Generalize the reload PLMO to support other transition types.

chrome/browser/page_load_metrics/observers/core_page_load_metrics_observer.cc

 // Copyright 2015 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/core_page_load_metrics_observer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "chrome/browser/browser_process.h"
 #include "components/page_load_metrics/browser/page_load_metrics_util.h"
 #include "components/rappor/rappor_service.h"
 #include "components/rappor/rappor_utils.h"
+#include "ui/base/page_transition_types.h"
 
 namespace {
 
 // The number of buckets in the bitfield histogram. These buckets are described
 // in rappor.xml in PageLoad.CoarseTiming.NavigationToFirstContentfulPaint.
 // The bucket flag is defined by 1 << bucket_index, and is the bitfield
 // representing which timing bucket the page load falls into, i.e. 000010
 // would be the bucket flag showing that the page took between 2 and 4 seconds
 // to load.
 const size_t kNumRapporHistogramBuckets = 6;
 
 uint64_t RapporHistogramBucketIndex(base::TimeDelta time) {
   int64_t seconds = time.InSeconds();
   if (seconds < 2)
     return 0;
   if (seconds < 4)
     return 1;
   if (seconds < 8)
     return 2;
   if (seconds < 16)
     return 3;
   if (seconds < 32)
     return 4;
   return 5;
 }
 
+// TODO(bmcquade): If other observers want to log histograms based on load type,
+// promote this enum to page_load_metrics_observer.h.
+enum PageLoadType {
+  LOAD_TYPE_NONE = 0,
+  LOAD_TYPE_RELOAD,
+  LOAD_TYPE_FORWARD_BACK,
+  LOAD_TYPE_NEW_NAVIGATION
+};
+
+PageLoadType GetPageLoadType(ui::PageTransition transition) {
+  if (ui::PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_RELOAD)) {
+    return LOAD_TYPE_RELOAD;
+  }
+  if (transition & ui::PAGE_TRANSITION_FORWARD_BACK) {

[Bryan McQuade, 2016/06/27 11:46:44]

regarding your comment about incorrectly accounting for a forward back as a
reload, i wonder, if we put this test first, before the reload test, if that
resolves the issue. forward/back is a modifier on the core type, so my guess is
that when you go back to a reloaded page, you get reload&fowrard_back. if we
check for the forward/back modifier first, we should handle that case correctly.

it's also arguable that going back to a page that was reloaded should no longer
be reported as a reload, but that's something we can at least work around if we
check forward/back first.

+    return LOAD_TYPE_FORWARD_BACK;
+  }
+  if (ui::PageTransitionIsNewNavigation(transition)) {
+    return LOAD_TYPE_NEW_NAVIGATION;
+  }
+  NOTREACHED() << "Received PageTransition with no matching PageLoadType.";
+  return LOAD_TYPE_NONE;
+}
+
 }  // namespace
 
 namespace internal {
 
 const char kHistogramCommit[] = "PageLoad.Timing2.NavigationToCommit";
 const char kHistogramFirstLayout[] = "PageLoad.Timing2.NavigationToFirstLayout";
 const char kHistogramFirstTextPaint[] =
     "PageLoad.Timing2.NavigationToFirstTextPaint";
 const char kHistogramDomContentLoaded[] =
     "PageLoad.Timing2.NavigationToDOMContentLoadedEventFired";
@@ skipping 95 matching lines @@
     "PageLoad.ParseTiming.ParseBlockedOnScriptLoad";
 const char kBackgroundHistogramParseBlockedOnScriptLoadImmediate[] =
     "PageLoad.ParseTiming.ParseBlockedOnScriptLoad.Background";
 const char kHistogramParseBlockedOnScriptLoadDocumentWriteImmediate[] =
     "PageLoad.ParseTiming.ParseBlockedOnScriptLoadFromDocumentWrite";
 const char
     kBackgroundHistogramParseBlockedOnScriptLoadDocumentWriteImmediate[] =
         "PageLoad.ParseTiming.ParseBlockedOnScriptLoadFromDocumentWrite."
         "Background";
 
+const char kHistogramLoadTypeFirstContentfulPaintReload[] =
+    "PageLoad.PaintTiming.NavigationToFirstContentfulPaint.LoadType."
+    "Reload";
+const char kHistogramLoadTypeFirstContentfulPaintReloadByGesture[] =
+    "PageLoad.PaintTiming.NavigationToFirstContentfulPaint.LoadType."
+    "Reload.UserGesture";
+const char kHistogramLoadTypeFirstContentfulPaintForwardBack[] =
+    "PageLoad.PaintTiming.NavigationToFirstContentfulPaint.LoadType."
+    "ForwardBackNavigation";
+const char kHistogramLoadTypeFirstContentfulPaintNewNavigation[] =
+    "PageLoad.PaintTiming.NavigationToFirstContentfulPaint.LoadType."
+    "NewNavigation";
+
 const char kHistogramFirstContentfulPaintHigh[] =
     "PageLoad.Timing2.NavigationToFirstContentfulPaint.HighResolutionClock";
 const char kHistogramFirstContentfulPaintLow[] =
     "PageLoad.Timing2.NavigationToFirstContentfulPaint.LowResolutionClock";
 
 const char kHistogramFirstBackground[] =
     "PageLoad.Timing2.NavigationToFirstBackground";
 const char kHistogramFirstForeground[] =
     "PageLoad.Timing2.NavigationToFirstForeground";
 
 const char kHistogramBackgroundBeforePaint[] =
     "PageLoad.Timing2.NavigationToFirstBackground.AfterCommit.BeforePaint";
 const char kHistogramBackgroundBeforeCommit[] =
     "PageLoad.Timing2.NavigationToFirstBackground.BeforeCommit";
 const char kHistogramBackgroundDuringParse[] =
     "PageLoad.Timing2.NavigationToFirstBackground.DuringParse";
 const char kHistogramFailedProvisionalLoad[] =
     "PageLoad.Timing2.NavigationToFailedProvisionalLoad";
 
 const char kHistogramForegroundToFirstPaint[] =
     "PageLoad.Timing2.ForegroundToFirstPaint";
 
 const char kRapporMetricsNameCoarseTiming[] =
     "PageLoad.CoarseTiming.NavigationToFirstContentfulPaint";
 
 }  // namespace internal
 
-CorePageLoadMetricsObserver::CorePageLoadMetricsObserver() {}
+CorePageLoadMetricsObserver::CorePageLoadMetricsObserver()
+    : transition_(ui::PAGE_TRANSITION_LINK),
+      initiated_by_user_gesture_(false) {}
 
 CorePageLoadMetricsObserver::~CorePageLoadMetricsObserver() {}
 
+void CorePageLoadMetricsObserver::OnCommit(
+    content::NavigationHandle* navigation_handle) {
+  transition_ = navigation_handle->GetPageTransition();
+  initiated_by_user_gesture_ = navigation_handle->HasUserGesture();
+}
+
 void CorePageLoadMetricsObserver::OnDomContentLoadedEventStart(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   if (WasStartedInForegroundEventInForeground(
           timing.dom_content_loaded_event_start, info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramDomContentLoadedImmediate,
                         timing.dom_content_loaded_event_start);
   } else {
     PAGE_LOAD_HISTOGRAM(internal::kBackgroundHistogramDomContentLoadedImmediate,
                         timing.dom_content_loaded_event_start);
@@ skipping 63 matching lines @@
 void CorePageLoadMetricsObserver::OnFirstContentfulPaint(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& info) {
   if (WasStartedInForegroundEventInForeground(timing.first_contentful_paint,
                                               info)) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstContentfulPaintImmediate,
                         timing.first_contentful_paint);
     PAGE_LOAD_HISTOGRAM(
         internal::kHistogramParseStartToFirstContentfulPaintImmediate,
         timing.first_contentful_paint - timing.parse_start);
+
+    switch (GetPageLoadType(transition_)) {
+      case LOAD_TYPE_RELOAD:
+        PAGE_LOAD_HISTOGRAM(
+            internal::kHistogramLoadTypeFirstContentfulPaintReload,
+            timing.first_contentful_paint);
+        if (initiated_by_user_gesture_) {
+          PAGE_LOAD_HISTOGRAM(
+              internal::kHistogramLoadTypeFirstContentfulPaintReloadByGesture,
+              timing.first_contentful_paint);
+        }
+        break;
+      case LOAD_TYPE_FORWARD_BACK:
+        PAGE_LOAD_HISTOGRAM(
+            internal::kHistogramLoadTypeFirstContentfulPaintForwardBack,
+            timing.first_contentful_paint);
+        break;
+      case LOAD_TYPE_NEW_NAVIGATION:
+        PAGE_LOAD_HISTOGRAM(
+            internal::kHistogramLoadTypeFirstContentfulPaintNewNavigation,
+            timing.first_contentful_paint);
+        break;
+      case LOAD_TYPE_NONE:
+        NOTREACHED();
+        break;
+    }
   } else {
     PAGE_LOAD_HISTOGRAM(
         internal::kBackgroundHistogramFirstContentfulPaintImmediate,
         timing.first_contentful_paint);
     PAGE_LOAD_HISTOGRAM(
         internal::kBackgroundHistogramParseStartToFirstContentfulPaintImmediate,
         timing.first_contentful_paint - timing.parse_start);
   }
 }
 
@@ skipping 292 matching lines @@
       RapporHistogramBucketIndex(timing.first_contentful_paint);
   sample->SetFlagsField("Bucket", uint64_t(1) << bucket_index,
                         kNumRapporHistogramBuckets);
   // The IsSlow flag is just a one bit boolean if the first contentful paint
   // was > 10s.
   sample->SetFlagsField("IsSlow",
                         timing.first_contentful_paint.InSecondsF() >= 10, 1);
   rappor_service->RecordSampleObj(internal::kRapporMetricsNameCoarseTiming,
                                   std::move(sample));
 }