Add HTTPS specific UMA for data reduction proxy requests

chrome/renderer/page_load_histograms.cc

 // 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.
 
 #include "chrome/renderer/page_load_histograms.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 92 matching lines @@
           name, websearch_chrome_joint_experiment_id);                         \
       PltHistogramWithNoMacroCaching(name_with_experiment_id, sample);         \
     }                                                                          \
   }                                                                            \
   PltHistogramWithGwsPreview(name, sample, is_preview,                         \
                              websearch_chrome_joint_experiment_id);            \
 }
 
 // In addition to PLT_HISTOGRAM, add the *_DataReductionProxy variant
 // conditionally. This macro runs only in one thread.
-#define PLT_HISTOGRAM_DRP(name, sample, data_reduction_proxy_was_used) \
+#define PLT_HISTOGRAM_DRP(                                              \
+    name, sample, data_reduction_proxy_was_used, scheme_type)           \
   do {                                                                  \
     static base::HistogramBase* counter(NULL);                          \
     static base::HistogramBase* drp_counter(NULL);                      \
+    static base::HistogramBase* https_drp_counter(NULL);                \
     if (!counter) {                                                     \
       DCHECK(drp_counter == NULL);                                      \
+      DCHECK(https_drp_counter == NULL);                                \
       counter = base::Histogram::FactoryTimeGet(                        \
           name, kPLTMin(), kPLTMax(), kPLTCount,                        \
           base::Histogram::kUmaTargetedHistogramFlag);                  \
     }                                                                   \
     counter->AddTime(sample);                                           \
     if (!data_reduction_proxy_was_used) break;                          \
-    if (!drp_counter) {                                                 \
-      drp_counter = base::Histogram::FactoryTimeGet(                    \
-          std::string(name) + "_DataReductionProxy",                    \
-          kPLTMin(), kPLTMax(), kPLTCount,                              \
-          base::Histogram::kUmaTargetedHistogramFlag);                  \
+    if ((scheme_type & URLPattern::SCHEME_HTTPS) == 0) {                \
+      if (!https_drp_counter) {                                         \
+        https_drp_counter = base::Histogram::FactoryTimeGet(            \
+            std::string(name) + "_DataReductionProxy",                  \
+            kPLTMin(), kPLTMax(), kPLTCount,                            \
+            base::Histogram::kUmaTargetedHistogramFlag);                \
+      }                                                                 \
+      https_drp_counter->AddTime(sample);                               \
+    } else {                                                            \
+      if (!drp_counter) {                                               \
+        drp_counter = base::Histogram::FactoryTimeGet(                  \
+            std::string(name) + "_HTTPS_DataReductionProxy",            \
+            kPLTMin(), kPLTMax(), kPLTCount,                            \
+            base::Histogram::kUmaTargetedHistogramFlag);                \
+      }                                                                 \
+      drp_counter->AddTime(sample);                                     \
     }                                                                   \
-    drp_counter->AddTime(sample);                                       \
   } while (0)
 
 // Returns the scheme type of the given URL if its type is one for which we
 // dump page load histograms. Otherwise returns NULL.
 URLPattern::SchemeMasks GetSupportedSchemeType(const GURL& url) {
   if (url.SchemeIs("http"))
     return URLPattern::SCHEME_HTTP;
   else if (url.SchemeIs("https"))
     return URLPattern::SCHEME_HTTPS;
   return static_cast<URLPattern::SchemeMasks>(0);
 }
 
 // Helper function to check for string in 'via' header. Returns true if
 // |via_value| is one of the values listed in the Via header.
 bool ViaHeaderContains(WebFrame* frame, const std::string& via_value) {
   const char kViaHeaderName[] = "Via";
   std::vector<std::string> values;
   // Multiple via headers have already been coalesced and hence each value
   // separated by a comma corresponds to a proxy. The value added by a proxy is
   // not expected to contain any commas.
   // Example., Via: 1.0 Compression proxy, 1.1 Google Instant Proxy Preview
   base::SplitString(
       frame->dataSource()->response().httpHeaderField(kViaHeaderName).utf8(),
       ',', &values);
   return std::find(values.begin(), values.end(), via_value) != values.end();
 }
 
-// Returns true if the data reduction proxy was used. Note, this function will
-// produce a false positive if a page is fetched using SPDY and using a proxy,
-// and the data reduction proxy's via value is added to the Via header.
-// TODO(bengr): Plumb the hostname of the proxy and check if it matches
-// |SPDY_PROXY_AUTH_ORIGIN|.
-bool DataReductionProxyWasUsed(WebFrame* frame) {
-  DocumentState* document_state =
-      DocumentState::FromDataSource(frame->dataSource());
-  if (!document_state->was_fetched_via_proxy())
-    return false;
-
-  std::string via_header =
-      base::UTF16ToUTF8(frame->dataSource()->response().httpHeaderField("Via"));
-
-  if (via_header.empty())
-    return false;
-  std::string headers = "HTTP/1.1 200 OK\nVia: " + via_header + "\n\n";
-  // Produce raw headers, expected by the |HttpResponseHeaders| constructor.
-  std::replace(headers.begin(), headers.end(), '\n', '\0');
-  scoped_refptr<net::HttpResponseHeaders> response_headers(
-      new net::HttpResponseHeaders(headers));
-  return data_reduction_proxy::HasDataReductionProxyViaHeader(
-      response_headers.get(), NULL);
-}
-
 // Returns true if the provided URL is a referrer string that came from
 // a Google Web Search results page. This is a little non-deterministic
 // because desktop and mobile websearch differ and sometimes just provide
 // http://www.google.com/ as the referrer. In the case of /url we can be sure
 // that it came from websearch but we will be generous and allow for cases
 // where a non-Google URL was provided a bare Google URL as a referrer.
 // The domain validation matches the code used by the prerenderer for similar
 // purposes.
 // TODO(pmeenan): Remove the fuzzy logic when the referrer is reliable
 bool IsFromGoogleSearchResult(const GURL& url, const GURL& referrer) {
@@ skipping 26 matching lines @@
   if (0 < experiment_id && experiment_id <= kMaxExperimentID)
     return experiment_id;
   return kNoExperiment;
 }
 
 void DumpHistograms(const WebPerformance& performance,
                     DocumentState* document_state,
                     bool data_reduction_proxy_was_used,
                     bool came_from_websearch,
                     int websearch_chrome_joint_experiment_id,
-                    bool is_preview) {
+                    bool is_preview,
+                    URLPattern::SchemeMasks scheme_type) {
   // This function records new histograms based on the Navigation Timing
   // records. As such, the histograms should not depend on the deprecated timing
   // information collected in DocumentState. However, here for some reason we
   // check if document_state->request_time() is null. TODO(ppi): find out why
   // and remove DocumentState from the parameter list.
   Time request = document_state->request_time();
 
   Time navigation_start = Time::FromDoubleT(performance.navigationStart());
   Time redirect_start = Time::FromDoubleT(performance.redirectStart());
   Time redirect_end = Time::FromDoubleT(performance.redirectEnd());
@@ skipping 31 matching lines @@
   // |load_event_end| may be NULL as in the non-PT_ case below. Examples in
   // http://crbug.com/112006.
   // DCHECK(!load_event_start.is_null());
   // DCHECK(!load_event_end.is_null());
 
   if (document_state->web_timing_histograms_recorded())
     return;
   document_state->set_web_timing_histograms_recorded(true);
 
   if (!redirect_start.is_null() && !redirect_end.is_null()) {
-    PLT_HISTOGRAM_DRP("PLT.NT_Redirect", redirect_end - redirect_start,
-                      data_reduction_proxy_was_used);
+    PLT_HISTOGRAM_DRP("PLT.NT_Redirect",
+                      redirect_end - redirect_start,
+                      data_reduction_proxy_was_used,
+                      scheme_type);
     PLT_HISTOGRAM_DRP(
         "PLT.NT_DelayBeforeFetchRedirect",
         (fetch_start - navigation_start) - (redirect_end - redirect_start),
-        data_reduction_proxy_was_used);
+        data_reduction_proxy_was_used,
+        scheme_type);
   } else {
     PLT_HISTOGRAM_DRP("PLT.NT_DelayBeforeFetch",
                       fetch_start - navigation_start,
-                      data_reduction_proxy_was_used);
+                      data_reduction_proxy_was_used,
+                      scheme_type);
   }
   PLT_HISTOGRAM_DRP("PLT.NT_DelayBeforeDomainLookup",
                     domain_lookup_start - fetch_start,
-                    data_reduction_proxy_was_used);
+                    data_reduction_proxy_was_used,
+                    scheme_type);
   PLT_HISTOGRAM_DRP("PLT.NT_DomainLookup",
                     domain_lookup_end - domain_lookup_start,
-                    data_reduction_proxy_was_used);
+                    data_reduction_proxy_was_used,
+                    scheme_type);
   PLT_HISTOGRAM_DRP("PLT.NT_DelayBeforeConnect",
                     connect_start - domain_lookup_end,
-                    data_reduction_proxy_was_used);
-  PLT_HISTOGRAM_DRP("PLT.NT_Connect", connect_end - connect_start,
-                    data_reduction_proxy_was_used);
+                    data_reduction_proxy_was_used,
+                    scheme_type);
+  PLT_HISTOGRAM_DRP("PLT.NT_Connect",
+                    connect_end - connect_start,
+                    data_reduction_proxy_was_used,
+                    scheme_type);
   PLT_HISTOGRAM_DRP("PLT.NT_DelayBeforeRequest",
                     request_start - connect_end,
-                    data_reduction_proxy_was_used);
-  PLT_HISTOGRAM_DRP("PLT.NT_Request", response_start - request_start,
-                    data_reduction_proxy_was_used);
-  PLT_HISTOGRAM_DRP("PLT.NT_Response", response_end - response_start,
-                    data_reduction_proxy_was_used);
+                    data_reduction_proxy_was_used,
+                    scheme_type);
+  PLT_HISTOGRAM_DRP("PLT.NT_Request",
+                    response_start - request_start,
+                    data_reduction_proxy_was_used,
+                    scheme_type);
+  PLT_HISTOGRAM_DRP("PLT.NT_Response",
+                    response_end - response_start,
+                    data_reduction_proxy_was_used,
+                    scheme_type);
 
   if (!dom_loading.is_null()) {
     PLT_HISTOGRAM_DRP("PLT.NT_DelayBeforeDomLoading",
                       dom_loading - response_start,
-                      data_reduction_proxy_was_used);
+                      data_reduction_proxy_was_used,
+                      scheme_type);
   }
   if (!dom_interactive.is_null() && !dom_loading.is_null()) {
     PLT_HISTOGRAM_DRP("PLT.NT_DomLoading",
                       dom_interactive - dom_loading,
-                      data_reduction_proxy_was_used);
+                      data_reduction_proxy_was_used,
+                      scheme_type);
   }
   if (!dom_content_loaded_start.is_null() && !dom_interactive.is_null()) {
     PLT_HISTOGRAM_DRP("PLT.NT_DomInteractive",
                       dom_content_loaded_start - dom_interactive,
-                      data_reduction_proxy_was_used);
+                      data_reduction_proxy_was_used,
+                      scheme_type);
   }
   if (!dom_content_loaded_start.is_null() &&
       !dom_content_loaded_end.is_null() ) {
     PLT_HISTOGRAM_DRP("PLT.NT_DomContentLoaded",
                       dom_content_loaded_end - dom_content_loaded_start,
-                      data_reduction_proxy_was_used);
+                      data_reduction_proxy_was_used,
+                      scheme_type);
   }
   if (!dom_content_loaded_end.is_null() && !load_event_start.is_null()) {
     PLT_HISTOGRAM_DRP("PLT.NT_DelayBeforeLoadEvent",
                       load_event_start - dom_content_loaded_end,
-                      data_reduction_proxy_was_used);
+                      data_reduction_proxy_was_used,
+                      scheme_type);
   }
 
   // TODO(simonjam): There is no way to distinguish between abandonment and
   // intentional Javascript navigation before the load event fires.
   // TODO(dominich): Load type breakdown
   if (!load_event_start.is_null()) {
     PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_BeginToFinishDoc",
                                    load_event_start - begin,
                                    came_from_websearch,
                                    websearch_chrome_joint_experiment_id,
                                    is_preview);
     PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_CommitToFinishDoc",
                                    load_event_start - response_start,
                                    came_from_websearch,
                                    websearch_chrome_joint_experiment_id,
                                    is_preview);
     PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_RequestToFinishDoc",
                                    load_event_start - navigation_start,
                                    came_from_websearch,
                                    websearch_chrome_joint_experiment_id,
                                    is_preview);
     if (data_reduction_proxy_was_used) {
-      PLT_HISTOGRAM("PLT.PT_BeginToFinishDoc_DataReductionProxy",
-                    load_event_start - begin);
-      PLT_HISTOGRAM("PLT.PT_CommitToFinishDoc_DataReductionProxy",
-                    load_event_start - response_start);
-      PLT_HISTOGRAM("PLT.PT_RequestToFinishDoc_DataReductionProxy",
-                    load_event_start - navigation_start);
+      if ((scheme_type & URLPattern::SCHEME_HTTPS) == 0) {
+        PLT_HISTOGRAM("PLT.PT_BeginToFinishDoc_DataReductionProxy",
+                      load_event_start - begin);
+        PLT_HISTOGRAM("PLT.PT_CommitToFinishDoc_DataReductionProxy",
+                      load_event_start - response_start);
+        PLT_HISTOGRAM("PLT.PT_RequestToFinishDoc_DataReductionProxy",
+                      load_event_start - navigation_start);
+      } else {
+        PLT_HISTOGRAM("PLT.PT_BeginToFinishDoc_HTTPS_DataReductionProxy",
+                      load_event_start - begin);
+        PLT_HISTOGRAM("PLT.PT_CommitToFinishDoc_HTTPS_DataReductionProxy",
+                      load_event_start - response_start);
+        PLT_HISTOGRAM("PLT.PT_RequestToFinishDoc_HTTPS_DataReductionProxy",
+                      load_event_start - navigation_start);
+      }
     }
   }
   if (!load_event_end.is_null()) {
     PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_BeginToFinish",
                                    load_event_end - begin,
                                    came_from_websearch,
                                    websearch_chrome_joint_experiment_id,
                                    is_preview);
     PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_CommitToFinish",
                                    load_event_end - response_start,
                                    came_from_websearch,
                                    websearch_chrome_joint_experiment_id,
                                    is_preview);
     PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_RequestToFinish",
                                    load_event_end - navigation_start,
                                    came_from_websearch,
                                    websearch_chrome_joint_experiment_id,
                                    is_preview);
     PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_StartToFinish",
                                    load_event_end - request_start,
                                    came_from_websearch,
                                    websearch_chrome_joint_experiment_id,
                                    is_preview);
     if (data_reduction_proxy_was_used) {
-      PLT_HISTOGRAM("PLT.PT_BeginToFinish_DataReductionProxy",
-                    load_event_end - begin);
-      PLT_HISTOGRAM("PLT.PT_CommitToFinish_DataReductionProxy",
-                    load_event_end - response_start);
-      PLT_HISTOGRAM("PLT.PT_RequestToFinish_DataReductionProxy",
-                    load_event_end - navigation_start);
-      PLT_HISTOGRAM("PLT.PT_StartToFinish_DataReductionProxy",
-                    load_event_end - request_start);
+      if ((scheme_type & URLPattern::SCHEME_HTTPS) == 0) {
+        PLT_HISTOGRAM("PLT.PT_BeginToFinish_DataReductionProxy",
+                      load_event_end - begin);
+        PLT_HISTOGRAM("PLT.PT_CommitToFinish_DataReductionProxy",
+                      load_event_end - response_start);
+        PLT_HISTOGRAM("PLT.PT_RequestToFinish_DataReductionProxy",
+                      load_event_end - navigation_start);
+        PLT_HISTOGRAM("PLT.PT_StartToFinish_DataReductionProxy",
+                      load_event_end - request_start);
+      } else {
+        PLT_HISTOGRAM("PLT.PT_BeginToFinish_HTTPS_DataReductionProxy",
+                      load_event_end - begin);
+        PLT_HISTOGRAM("PLT.PT_CommitToFinish_HTTPS_DataReductionProxy",
+                      load_event_end - response_start);
+        PLT_HISTOGRAM("PLT.PT_RequestToFinish_HTTPS_DataReductionProxy",
+                      load_event_end - navigation_start);
+        PLT_HISTOGRAM("PLT.PT_StartToFinish_HTTPS_DataReductionProxy",
+                      load_event_end - request_start);
+      }
     }
   }
   if (!load_event_start.is_null() && !load_event_end.is_null()) {
     PLT_HISTOGRAM("PLT.PT_FinishDocToFinish",
                   load_event_end - load_event_start);
     PLT_HISTOGRAM_DRP("PLT.NT_LoadEvent",
                       load_event_end - load_event_start,
-                      data_reduction_proxy_was_used);
+                      data_reduction_proxy_was_used,
+                      scheme_type);
 
-    if (data_reduction_proxy_was_used)
-      PLT_HISTOGRAM("PLT.PT_FinishDocToFinish_DataReductionProxy",
-                    load_event_end - load_event_start);
+    if (data_reduction_proxy_was_used) {
+      if ((scheme_type & URLPattern::SCHEME_HTTPS) == 0) {
+        PLT_HISTOGRAM("PLT.PT_FinishDocToFinish_DataReductionProxy",
+                      load_event_end - load_event_start);
+      } else {
+        PLT_HISTOGRAM("PLT.PT_FinishDocToFinish_HTTPS_DataReductionProxy",
+                      load_event_end - load_event_start);
+      }
+    }
   }
   if (!dom_content_loaded_start.is_null()) {
     PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_RequestToDomContentLoaded",
                                    dom_content_loaded_start - navigation_start,
                                    came_from_websearch,
                                    websearch_chrome_joint_experiment_id,
                                    is_preview);
-    if (data_reduction_proxy_was_used)
-      PLT_HISTOGRAM("PLT.PT_RequestToDomContentLoaded_DataReductionProxy",
-                    dom_content_loaded_start - navigation_start);
+    if (data_reduction_proxy_was_used) {
+      if ((scheme_type & URLPattern::SCHEME_HTTPS) == 0) {
+        PLT_HISTOGRAM("PLT.PT_RequestToDomContentLoaded_DataReductionProxy",
+                      dom_content_loaded_start - navigation_start);
+      } else {
+        PLT_HISTOGRAM(
+            "PLT.PT_RequestToDomContentLoaded_HTTPS_DataReductionProxy",
+            dom_content_loaded_start - navigation_start);
+      }
+    }
   }
   PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_BeginToCommit",
                                  response_start - begin,
                                  came_from_websearch,
                                  websearch_chrome_joint_experiment_id,
                                  is_preview);
   PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_RequestToStart",
                                  request_start - navigation_start,
                                  came_from_websearch,
                                  websearch_chrome_joint_experiment_id,
                                  is_preview);
   PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_StartToCommit",
                                  response_start - request_start,
                                  came_from_websearch,
                                  websearch_chrome_joint_experiment_id,
                                  is_preview);
   PLT_HISTOGRAM_WITH_GWS_VARIANT("PLT.PT_RequestToCommit",
                                  response_start - navigation_start,
                                  came_from_websearch,
                                  websearch_chrome_joint_experiment_id,
                                  is_preview);
   if (data_reduction_proxy_was_used) {
-    PLT_HISTOGRAM("PLT.PT_BeginToCommit_DataReductionProxy",
-                  response_start - begin);
-    PLT_HISTOGRAM("PLT.PT_RequestToStart_DataReductionProxy",
-                  request_start - navigation_start);
-    PLT_HISTOGRAM("PLT.PT_StartToCommit_DataReductionProxy",
-                  response_start - request_start);
-    PLT_HISTOGRAM("PLT.PT_RequestToCommit_DataReductionProxy",
-                  response_start - navigation_start);
+    if ((scheme_type & URLPattern::SCHEME_HTTPS) == 0) {
+      PLT_HISTOGRAM("PLT.PT_BeginToCommit_DataReductionProxy",
+                    response_start - begin);
+      PLT_HISTOGRAM("PLT.PT_RequestToStart_DataReductionProxy",
+                    request_start - navigation_start);
+      PLT_HISTOGRAM("PLT.PT_StartToCommit_DataReductionProxy",
+                    response_start - request_start);
+      PLT_HISTOGRAM("PLT.PT_RequestToCommit_DataReductionProxy",
+                    response_start - navigation_start);
+    } else {
+      PLT_HISTOGRAM("PLT.PT_BeginToCommit_HTTPS_DataReductionProxy",
+                    response_start - begin);
+      PLT_HISTOGRAM("PLT.PT_RequestToStart_HTTPS_DataReductionProxy",
+                    request_start - navigation_start);
+      PLT_HISTOGRAM("PLT.PT_StartToCommit_HTTPS_DataReductionProxy",
+                    response_start - request_start);
+      PLT_HISTOGRAM("PLT.PT_RequestToCommit_HTTPS_DataReductionProxy",
+                    response_start - navigation_start);
+    }
   }
 }
 
 // These histograms are based on the timing information collected in
 // DocumentState. They should be transitioned to equivalents based on the
 // Navigation Timing records (see DumpPerformanceTiming()) or dropped if not
 // needed. Please do not add new metrics based on DocumentState.
 void DumpDeprecatedHistograms(const WebPerformance& performance,
                               DocumentState* document_state,
                               bool data_reduction_proxy_was_used,
@@ skipping 205 matching lines @@
         break;
       default:
         break;
     }
   }
 }
 
 }  // namespace
 
 PageLoadHistograms::PageLoadHistograms(content::RenderView* render_view)
-    : content::RenderViewObserver(render_view) {
+    : content::RenderViewObserver(render_view),
+      data_reduction_proxy_params_(
+          data_reduction_proxy::DataReductionProxyParams::kAllowed |
+          data_reduction_proxy::DataReductionProxyParams::kFallbackAllowed |
+          data_reduction_proxy::DataReductionProxyParams::kAlternativeAllowed) {
 }
 
 void PageLoadHistograms::Dump(WebFrame* frame) {
   // We only dump histograms for main frames.
   // In the future, it may be interesting to tag subframes and dump them too.
   if (!frame || frame->parent())
     return;
 
   // Only dump for supported schemes.
   URLPattern::SchemeMasks scheme_type =
       GetSupportedSchemeType(frame->document().url());
   if (scheme_type == 0)
     return;
 
   // Ignore multipart requests.
   if (frame->dataSource()->response().isMultipartPayload())
     return;
 
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->dataSource());
 
-  bool data_reduction_proxy_was_used = DataReductionProxyWasUsed(frame);
+  bool data_reduction_proxy_was_used =
+      data_reduction_proxy_params_.IsDataReductionProxy(
+          document_state->proxy_server(), NULL);
   bool came_from_websearch =
       IsFromGoogleSearchResult(frame->document().url(),
                                GURL(frame->document().referrer()));
   int websearch_chrome_joint_experiment_id = kNoExperiment;
   bool is_preview = false;
   if (came_from_websearch) {
     websearch_chrome_joint_experiment_id =
         GetQueryStringBasedExperiment(GURL(frame->document().referrer()));
     is_preview = ViaHeaderContains(frame, "1.1 Google Instant Proxy Preview");
   }
 
   // Metrics based on the timing information recorded for the Navigation Timing
   // API - http://www.w3.org/TR/navigation-timing/.
   DumpHistograms(frame->performance(), document_state,
                  data_reduction_proxy_was_used,
                  came_from_websearch,
                  websearch_chrome_joint_experiment_id,
-                 is_preview);
+                 is_preview,
+                 scheme_type);
 
   // Old metrics based on the timing information stored in DocumentState. These
   // are deprecated and should go away.
   DumpDeprecatedHistograms(frame->performance(), document_state,
                            data_reduction_proxy_was_used,
                            came_from_websearch,
                            websearch_chrome_joint_experiment_id,
                            is_preview,
                            scheme_type);
 
@@ skipping 32 matching lines @@
 
   DCHECK(document_state);
   DCHECK(ds);
   GURL url(ds->request().url());
   Time start = document_state->start_load_time();
   Time finish = document_state->finish_load_time();
   // TODO(mbelshe): should we log more stats?
   VLOG(1) << "PLT: " << (finish - start).InMilliseconds() << "ms "
           << url.spec();
 }