tools/measure_page_load_time/ie_bho/MeasurePageLoadTimeBHO.cpp - chromium/src - Git at Google

 // 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);
 }
	// 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 (4601000) // 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);
	}