chrome.loadTimes() shouldn't be affected by in-document navigation.

chrome/renderer/page_load_histograms.cc

 // Copyright (c) 2011 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/page_load_histograms.h"
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
@@ skipping 32 matching lines @@
   if (url.SchemeIs("http"))
     return URLPattern::SCHEME_HTTP;
   else if (url.SchemeIs("https"))
     return URLPattern::SCHEME_HTTPS;
   return static_cast<URLPattern::SchemeMasks>(0);
 }
 
 static void DumpWebTiming(const Time& navigation_start,
                           const Time& load_event_start,
                           const Time& load_event_end,
-                          content::NavigationState* navigation_state) {
+                          NavigationState::LoadTimes* load_times) {
   if (navigation_start.is_null() ||
       load_event_start.is_null() ||
       load_event_end.is_null())
     return;
 
-  if (navigation_state->web_timing_histograms_recorded())
+  if (load_times->web_timing_histograms_recorded())
     return;
-  navigation_state->set_web_timing_histograms_recorded(true);
+  load_times->set_web_timing_histograms_recorded(true);
 
   // TODO(tonyg): There are many new details we can record, add them after the
   // basic metrics are evaluated.
   // TODO(simonjam): There is no way to distinguish between abandonment and
   // intentional Javascript navigation before the load event fires.
   PLT_HISTOGRAM("PLT.NavStartToLoadStart", load_event_start - navigation_start);
   PLT_HISTOGRAM("PLT.NavStartToLoadEnd", load_event_end - navigation_start);
 }
 
 enum MissingStartType {
@@ skipping 31 matching lines @@
       GetSupportedSchemeType(frame->document().url());
   if (scheme_type == 0)
     return;
 
   // Ignore multipart requests.
   if (frame->dataSource()->response().isMultipartPayload())
     return;
 
   NavigationState* navigation_state =
       NavigationState::FromDataSource(frame->dataSource());
+  NavigationState::LoadTimes* load_times = navigation_state->load_times();
 
   // Times based on the Web Timing metrics.
   // http://www.w3.org/TR/navigation-timing/
   // TODO(tonyg, jar): We are in the process of vetting these metrics against
   // the existing ones. Once we understand any differences, we will standardize
   // on a single set of metrics.
   const WebPerformance& performance = frame->performance();
   Time navigation_start = Time::FromDoubleT(performance.navigationStart());
   Time load_event_start = Time::FromDoubleT(performance.loadEventStart());
   Time load_event_end = Time::FromDoubleT(performance.loadEventEnd());
-  DumpWebTiming(navigation_start, load_event_start, load_event_end,
-                navigation_state);
+  DumpWebTiming(navigation_start, load_event_start, load_event_end, load_times);
 
   // If we've already dumped, do nothing.
   // This simple bool works because we only dump for the main frame.
-  if (navigation_state->load_histograms_recorded())
+  if (load_times->load_histograms_recorded())
     return;
 
   // Collect measurement times.
-  Time start = navigation_state->start_load_time();
-  Time commit = navigation_state->commit_load_time();
+  Time start = load_times->start_load_time();
+  Time commit = load_times->commit_load_time();
 
   // TODO(tonyg, jar): Start can be missing after an in-document navigation and
   // possibly other cases like a very premature abandonment of the page.
   // The PLT.MissingStart histogram should help us troubleshoot and then we can
   // remove this.
   int missing_start_type = 0;
   missing_start_type |= start.is_null() ? START_MISSING : 0;
   missing_start_type |= commit.is_null() ? COMMIT_MISSING : 0;
   missing_start_type |= navigation_start.is_null() ? NAV_START_MISSING : 0;
   UMA_HISTOGRAM_ENUMERATION("PLT.MissingStart", missing_start_type,
                             MISSING_START_TYPE_MAX);
   if (missing_start_type)
     return;
 
   // We properly handle null values for the next 3 variables.
-  Time request = navigation_state->request_time();
-  Time first_paint = navigation_state->first_paint_time();
-  Time first_paint_after_load = navigation_state->first_paint_after_load_time();
-  Time finish_doc = navigation_state->finish_document_load_time();
-  Time finish_all_loads = navigation_state->finish_load_time();
+  Time request = load_times->request_time();
+  Time first_paint = load_times->first_paint_time();
+  Time first_paint_after_load = load_times->first_paint_after_load_time();
+  Time finish_doc = load_times->finish_document_load_time();
+  Time finish_all_loads = load_times->finish_load_time();
 
   // TODO(tonyg, jar): We suspect a bug in abandonment counting, this temporary
   // histogram should help us to troubleshoot.
   int abandon_type = 0;
   abandon_type |= finish_doc.is_null() ? FINISH_DOC_MISSING : 0;
   abandon_type |= finish_all_loads.is_null() ? FINISH_ALL_LOADS_MISSING : 0;
   abandon_type |= load_event_start.is_null() ? LOAD_EVENT_START_MISSING : 0;
   abandon_type |= load_event_end.is_null() ? LOAD_EVENT_END_MISSING : 0;
   UMA_HISTOGRAM_ENUMERATION("PLT.AbandonType", abandon_type, ABANDON_TYPE_MAX);
 
   // Handle case where user hits "stop" or "back" before loading completely.
   bool abandoned_page = finish_doc.is_null();
   if (abandoned_page) {
     finish_doc = Time::Now();
-    navigation_state->set_finish_document_load_time(finish_doc);
+    load_times->set_finish_document_load_time(finish_doc);
   }
 
   // TODO(jar): We should really discriminate the definition of "abandon" more
   // finely.  We should have:
   // abandon_before_document_loaded
   // abandon_before_onload_fired
 
   if (finish_all_loads.is_null()) {
     finish_all_loads = Time::Now();
-    navigation_state->set_finish_load_time(finish_all_loads);
+    load_times->set_finish_load_time(finish_all_loads);
   } else {
     DCHECK(!abandoned_page);  // How can the doc have finished but not the page?
     if (abandoned_page)
       return;  // Don't try to record a stat which is broken.
   }
 
-  navigation_state->set_load_histograms_recorded(true);
+  load_times->set_load_histograms_recorded(true);
 
   // Note: Client side redirects will have no request time.
   Time begin = request.is_null() ? start : request;
   TimeDelta begin_to_finish_doc = finish_doc - begin;
   TimeDelta begin_to_finish_all_loads = finish_all_loads - begin;
   TimeDelta start_to_finish_all_loads = finish_all_loads - start;
   TimeDelta start_to_commit = commit - start;
 
   NavigationState::LoadType load_type = navigation_state->load_type();
 
@@ skipping 554 matching lines @@
   // but didn't get SPDY.
   static const bool use_spdy_histogram =
       base::FieldTrialList::TrialExists("SpdyImpact");
   if (use_spdy_histogram) {
     // We take extra effort to only compute these once.
     static bool in_spdy_trial = base::FieldTrialList::Find(
         "SpdyImpact")->group_name() == "npn_with_spdy";
     static bool in_http_trial = base::FieldTrialList::Find(
         "SpdyImpact")->group_name() == "npn_with_http";
 
-    bool spdy_trial_success = navigation_state->was_fetched_via_spdy() ?
+    bool spdy_trial_success = load_times->was_fetched_via_spdy() ?
         in_spdy_trial : in_http_trial;
     if (spdy_trial_success) {
       // Histograms to determine if SPDY has an impact for https traffic.
       // TODO(mbelshe): After we've seen the difference between BeginToFinish
       //                and StartToFinish, consider removing one or the other.
       if (scheme_type == URLPattern::SCHEME_HTTPS &&
-          navigation_state->was_npn_negotiated()) {
+          load_times->was_npn_negotiated()) {
         UMA_HISTOGRAM_ENUMERATION(
             base::FieldTrial::MakeName("PLT.Abandoned", "SpdyImpact"),
             abandoned_page ? 1 : 0, 2);
         switch (load_type) {
           case NavigationState::LINK_LOAD_NORMAL:
             PLT_HISTOGRAM(base::FieldTrial::MakeName(
                 "PLT.BeginToFinish_LinkLoadNormal", "SpdyImpact"),
                 begin_to_finish_all_loads);
             PLT_HISTOGRAM(base::FieldTrial::MakeName(
                 "PLT.StartToFinish_LinkLoadNormal", "SpdyImpact"),
@@ skipping 14 matching lines @@
                 start_to_commit);
             break;
           default:
             break;
         }
       }
 
       // Histograms to compare the impact of alternate protocol over http
       // traffic: when spdy is used vs. when http is used.
       if (scheme_type == URLPattern::SCHEME_HTTP &&
-          navigation_state->was_alternate_protocol_available()) {
-        if (!navigation_state->was_npn_negotiated()) {
+          load_times->was_alternate_protocol_available()) {
+        if (!load_times->was_npn_negotiated()) {
           // This means that even there is alternate protocols for npn_http or
           // npn_spdy, they are not taken (due to the base::FieldTrial).
           switch (load_type) {
             case NavigationState::LINK_LOAD_NORMAL:
               PLT_HISTOGRAM(
                   "PLT.StartToFinish_LinkLoadNormal_AlternateProtocol_http",
                   start_to_finish_all_loads);
               PLT_HISTOGRAM(
                   "PLT.StartToCommit_LinkLoadNormal_AlternateProtocol_http",
                   start_to_commit);
               break;
             case NavigationState::NORMAL_LOAD:
               PLT_HISTOGRAM(
                   "PLT.StartToFinish_NormalLoad_AlternateProtocol_http",
                   start_to_finish_all_loads);
               PLT_HISTOGRAM(
                   "PLT.StartToCommit_NormalLoad_AlternateProtocol_http",
                   start_to_commit);
               break;
             default:
               break;
           }
-        } else if (navigation_state->was_fetched_via_spdy()) {
+        } else if (load_times->was_fetched_via_spdy()) {
           switch (load_type) {
             case NavigationState::LINK_LOAD_NORMAL:
               PLT_HISTOGRAM(
                   "PLT.StartToFinish_LinkLoadNormal_AlternateProtocol_spdy",
                   start_to_finish_all_loads);
               PLT_HISTOGRAM(
                   "PLT.StartToCommit_LinkLoadNormal_AlternateProtocol_spdy",
                   start_to_commit);
               break;
             case NavigationState::NORMAL_LOAD:
               PLT_HISTOGRAM(
                   "PLT.StartToFinish_NormalLoad_AlternateProtocol_spdy",
                   start_to_finish_all_loads);
               PLT_HISTOGRAM(
                   "PLT.StartToCommit_NormalLoad_AlternateProtocol_spdy",
                   start_to_commit);
               break;
             default:
               break;
           }
         }
       }
     }
   }
 
   // Record SpdyCwnd field trial results.
-  if (navigation_state->was_fetched_via_spdy()) {
+  if (load_times->was_fetched_via_spdy()) {
     switch (load_type) {
       case NavigationState::LINK_LOAD_NORMAL:
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_LinkLoadNormal", "SpdyCwnd"),
             begin_to_finish_all_loads);
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.StartToFinish_LinkLoadNormal", "SpdyCwnd"),
             start_to_finish_all_loads);
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.StartToCommit_LinkLoadNormal", "SpdyCwnd"),
             start_to_commit);
         break;
       case NavigationState::NORMAL_LOAD:
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.BeginToFinish_NormalLoad", "SpdyCwnd"),
             begin_to_finish_all_loads);
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.StartToFinish_NormalLoad", "SpdyCwnd"),
             start_to_finish_all_loads);
         PLT_HISTOGRAM(base::FieldTrial::MakeName(
             "PLT.StartToCommit_NormalLoad", "SpdyCwnd"),
             start_to_commit);
         break;
       default:
         break;
     }
   }
 
   // Record page load time and abandonment rates for proxy cases.
-  if (navigation_state->was_fetched_via_proxy()) {
+  if (load_times->was_fetched_via_proxy()) {
     if (scheme_type == URLPattern::SCHEME_HTTPS) {
       PLT_HISTOGRAM("PLT.StartToFinish.Proxy.https", start_to_finish_all_loads);
       UMA_HISTOGRAM_ENUMERATION("PLT.Abandoned.Proxy.https",
                                 abandoned_page ? 1 : 0, 2);
     } else {
       DCHECK(scheme_type == URLPattern::SCHEME_HTTP);
       PLT_HISTOGRAM("PLT.StartToFinish.Proxy.http", start_to_finish_all_loads);
       UMA_HISTOGRAM_ENUMERATION("PLT.Abandoned.Proxy.http",
                                 abandoned_page ? 1 : 0, 2);
     }
@@ skipping 12 matching lines @@
     }
   }
 
   // Site isolation metrics.
   UMA_HISTOGRAM_COUNTS("SiteIsolation.PageLoadsWithCrossSiteFrameAccess",
                        cross_origin_access_count_);
   UMA_HISTOGRAM_COUNTS("SiteIsolation.PageLoadsWithSameSiteFrameAccess",
                        same_origin_access_count_);
 
   // Log the PLT to the info log.
-  LogPageLoadTime(navigation_state, frame->dataSource());
+  LogPageLoadTime(load_times, frame->dataSource());
 
   // Record prerendering histograms.
   prerender::PrerenderHelper::RecordHistograms(render_view(),
                                                finish_all_loads,
                                                begin_to_finish_all_loads);
 
   // Since there are currently no guarantees that renderer histograms will be
   // sent to the browser, we initiate a PostTask here to be sure that we send
   // the histograms we generated.  Without this call, pages that don't have an
   // on-close-handler might generate data that is lost when the renderer is
@@ skipping 15 matching lines @@
 }
 
 void PageLoadHistograms::ClosePage() {
   // TODO(davemoore) This code should be removed once willClose() gets
   // called when a page is destroyed. page_load_histograms_.Dump() is safe
   // to call multiple times for the same frame, but it will simplify things.
   Dump(render_view()->GetWebView()->mainFrame());
   ResetCrossFramePropertyAccess();
 }
 
-void PageLoadHistograms::LogPageLoadTime(const NavigationState* state,
-                                         const WebDataSource* ds) const {
+void PageLoadHistograms::LogPageLoadTime(
+    const NavigationState::LoadTimes* load_times,
+    const WebDataSource* ds) const {
   // Because this function gets called on every page load,
   // take extra care to optimize it away if logging is turned off.
   if (logging::LOG_INFO < logging::GetMinLogLevel())
     return;
 
-  DCHECK(state);
+  DCHECK(load_times);
   DCHECK(ds);
   GURL url(ds->request().url());
-  Time start = state->start_load_time();
-  Time finish = state->finish_load_time();
+  Time start = load_times->start_load_time();
+  Time finish = load_times->finish_load_time();
   // TODO(mbelshe): should we log more stats?
   VLOG(1) << "PLT: " << (finish - start).InMilliseconds() << "ms "
           << url.spec();
 }