Adding parse UMA and pingback metrics

chrome/browser/page_load_metrics/observers/data_reduction_proxy_metrics_observer.cc

 // Copyright 2016 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/browser/page_load_metrics/observers/data_reduction_proxy_metrics_observer.h"
 
 #include <string>
 
 #include "base/optional.h"
 #include "base/time/time.h"
@@ skipping 20 matching lines @@
 bool ShouldRecordHistogram(const DataReductionProxyData* data,
                            const base::Optional<base::TimeDelta>& event,
                            const page_load_metrics::PageLoadExtraInfo& info) {
   return data && data->used_data_reduction_proxy() &&
          WasStartedInForegroundOptionalEventInForeground(event, info);
 }
 
 // A macro is needed because PAGE_LOAD_HISTOGRAM creates a static instance of
 // the histogram. A distinct histogram is needed for each place that calls
 // RECORD_HISTOGRAMS_FOR_SUFFIX.
-#define RECORD_HISTOGRAMS_FOR_SUFFIX(data, event, info, histogram_suffix)   \
+#define RECORD_HISTOGRAMS_FOR_SUFFIX(data, event, value, info,              \

[tbansal1, 2016/09/06 17:28:16]

Why do you need to pass value?

[RyanSturm, 2016/09/06 17:47:23]

parse_duration is the difference between two events, but uses the parse_stop
event to check if it is backgrounded.

[tbansal1, 2016/09/06 19:44:43]

Acked. Can you add a comment that event is time delta from navigation start
until the time when the event happened.

+                                     histogram_suffix)                      \
   do {                                                                      \
     if (ShouldRecordHistogram(data.get(), event, info)) {                   \
       PAGE_LOAD_HISTOGRAM(                                                  \
           std::string(internal::kHistogramDataReductionProxyPrefix)         \
               .append(histogram_suffix),                                    \
-          event.value());                                                   \
+          value);                                                           \
       if (data->lofi_requested()) {                                         \
         PAGE_LOAD_HISTOGRAM(                                                \
             std::string(internal::kHistogramDataReductionProxyLoFiOnPrefix) \
                 .append(histogram_suffix),                                  \
-            event.value());                                                 \
+            value);                                                         \
       }                                                                     \
     }                                                                       \
   } while (false)
 
 }  // namespace
 
 namespace internal {
 
 const char kHistogramDataReductionProxyPrefix[] =
     "PageLoad.Clients.DataReductionProxy.";
 const char kHistogramDataReductionProxyLoFiOnPrefix[] =
     "PageLoad.Clients.DataReductionProxy.LoFiOn.";
 const char kHistogramDOMContentLoadedEventFiredSuffix[] =
     "DocumentTiming.NavigationToDOMContentLoadedEventFired";
 const char kHistogramFirstLayoutSuffix[] =
     "DocumentTiming.NavigationToFirstLayout";
 const char kHistogramLoadEventFiredSuffix[] =
     "DocumentTiming.NavigationToLoadEventFired";
 const char kHistogramFirstContentfulPaintSuffix[] =
     "PaintTiming.NavigationToFirstContentfulPaint";
 const char kHistogramFirstImagePaintSuffix[] =
     "PaintTiming.NavigationToFirstImagePaint";
 const char kHistogramFirstPaintSuffix[] = "PaintTiming.NavigationToFirstPaint";
 const char kHistogramFirstTextPaintSuffix[] =
     "PaintTiming.NavigationToFirstTextPaint";
 const char kHistogramParseStartSuffix[] = "ParseTiming.NavigationToParseStart";
+const char kHistogramParseBlockedOnScriptLoadSuffix[] =
+    "ParseTiming.ParseBlockedOnScriptLoad";
+const char kHistogramParseDurationSuffix[] = "ParseTiming.ParseDuration";
 
 }  // namespace internal
 
 DataReductionProxyMetricsObserver::DataReductionProxyMetricsObserver()
     : browser_context_(nullptr) {}
 
 DataReductionProxyMetricsObserver::~DataReductionProxyMetricsObserver() {}
 
 // Check if the NavigationData indicates anything about the DataReductionProxy.
 void DataReductionProxyMetricsObserver::OnCommit(
@@ skipping 35 matching lines @@
   if (data_reduction_proxy::params::IsIncludedInHoldbackFieldTrial() ||
       data_reduction_proxy::params::IsIncludedInTamperDetectionExperiment()) {
     return;
   }
   // Only consider timing events that happened before the first background
   // event.
   base::Optional<base::TimeDelta> response_start;
   base::Optional<base::TimeDelta> load_event_start;
   base::Optional<base::TimeDelta> first_image_paint;
   base::Optional<base::TimeDelta> first_contentful_paint;
+  base::Optional<base::TimeDelta> parse_blocked_on_script_load_duration;
+  base::Optional<base::TimeDelta> parse_stop;
   if (WasStartedInForegroundOptionalEventInForeground(timing.response_start,
                                                       info)) {
     response_start = timing.response_start;
   }
   if (WasStartedInForegroundOptionalEventInForeground(timing.load_event_start,
                                                       info)) {
     load_event_start = timing.load_event_start;
   }
   if (WasStartedInForegroundOptionalEventInForeground(timing.first_image_paint,
                                                       info)) {
     first_image_paint = timing.first_image_paint;
   }
   if (WasStartedInForegroundOptionalEventInForeground(
           timing.first_contentful_paint, info)) {
     first_contentful_paint = timing.first_contentful_paint;
   }
+  if (WasStartedInForegroundOptionalEventInForeground(
+          timing.parse_blocked_on_script_load_duration, info)) {
+    parse_blocked_on_script_load_duration =
+        timing.parse_blocked_on_script_load_duration;
+  }
+  if (WasStartedInForegroundOptionalEventInForeground(timing.parse_stop,
+                                                      info)) {
+    parse_stop = timing.parse_stop;
+  }
+
   DataReductionProxyPageLoadTiming data_reduction_proxy_timing(
       timing.navigation_start, response_start, load_event_start,
-      first_image_paint, first_contentful_paint);
+      first_image_paint, first_contentful_paint,
+      parse_blocked_on_script_load_duration, parse_stop);
   GetPingbackClient()->SendPingback(*data_, data_reduction_proxy_timing);
 }
 
 void DataReductionProxyMetricsObserver::OnDomContentLoadedEventStart(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   RECORD_HISTOGRAMS_FOR_SUFFIX(
-      data_, timing.dom_content_loaded_event_start, info,
+      data_, timing.dom_content_loaded_event_start,
+      timing.dom_content_loaded_event_start.value(), info,
       internal::kHistogramDOMContentLoadedEventFiredSuffix);
 }
 
 void DataReductionProxyMetricsObserver::OnLoadEventStart(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
-  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.load_event_start, info,
+  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.load_event_start,
+                               timing.load_event_start.value(), info,
                                internal::kHistogramLoadEventFiredSuffix);
 }
 
 void DataReductionProxyMetricsObserver::OnFirstLayout(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
-  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_layout, info,
+  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_layout,
+                               timing.first_layout.value(), info,
                                internal::kHistogramFirstLayoutSuffix);
 }
 
 void DataReductionProxyMetricsObserver::OnFirstPaint(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
-  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_paint, info,
+  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_paint,
+                               timing.first_paint.value(), info,
                                internal::kHistogramFirstPaintSuffix);
 }
 
 void DataReductionProxyMetricsObserver::OnFirstTextPaint(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
-  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_text_paint, info,
+  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_text_paint,
+                               timing.first_text_paint.value(), info,
                                internal::kHistogramFirstTextPaintSuffix);
 }
 
 void DataReductionProxyMetricsObserver::OnFirstImagePaint(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
-  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_image_paint, info,
+  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_image_paint,
+                               timing.first_image_paint.value(), info,
                                internal::kHistogramFirstImagePaintSuffix);
 }
 
 void DataReductionProxyMetricsObserver::OnFirstContentfulPaint(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
-  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_contentful_paint, info,
+  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.first_contentful_paint,
+                               timing.first_contentful_paint.value(), info,
                                internal::kHistogramFirstContentfulPaintSuffix);
 }
 
 void DataReductionProxyMetricsObserver::OnParseStart(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
-  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.parse_start, info,
+  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.parse_start,
+                               timing.parse_start.value(), info,
                                internal::kHistogramParseStartSuffix);
 }
 
+void DataReductionProxyMetricsObserver::OnParseStop(
+    const page_load_metrics::PageLoadTiming& timing,
+    const page_load_metrics::PageLoadExtraInfo& info) {
+  base::TimeDelta parse_duration =
+      timing.parse_stop.value() - timing.parse_start.value();
+  RECORD_HISTOGRAMS_FOR_SUFFIX(data_, timing.parse_stop, parse_duration, info,
+                               internal::kHistogramParseDurationSuffix);
+  RECORD_HISTOGRAMS_FOR_SUFFIX(
+      data_, timing.parse_blocked_on_script_load_duration,
+      timing.parse_blocked_on_script_load_duration.value(), info,
+      internal::kHistogramParseBlockedOnScriptLoadSuffix);
+}
+
 DataReductionProxyPingbackClient*
 DataReductionProxyMetricsObserver::GetPingbackClient() const {
   return DataReductionProxyChromeSettingsFactory::GetForBrowserContext(
              browser_context_)
       ->data_reduction_proxy_service()
       ->pingback_client();
 }
 
 }  // namespace data_reduction_proxy