measure_page_load_time/ie_bho/MeasurePageLoadTimeBHO.cpp

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Implements a Browser Helper Object (BHO) which opens a socket
// and waits to receive URLs over it. Visits those URLs, measuring
// how long it takes between the start of navigation and the
// DocumentComplete event, and returns the time in milliseconds as
// a string to the caller.

#include "stdafx.h"
#include "MeasurePageLoadTimeBHO.h"

#define MAX_URL 1024                 // size of URL buffer
#define MAX_PAGELOADTIME (4*60*1000) // assume all pages take < 4 minutes
#define PORT 42492                   // port to listen on. Also jhaas's
                                     // old MSFT employee number


// Static function to serve as thread entry point, takes a "this"
// pointer as pParam and calls the method in the object
static DWORD WINAPI ProcessPageTimeRequests(LPVOID pThis) {
  reinterpret_cast<CMeasurePageLoadTimeBHO*>(pThis)->ProcessPageTimeRequests();

  return 0;
}


STDMETHODIMP CMeasurePageLoadTimeBHO::SetSite(IUnknown* pUnkSite)
{
    if (pUnkSite != NULL)
    {
        // Cache the pointer to IWebBrowser2.
        HRESULT hr = pUnkSite->QueryInterface(IID_IWebBrowser2, (void **)&m_spWebBrowser);
        if (SUCCEEDED(hr))
        {
            // Register to sink events from DWebBrowserEvents2.
            hr = DispEventAdvise(m_spWebBrowser);
            if (SUCCEEDED(hr))
            {
                m_fAdvised = TRUE;
            }

            // Stash the interface in the global interface table
            CComGITPtr<IWebBrowser2> git(m_spWebBrowser);
            m_dwCookie = git.Detach();

            // Create the event to be signaled when navigation completes.
            // Start it in nonsignaled state, and allow it to be triggered
            // when the initial page load is done.
            m_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

            // Create a thread to wait on the socket
            HANDLE hThread = CreateThread(NULL, 0, ::ProcessPageTimeRequests, this, 0, NULL);
        }
    }
    else
    {
        // Unregister event sink.
        if (m_fAdvised)
        {
            DispEventUnadvise(m_spWebBrowser);
            m_fAdvised = FALSE;
        }

        // Release cached pointers and other resources here.
        m_spWebBrowser.Release();
    }

    // Call base class implementation.
    return IObjectWithSiteImpl<CMeasurePageLoadTimeBHO>::SetSite(pUnkSite);
}


void STDMETHODCALLTYPE CMeasurePageLoadTimeBHO::OnDocumentComplete(IDispatch *pDisp, VARIANT *pvarURL)
{
    if (pDisp == m_spWebBrowser)
    {
        // Fire the event when the page is done loading
        // to unblock the other thread.
        SetEvent(m_hEvent);
    }
}


void CMeasurePageLoadTimeBHO::ProcessPageTimeRequests()
{
    CoInitialize(NULL);

    // The event will start in nonsignaled state, meaning that
    // the initial page load isn't done yet. Wait for that to
    // finish before doing anything.
    //
    // It seems to be the case that the BHO will get loaded
    // and SetSite called always before the initial page load
    // even begins, but just to be on the safe side, we won't
    // wait indefinitely.
    WaitForSingleObject(m_hEvent, MAX_PAGELOADTIME);

    // Retrieve the web browser interface from the global table
    CComGITPtr<IWebBrowser2> git(m_dwCookie);
    IWebBrowser2* browser;
    git.CopyTo(&browser);

    // Create a listening socket
    m_sockListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (m_sockListen == SOCKET_ERROR)
        ErrorExit();

    BOOL on = TRUE;
    if (setsockopt(m_sockListen, SOL_SOCKET, SO_REUSEADDR,
                   (const char*)&on, sizeof(on)))
        ErrorExit();

    // Bind the listening socket
    SOCKADDR_IN addrBind;

    addrBind.sin_family      = AF_INET;
    addrBind.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    addrBind.sin_port        = htons(PORT);

    if (bind(m_sockListen, (sockaddr*)&addrBind, sizeof(addrBind)))
        ErrorExit();

    // Listen for incoming connections
    if (listen(m_sockListen, 1))
        ErrorExit();

    // Ensure the socket is blocking... it should be by default, but
    // it can't hurt to make sure
    unsigned long nNonblocking = 0;
    if (ioctlsocket(m_sockListen, FIONBIO, &nNonblocking))
        ErrorExit();

    m_sockTransport = 0;

    // Loop indefinitely waiting for connections
    while(1)
    {
        SOCKADDR_IN addrConnected;
        int         sConnected = sizeof(addrConnected);

        // Wait for a client to connect and send a URL
        m_sockTransport = accept(
            m_sockListen, (sockaddr*)&addrConnected, &sConnected);

        if (m_sockTransport == SOCKET_ERROR)
            ErrorExit();

        char pbBuffer[MAX_URL], strURL[MAX_URL];
        DWORD cbRead, cbWritten;

        bool fDone = false;

        // Loop until we're done with this client
        while (!fDone)
        {
            *strURL = '\0';
            bool fReceivedCR = false;

            do
            {
                // Only receive up to the first carriage return
                cbRead = recv(m_sockTransport, pbBuffer, MAX_URL-1, MSG_PEEK);

                // An error on read most likely means that the remote peer
                // closed the connection. Go back to waiting
                if (cbRead == 0)
                {
                    fDone = true;
                    break;
                }

                // Null terminate the received characters so strchr() is safe
                pbBuffer[cbRead] = '\0';

                if(char* pchFirstCR = strchr(pbBuffer, '\n'))
                {
                    cbRead = (DWORD)(pchFirstCR - pbBuffer + 1);
                    fReceivedCR = true;
                }

                // The below call will not block, since we determined with
                // MSG_PEEK that at least cbRead bytes are in the TCP receive buffer
                recv(m_sockTransport, pbBuffer, cbRead, 0);
                pbBuffer[cbRead] = '\0';

                strcat_s(strURL, sizeof(strURL), pbBuffer);
            } while (!fReceivedCR);

            // If an error occurred while reading, exit this loop
            if (fDone)
                break;

            // Strip the trailing CR and/or LF
            int i;
            for (i = (int)strlen(strURL)-1; i >= 0 && isspace(strURL[i]); i--)
            {
                strURL[i] = '\0';
            }

            if (i < 0)
            {
                // Sending a carriage return on a line by itself means that
                // the client is done making requests
                fDone = true;
            }
            else
            {
                // Send the browser to the requested URL
                CComVariant vNavFlags( navNoReadFromCache );
                CComVariant vTargetFrame("_self");
                CComVariant vPostData("");
                CComVariant vHTTPHeaders("");

                ResetEvent(m_hEvent);
                DWORD dwStartTime = GetTickCount();

                HRESULT hr = browser->Navigate(
                    CComBSTR(strURL),
                    &vNavFlags,
                    &vTargetFrame, // TargetFrameName
                    &vPostData, // PostData
                    &vHTTPHeaders // Headers
                    );

                // The main browser thread will call OnDocumentComplete() when
                // the page is done loading, which will in turn trigger
                // m_hEvent. Wait here until then; the event will reset itself
                // once this thread is released
                if (WaitForSingleObject(m_hEvent, MAX_PAGELOADTIME) == WAIT_TIMEOUT)
                {
                    sprintf_s(pbBuffer, sizeof(pbBuffer), "%s,timeout\n", strURL);

                    browser->Stop();
                }
                else
                {
                    // Format the elapsed time as a string
                    DWORD dwLoadTime = GetTickCount() - dwStartTime;
                    sprintf_s(
                        pbBuffer, sizeof(pbBuffer), "%s,%d\n", strURL, dwLoadTime);
                }

                // Send the result. Just in case the TCP buffer can't handle
                // the whole thing, send in parts if necessary
                char *chSend = pbBuffer;

                while (*chSend)
                {
                    cbWritten = send(
                        m_sockTransport, chSend, (int)strlen(chSend), 0);

                    // Error on send probably means connection reset by peer
                    if (cbWritten == 0)
                    {
                        fDone = true;
                        break;
                    }

                    chSend += cbWritten;
                }
            }
        }

        // Close the transport socket and wait for another connection
        closesocket(m_sockTransport);
        m_sockTransport = 0;
    }
}


void CMeasurePageLoadTimeBHO::ErrorExit()
{
    // Unlink from IE, close the sockets, then terminate this
    // thread
    SetSite(NULL);

    if (m_sockTransport && m_sockTransport != SOCKET_ERROR)
    {
        closesocket(m_sockTransport);
        m_sockTransport = 0;
    }

    if (m_sockListen && m_sockListen != SOCKET_ERROR)
    {
        closesocket(m_sockListen);
        m_sockListen = 0;
    }

    TerminateThread(GetCurrentThread(), -1);
}