Generalize abort tracking to page end state tracking

chrome/browser/page_load_metrics/observers/from_gws_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/from_gws_page_load_metrics_observer.h"
 #include <string>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
 #include "chrome/common/page_load_metrics/page_load_timing.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 
-using page_load_metrics::UserAbortType;
+using page_load_metrics::PageAbortReason;
 
 namespace internal {
 
 const char kHistogramFromGWSDomContentLoaded[] =
     "PageLoad.Clients.FromGoogleSearch.DocumentTiming."
     "NavigationToDOMContentLoadedEventFired";
 const char kHistogramFromGWSLoad[] =
     "PageLoad.Clients.FromGoogleSearch.DocumentTiming."
     "NavigationToLoadEventFired";
 const char kHistogramFromGWSFirstPaint[] =
@@ skipping 68 matching lines @@
     "PageLoad.Clients.FromGoogleSearch.Experimental.AbortTiming.Background."
     "AfterCommit.BeforePaint";
 const char kHistogramFromGWSAbortBackgroundBeforeInteraction[] =
     "PageLoad.Clients.FromGoogleSearch.Experimental.AbortTiming.Background."
     "AfterPaint.BeforeInteraction";
 
 }  // namespace internal
 
 namespace {
 
-void LogCommittedAbortsBeforePaint(UserAbortType abort_type,
-                                   base::TimeDelta time_to_abort) {
-  switch (abort_type) {
-    case UserAbortType::ABORT_STOP:
+void LogCommittedAbortsBeforePaint(PageAbortReason abort_reason,
+                                   base::TimeDelta page_end_time) {
+  switch (abort_reason) {
+    case PageAbortReason::ABORT_STOP:
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSAbortStopBeforePaint,
-                          time_to_abort);
+                          page_end_time);
       break;
-    case UserAbortType::ABORT_CLOSE:
+    case PageAbortReason::ABORT_CLOSE:
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSAbortCloseBeforePaint,
-                          time_to_abort);
+                          page_end_time);
       break;
-    case UserAbortType::ABORT_NEW_NAVIGATION:
+    case PageAbortReason::ABORT_NEW_NAVIGATION:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortNewNavigationBeforePaint,
-          time_to_abort);
+          page_end_time);
       break;
-    case UserAbortType::ABORT_RELOAD:
+    case PageAbortReason::ABORT_RELOAD:
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSAbortReloadBeforePaint,
-                          time_to_abort);
+                          page_end_time);
       break;
-    case UserAbortType::ABORT_FORWARD_BACK:
+    case PageAbortReason::ABORT_FORWARD_BACK:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortForwardBackBeforePaint,
-          time_to_abort);
+          page_end_time);
       break;
-    case UserAbortType::ABORT_BACKGROUND:
+    case PageAbortReason::ABORT_BACKGROUND:
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSAbortBackgroundBeforePaint,
-                          time_to_abort);
+                          page_end_time);
       break;
     default:
       // These should only be logged for provisional aborts.
-      DCHECK_NE(abort_type, UserAbortType::ABORT_OTHER);
+      DCHECK_NE(abort_reason, PageAbortReason::ABORT_OTHER);
       break;
   }
 }
 
-void LogAbortsAfterPaintBeforeInteraction(UserAbortType abort_type,
-                                          base::TimeDelta time_to_abort) {
-  switch (abort_type) {
-    case UserAbortType::ABORT_STOP:
+void LogAbortsAfterPaintBeforeInteraction(
+    const page_load_metrics::PageAbortInfo& abort_info) {
+  switch (abort_info.reason) {
+    case PageAbortReason::ABORT_STOP:
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSAbortStopBeforeInteraction,
-                          time_to_abort);
+                          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_CLOSE:
+    case PageAbortReason::ABORT_CLOSE:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortCloseBeforeInteraction,
-          time_to_abort);
+          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_NEW_NAVIGATION:
+    case PageAbortReason::ABORT_NEW_NAVIGATION:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortNewNavigationBeforeInteraction,
-          time_to_abort);
+          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_RELOAD:
+    case PageAbortReason::ABORT_RELOAD:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortReloadBeforeInteraction,
-          time_to_abort);
+          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_FORWARD_BACK:
+    case PageAbortReason::ABORT_FORWARD_BACK:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortForwardBackBeforeInteraction,
-          time_to_abort);
+          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_BACKGROUND:
+    case PageAbortReason::ABORT_BACKGROUND:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortBackgroundBeforeInteraction,
-          time_to_abort);
+          abort_info.time_to_abort);
       break;
     default:
       // These should only be logged for provisional aborts.
-      DCHECK_NE(abort_type, UserAbortType::ABORT_OTHER);
+      DCHECK_NE(abort_info.reason, PageAbortReason::ABORT_OTHER);
       break;
   }
 }
 
-void LogProvisionalAborts(UserAbortType abort_type,
-                          base::TimeDelta time_to_abort) {
-  switch (abort_type) {
-    case UserAbortType::ABORT_STOP:
+void LogProvisionalAborts(const page_load_metrics::PageAbortInfo& abort_info) {
+  switch (abort_info.reason) {
+    case PageAbortReason::ABORT_STOP:
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSAbortStopBeforeCommit,
-                          time_to_abort);
+                          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_CLOSE:
+    case PageAbortReason::ABORT_CLOSE:
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSAbortCloseBeforeCommit,
-                          time_to_abort);
+                          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_OTHER:
+    case PageAbortReason::ABORT_OTHER:
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSAbortOtherBeforeCommit,
-                          time_to_abort);
+                          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_NEW_NAVIGATION:
+    case PageAbortReason::ABORT_NEW_NAVIGATION:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortNewNavigationBeforeCommit,
-          time_to_abort);
+          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_RELOAD:
+    case PageAbortReason::ABORT_RELOAD:
       PAGE_LOAD_HISTOGRAM(internal::kHistogramFromGWSAbortReloadBeforeCommit,
-                          time_to_abort);
+                          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_FORWARD_BACK:
+    case PageAbortReason::ABORT_FORWARD_BACK:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortForwardBackBeforeCommit,
-          time_to_abort);
+          abort_info.time_to_abort);
       break;
-    case UserAbortType::ABORT_BACKGROUND:
+    case PageAbortReason::ABORT_BACKGROUND:
       PAGE_LOAD_HISTOGRAM(
           internal::kHistogramFromGWSAbortBackgroundBeforeCommit,
-          time_to_abort);
+          abort_info.time_to_abort);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 bool WasAbortedInForeground(
-    UserAbortType abort_type,
-    const base::Optional<base::TimeDelta>& time_to_abort,
-    const page_load_metrics::PageLoadExtraInfo& info) {
-  if (!time_to_abort)
+    const page_load_metrics::PageLoadExtraInfo& info,
+    const page_load_metrics::PageAbortInfo& abort_info) {
+  if (!info.started_in_foreground ||
+      abort_info.reason == PageAbortReason::ABORT_NONE)
     return false;
-  if (abort_type == UserAbortType::ABORT_NONE)
-    return false;
+
+  base::Optional<base::TimeDelta> time_to_abort(abort_info.time_to_abort);
   if (WasStartedInForegroundOptionalEventInForeground(time_to_abort, info))
     return true;
-  if (!info.started_in_foreground)
-    return false;
 
-  const base::TimeDelta time_to_abort_val = time_to_abort.value();
   const base::TimeDelta time_to_first_background =
       info.first_background_time.value();
-  DCHECK_GT(time_to_abort_val, time_to_first_background);
+  DCHECK_GT(abort_info.time_to_abort, time_to_first_background);
   base::TimeDelta background_abort_delta =
-      time_to_abort_val - time_to_first_background;
+      abort_info.time_to_abort - time_to_first_background;
   // Consider this a foregrounded abort if it occurred within 100ms of a
   // background. This is needed for closing some tabs, where the signal for
   // background is often slightly ahead of the signal for close.
   if (background_abort_delta.InMilliseconds() < 100)
     return true;
   return false;
 }
 
 bool WasAbortedBeforeInteraction(
-    UserAbortType abort_type,
-    const base::Optional<base::TimeDelta>& time_to_interaction,
-    const base::Optional<base::TimeDelta>& time_to_abort) {
+    const page_load_metrics::PageAbortInfo& abort_info,
+    const base::Optional<base::TimeDelta>& time_to_interaction) {
   // These conditions should be guaranteed by the call to
   // WasAbortedInForeground, which is called before WasAbortedBeforeInteraction
   // gets invoked.
-  DCHECK(time_to_abort);
-  DCHECK(abort_type != UserAbortType::ABORT_NONE);
+  DCHECK(abort_info.reason != PageAbortReason::ABORT_NONE);
 
   if (!time_to_interaction)
     return true;
   // For the case the abort is a reload or forward_back. Since pull to
   // reload / forward_back is the most common user case such aborts being
   // triggered, add a sanitization threshold here: if the first user
   // interaction are received before a reload / forward_back in a very
   // short time, treat the interaction as a gesture to perform the abort.
 
   // Why 1000ms?
   // 1000ms is enough to perform a pull to reload / forward_back gesture.
   // It's also too short a time for a user to consume any content
   // revealed by the interaction.
-  if (abort_type == UserAbortType::ABORT_RELOAD ||
-      abort_type == UserAbortType::ABORT_FORWARD_BACK) {
+  if (abort_info.reason == PageAbortReason::ABORT_RELOAD ||
+      abort_info.reason == PageAbortReason::ABORT_FORWARD_BACK) {
     return time_to_interaction.value() +
                base::TimeDelta::FromMilliseconds(1000) >
-           time_to_abort;
+           abort_info.time_to_abort;
   } else {
-    return time_to_interaction > time_to_abort;
+    return time_to_interaction > abort_info.time_to_abort;
   }
 }
 
 }  // namespace
 
 // See
 // https://docs.google.com/document/d/1jNPZ6Aeh0KV6umw1yZrrkfXRfxWNruwu7FELLx_cpOg/edit
 // for additional details.
 
 // static
@@ skipping 241 matching lines @@
     const blink::WebInputEvent& event) {
   logger_.OnUserInput(event);
 }
 
 void FromGWSPageLoadMetricsLogger::OnComplete(
     const page_load_metrics::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   if (!ShouldLogPostCommitMetrics(extra_info.url))
     return;
 
-  UserAbortType abort_type = extra_info.abort_type;
-  if (!WasAbortedInForeground(abort_type, extra_info.time_to_abort, extra_info))
+  page_load_metrics::PageAbortInfo abort_info = GetPageAbortInfo(extra_info);
+  if (!WasAbortedInForeground(extra_info, abort_info))
     return;
 
   // If we did not receive any timing IPCs from the render process, we can't
   // know for certain if the page was truly aborted before paint, or if the
   // abort happened before we received the IPC from the render process. Thus, we
   // do not log aborts for these page loads. Tracked page loads that receive no
   // timing IPCs are tracked via the ERR_NO_IPCS_RECEIVED error code in the
   // PageLoad.Events.InternalError histogram, so we can keep track of how often
   // this happens.
   if (timing.IsEmpty())
     return;
 
-  base::TimeDelta time_to_abort = extra_info.time_to_abort.value();
-  if (!timing.first_paint || timing.first_paint >= time_to_abort) {
-    LogCommittedAbortsBeforePaint(abort_type, time_to_abort);
-  } else if (WasAbortedBeforeInteraction(abort_type,
-                                         first_user_interaction_after_paint_,
-                                         extra_info.time_to_abort)) {
-    LogAbortsAfterPaintBeforeInteraction(abort_type, time_to_abort);
+  if (!timing.first_paint || timing.first_paint >= abort_info.time_to_abort) {
+    LogCommittedAbortsBeforePaint(abort_info.reason, abort_info.time_to_abort);
+  } else if (WasAbortedBeforeInteraction(abort_info,
+                                         first_user_interaction_after_paint_)) {
+    LogAbortsAfterPaintBeforeInteraction(abort_info);
   }
 }
 
 void FromGWSPageLoadMetricsLogger::OnFailedProvisionalLoad(
     const page_load_metrics::FailedProvisionalLoadInfo& failed_load_info,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {
   if (!ShouldLogFailedProvisionalLoadMetrics())
     return;
 
-  UserAbortType abort_type = extra_info.abort_type;
-  if (!WasAbortedInForeground(abort_type, extra_info.time_to_abort, extra_info))
+  page_load_metrics::PageAbortInfo abort_info = GetPageAbortInfo(extra_info);
+  if (!WasAbortedInForeground(extra_info, abort_info))
     return;
 
-  LogProvisionalAborts(abort_type, extra_info.time_to_abort.value());
+  LogProvisionalAborts(abort_info);
 }
 
 bool FromGWSPageLoadMetricsLogger::ShouldLogFailedProvisionalLoadMetrics() {
   // See comment in ShouldLogPostCommitMetrics above the call to
   // IsGoogleSearchHostname for more info on this if test.
   if (provisional_url_has_search_hostname_)
     return false;
 
   return previously_committed_url_is_search_results_ ||
          previously_committed_url_is_search_redirector_;
@@ skipping 126 matching lines @@
 }
 
 void FromGWSPageLoadMetricsLogger::OnUserInput(
     const blink::WebInputEvent& event) {
   if (first_paint_triggered_ && !first_user_interaction_after_paint_) {
     DCHECK(!navigation_start_.is_null());
     first_user_interaction_after_paint_ =
         base::TimeTicks::Now() - navigation_start_;
   }
 }