- Added support for keeping track of load times....

chrome/renderer/render_view.cc

 // Copyright (c) 2006-2008 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.
 
 #include "chrome/renderer/render_view.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 64 matching lines @@
 //   * printing
 //   * theming
 //   * views
 #include "base/gfx/gdi_util.h"
 #include "base/gfx/native_theme.h"
 #include "chrome/common/gfx/emf.h"
 #include "chrome/views/controls/message_box_view.h"
 #include "skia/ext/vector_canvas.h"
 #endif
 
+using base::Time;
 using base::TimeDelta;
 using webkit_glue::WebAccessibility;
 using WebKit::WebConsoleMessage;
 using WebKit::WebScriptSource;
 
 //-----------------------------------------------------------------------------
 
 // define to write the time necessary for thumbnail/DOM text retrieval,
 // respectively, into the system debug log
 // #define TIME_BITMAP_RETRIEVAL
@@ skipping 32 matching lines @@
     "chrome-ui://chromewebdata/";
 
 static const char* const kBackForwardNavigationScheme = "history";
 
 namespace {
 
 // Associated with browser-initiated navigations to hold tracking data.
 class RenderViewExtraRequestData : public WebRequest::ExtraData {
  public:
   RenderViewExtraRequestData(int32 pending_page_id,
-                             PageTransition::Type transition)
+                             PageTransition::Type transition,
+                             Time request_time)
       : transition_type(transition),
+        request_time(request_time),
         request_committed(false),
         pending_page_id_(pending_page_id) {
   }
 
   // Contains the page_id for this navigation or -1 if there is none yet.
   int32 pending_page_id() const { return pending_page_id_; }
 
   // Is this a new navigation?
   bool is_new_navigation() const { return pending_page_id_ == -1; }
 
   // Contains the transition type that the browser specified when it
   // initiated the load.
   PageTransition::Type transition_type;
+  Time request_time;
 
   // True if we have already processed the "DidCommitLoad" event for this
   // request.  Used by session history.
   bool request_committed;
 
  private:
   int32 pending_page_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewExtraRequestData);
 };
@@ skipping 638 matching lines @@
     cache_policy = WebRequestReloadIgnoringCacheData;
   } else if (params.page_id != -1 || main_frame->GetInViewSourceMode()) {
     cache_policy = WebRequestReturnCacheDataElseLoad;
   } else {
     cache_policy = WebRequestUseProtocolCachePolicy;
   }
 
   scoped_ptr<WebRequest> request(WebRequest::Create(params.url));
   request->SetCachePolicy(cache_policy);
   request->SetExtraData(new RenderViewExtraRequestData(
-      params.page_id, params.transition));
+      params.page_id, params.transition, params.request_time));
 
   // If we are reloading, then WebKit will use the state of the current page.
   // Otherwise, we give it the state to navigate to.
   if (!is_reload)
     request->SetHistoryState(params.state);
 
   if (params.referrer.is_valid()) {
     request->SetHttpHeaderValue("Referer",
                                 params.referrer.spec());
   }
@@ skipping 379 matching lines @@
     WebView* webview,
     WebFrame* frame,
     NavigationGesture gesture) {
   if (webview->GetMainFrame() == frame) {
     navigation_gesture_ = gesture;
 
     // Make sure redirect tracking state is clear for the new load.
     completed_client_redirect_src_ = GURL();
   }
 
+  WebDataSource* ds = frame->GetProvisionalDataSource();
+  if (ds) {
+    const WebRequest& req = ds->GetRequest();
+    RenderViewExtraRequestData* extra_data =
+        static_cast<RenderViewExtraRequestData*>(req.GetExtraData());
+    if (extra_data) {
+      ds->SetRequestTime(extra_data->request_time);
+    }
+  }
   Send(new ViewHostMsg_DidStartProvisionalLoadForFrame(
        routing_id_, webview->GetMainFrame() == frame,
        frame->GetProvisionalDataSource()->GetRequest().GetURL()));
 }
 
 bool RenderView::DidLoadResourceFromMemoryCache(WebView* webview,
                                                 const WebRequest& request,
                                                 const WebResponse& response,
                                                 WebFrame* frame) {
   // Let the browser know we loaded a resource from the memory cache.  This
@@ skipping 184 matching lines @@
 void RenderView::DidReceiveTitle(WebView* webview,
                                  const std::wstring& title,
                                  WebFrame* frame) {
   UpdateTitle(frame, title);
 
   // Also check whether we have new encoding name.
   UpdateEncoding(frame, webview->GetMainFrameEncodingName());
 }
 
 void RenderView::DidFinishLoadForFrame(WebView* webview, WebFrame* frame) {
+  if (webview->GetMainFrame() == frame) {
+    const GURL& url = frame->GetURL();
+    if (url.SchemeIs("http") || url.SchemeIs("https"))
+      DumpLoadHistograms();
+  }
 }
 
 void RenderView::DidFailLoadWithError(WebView* webview,
                                       const WebError& error,
                                       WebFrame* frame) {
 }
 
 void RenderView::DidFinishDocumentLoadForFrame(WebView* webview,
                                                WebFrame* frame) {
   // Check whether we have new encoding name.
@@ skipping 1557 matching lines @@
 void RenderView::OnExtensionResponse(int callback_id,
                                      const std::string& response) {
   WebFrame* web_frame = pending_extension_callbacks_.Lookup(callback_id);
   if (!web_frame)
     return;  // The frame went away.
 
   extensions_v8::ExtensionProcessBindings::ExecuteCallbackInFrame(
       web_frame, callback_id, response);
   pending_extension_callbacks_.Remove(callback_id);
 }
+
+// Dump all load time histograms. We create 2 sets time based histograms,
+// one that is specific to the navigation type and one that aggregates all
+// navigation types
+//
+// Each set contains 5 histograms measuring various times.
+// The time points we keep are
+//    request: time document was requested by user
+//    start: time load of document started
+//    finishDoc: main document loaded, before onload()
+//    finish: after onload() and all resources are loaded
+// finish_document_load_time and finish_load_time.
+// The times that we histogram are
+//    requestToStart,
+//    startToFinishDoc,
+//    finishDocToFinish,
+//    startToFinish,
+//    requestToFinish,
+//
+void RenderView::DumpLoadHistograms() const {
+  WebFrame* main_frame = webview()->GetMainFrame();
+  WebDataSource* ds = main_frame->GetDataSource();
+  WebNavigationType nav_type = ds->GetNavigationType();
+  Time request_time = ds->GetRequestTime();
+  Time start_load_time = ds->GetStartLoadTime();
+  Time finish_document_load_time = ds->GetFinishDocumentLoadTime();
+  Time finish_load_time = ds->GetFinishLoadTime();
+  TimeDelta request_to_start = start_load_time - request_time;
+  TimeDelta start_to_finish_doc = finish_document_load_time - start_load_time;
+  TimeDelta finish_doc_to_finish = finish_load_time - finish_document_load_time;
+  TimeDelta start_to_finish = finish_load_time - start_load_time;
+  TimeDelta request_to_finish = finish_load_time - start_load_time;
+
+  UMA_HISTOGRAM_TIMES("Renderer.All.RequestToStart", request_to_start);
+  UMA_HISTOGRAM_TIMES("Renderer.All.StartToFinishDoc", start_to_finish_doc);
+  UMA_HISTOGRAM_TIMES("Renderer.All.FinishDocToFinish", finish_doc_to_finish);
+  UMA_HISTOGRAM_TIMES("Renderer.All.StartToFinish", start_to_finish);
+  UMA_HISTOGRAM_TIMES("Renderer.All.RequestToFinish", request_to_finish);
+  switch (nav_type) {
+    case WebNavigationTypeLinkClicked:
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.LinkClicked.RequestToStart", request_to_start);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.LinkClicked.StartToFinishDoc", start_to_finish_doc);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.LinkClicked.FinishDocToFinish", finish_doc_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.LinkClicked.RequestToFinish", request_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.LinkClicked.StartToFinish", start_to_finish);
+      break;
+    case WebNavigationTypeFormSubmitted:
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormSubmitted.RequestToStart", request_to_start);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormSubmitted.StartToFinishDoc", start_to_finish_doc);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormSubmitted.FinishDocToFinish", finish_doc_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormSubmitted.RequestToFinish", request_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormSubmitted.StartToFinish", start_to_finish);
+      break;
+    case WebNavigationTypeBackForward:
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.BackForward.RequestToStart", request_to_start);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.BackForward.StartToFinishDoc", start_to_finish_doc);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.BackForward.FinishDocToFinish", finish_doc_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.BackForward.RequestToFinish", request_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.BackForward.StartToFinish", start_to_finish);
+      break;
+    case WebNavigationTypeReload:
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Reload.RequestToStart", request_to_start);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Reload.StartToFinishDoc", start_to_finish_doc);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Reload.FinishDocToFinish", finish_doc_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Reload.RequestToFinish", request_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Reload.StartToFinish", start_to_finish);
+      break;
+    case WebNavigationTypeFormResubmitted:
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormResubmitted.RequestToStart", request_to_start);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormResubmitted.StartToFinishDoc", start_to_finish_doc);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormResubmitted.FinishDocToFinish", finish_doc_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormResubmitted.RequestToFinish", request_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.FormResubmitted.StartToFinish", start_to_finish);
+      break;
+    case WebNavigationTypeOther:
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Other.RequestToStart", request_to_start);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Other.StartToFinishDoc", start_to_finish_doc);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Other.FinishDocToFinish", finish_doc_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Other.RequestToFinish", request_to_finish);
+      UMA_HISTOGRAM_TIMES(
+          "Renderer.Other.StartToFinish", start_to_finish);
+      break;
+  }
+}