[do not review][page_load_metrics] User Initiated Abort Tracking

components/page_load_metrics/browser/metrics_web_contents_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 "components/page_load_metrics/browser/metrics_web_contents_observer.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "components/page_load_metrics/browser/page_load_metrics_macros.h"
 #include "components/page_load_metrics/common/page_load_metrics_messages.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
 #include "components/rappor/rappor_service.h"
 #include "components/rappor/rappor_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
+#include "ui/base/page_transition_types.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(
     page_load_metrics::MetricsWebContentsObserver);
 
 namespace page_load_metrics {
 
 namespace {
 
 // The url we see from the renderer side is not always the same as what
 // we see from the browser side (e.g. chrome://newtab). We want to be
@@ skipping 39 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void RecordInternalError(InternalErrorLoadEvent event) {
   UMA_HISTOGRAM_ENUMERATION(kErrorEvents, event, ERR_LAST_ENTRY);
 }
 
+UserAbortType AbortTypeForPageTransition(ui::PageTransition transition) {
+  if (ui::PageTransitionCoreTypeIs(transition, ui::PAGE_TRANSITION_RELOAD))

[Bryan McQuade, 2015/11/23 22:39:44]

any reason we use PageTransitionCoreTypeIs here but not in the 'else if' below?

[Charlie Harrison, 2015/11/25 20:15:25]

PAGE_TRANSITION_FORWARD_BACK is a qualifier, not a core type.

+    return ABORT_RELOAD;
+  else if (transition & ui::PAGE_TRANSITION_FORWARD_BACK)
+    return ABORT_FORWARD_BACK;
+  else
+    return ABORT_NEW_NAVIGATION;
+}
+
 base::TimeDelta GetFirstContentfulPaint(const PageLoadTiming& timing) {
   if (timing.first_text_paint.is_zero())
     return timing.first_image_paint;
   if (timing.first_image_paint.is_zero())
     return timing.first_text_paint;
   return std::min(timing.first_text_paint, timing.first_image_paint);
 }
 
 // The number of buckets in the bitfield histogram. These buckets are described
 // in rappor.xml in PageLoad.CoarseTiming.NavigationToFirstContentfulPaint.
@@ skipping 20 matching lines @@
 
 }  // namespace
 
 PageLoadTracker::PageLoadTracker(
     bool in_foreground,
     PageLoadMetricsEmbedderInterface* embedder_interface,
     content::NavigationHandle* navigation_handle,
     base::ObserverList<PageLoadMetricsObserver, true>* observers)
     : has_commit_(false),
       navigation_start_(navigation_handle->NavigationStart()),
+      abort_type_(ABORT_NONE),
       started_in_foreground_(in_foreground),
       embedder_interface_(embedder_interface),
       observers_(observers) {}
 
 PageLoadTracker::~PageLoadTracker() {
   if (has_commit_) {
     RecordTimingHistograms();
     RecordRappor();
   }
+  RecordAbortTimingHistograms();
 }
 
 void PageLoadTracker::WebContentsHidden() {
   // Only log the first time we background in a given page load.
   if (started_in_foreground_ && background_time_.is_null())
     background_time_ = base::TimeTicks::Now();
 }
 
 void PageLoadTracker::WebContentsShown() {
   // Only log the first time we foreground in a given page load.
@@ skipping 34 matching lines @@
   return false;
 }
 
 bool PageLoadTracker::HasBackgrounded() {
   return !started_in_foreground_ || !background_time_.is_null();
 }
 
 PageLoadExtraInfo PageLoadTracker::GetPageLoadMetricsInfo() {
   base::TimeDelta first_background_time;
   base::TimeDelta first_foreground_time;
-  if (!background_time_.is_null() && started_in_foreground_)
+  if (!background_time_.is_null())
     first_background_time = background_time_ - navigation_start_;
-  if (!foreground_time_.is_null() && !started_in_foreground_)
+  if (!foreground_time_.is_null())
     first_foreground_time = foreground_time_ - navigation_start_;
   return PageLoadExtraInfo(first_background_time, first_foreground_time,
                            started_in_foreground_);
 }
 
+// We consider the first abort passed here as the true abort, unless it is
+// ABORT_OTHER, so call this with decreasing specificity.
+void PageLoadTracker::NotifyAbort(UserAbortType abort_type,
+                                  const base::TimeTicks& timestamp) {
+  DCHECK(abort_type != ABORT_NONE);
+  if (abort_type_ == ABORT_NONE) {
+    abort_type_ = abort_type;
+    abort_time_ = timestamp;
+  }
+
+  // If we got a better signal than ABORT_OTHER in the last 100ms, treat it
+  // as the cause of the abort (Some ABORT_OTHER signals occur before the true
+  // signal). Note that this only occurs for provisional loads. While this
+  // heuristic is coarse, it works better and is simpler than other feasible
+  // methods.

[Bryan McQuade, 2015/11/23 22:39:44]

Let's link to your design doc here so people reading the code can get more
insight on why the 100ms threshold is the best overall option, given the
complexity tradeoffs.

[Charlie Harrison, 2015/11/25 20:15:25]

Done.

+  if (abort_type_ == ABORT_OTHER && abort_type != ABORT_OTHER
+      && (timestamp - abort_time_).InMillisecondsF() < 100) {
+    abort_type_ = abort_type;
+    abort_time_ = std::min(abort_time_, timestamp);

[Bryan McQuade, 2015/11/23 22:39:44]

do we ever expect timestamp to be less than abort_time_? on first glance that
seems like it should never happen. if you don't expect it, i'd rather do:

DCHECK_LE(abort_time_, timestamp);
abort_time_ = timestamp;

[Charlie Harrison, 2015/11/25 20:15:25]

I think it is possible. For instance if we get an ABORT_OTHER which gets
replaced by a navigation start. We always want the earliest value.

+  }
+}
+
+void PageLoadTracker::RecordAbortTimingHistograms() {
+  if (abort_type_ == ABORT_NONE)
+    return;
+  DCHECK(!abort_time_.is_null());
+
+  // Loads are not considered aborts if they painted before the abort event.
+  base::TimeDelta time_to_abort = abort_time_ - navigation_start_;
+  if (!timing_.first_paint.is_zero() && timing_.first_paint < time_to_abort)
+    return;
+
+  // Don't log abort times if the page was backgrounded before the abort event.
+  if (GetBackgroundDelta() < time_to_abort)
+    return;
+  if (has_commit_) {
+    if (abort_type_ == ABORT_RELOAD) {
+      PAGE_LOAD_HISTOGRAM(kHistogramCommittedAbortReload, time_to_abort);
+    } else if (abort_type_ == ABORT_FORWARD_BACK) {
+      PAGE_LOAD_HISTOGRAM(kHistogramCommittedAbortForwardBack, time_to_abort);
+    } else if (abort_type_ == ABORT_NEW_NAVIGATION) {
+      PAGE_LOAD_HISTOGRAM(kHistogramCommittedAbortNewNavigation, time_to_abort);
+    } else if (abort_type_ == ABORT_STOP) {
+      PAGE_LOAD_HISTOGRAM(kHistogramCommittedAbortStop, time_to_abort);
+    } else if (abort_type_ == ABORT_CLOSE) {
+      PAGE_LOAD_HISTOGRAM(kHistogramCommittedAbortClose, time_to_abort);
+    }

[Bryan McQuade, 2015/11/23 21:33:42]

can we add:
else {
DLOG(FATAL) << "Received ABORT_OTHER for committed load.";
}

[Charlie Harrison, 2015/11/25 20:15:25]

Done.

+  } else {
+    if (abort_type_ == ABORT_RELOAD) {
+      PAGE_LOAD_HISTOGRAM(kHistogramProvisionalAbortReload, time_to_abort);
+    } else if (abort_type_ == ABORT_FORWARD_BACK) {
+      PAGE_LOAD_HISTOGRAM(kHistogramProvisionalAbortForwardBack, time_to_abort);
+    } else if (abort_type_ == ABORT_NEW_NAVIGATION) {
+      PAGE_LOAD_HISTOGRAM(kHistogramProvisionalAbortNewNavigation,
+                          time_to_abort);
+    } else if (abort_type_ == ABORT_STOP) {
+      PAGE_LOAD_HISTOGRAM(kHistogramProvisionalAbortStop, time_to_abort);
+    } else if (abort_type_ == ABORT_CLOSE) {
+      PAGE_LOAD_HISTOGRAM(kHistogramProvisionalAbortClose, time_to_abort);
+    } else if (abort_type_ == ABORT_OTHER) {
+      PAGE_LOAD_HISTOGRAM(kHistogramProvisionalAbortOther, time_to_abort);
+    }
+  }
+}
+
 const GURL& PageLoadTracker::GetCommittedURL() {
   DCHECK(has_commit_);
   return url_;
 }
 
 // Blink calculates navigation start using TimeTicks, but converts to epoch time
 // in its public API. Thus, to compare time values to navigation start, we
 // calculate the current time since the epoch using TimeTicks, and convert to
 // Time. This method is similar to how blink converts TimeTicks to epoch time.
 // There may be slight inaccuracies due to inter-process timestamps, but
 // this solution is the best we have right now.
 //
 // returns a TimeDelta which is
 //  - Infinity if we were never backgrounded
 //  - null (TimeDelta()) if we started backgrounded
 //  - elapsed time to first background if we started in the foreground and
 //    backgrounded.
 base::TimeDelta PageLoadTracker::GetBackgroundDelta() {
   if (started_in_foreground_) {
     return background_time_.is_null() ? base::TimeDelta::Max()
                                       : background_time_ - navigation_start_;
   }
   return base::TimeDelta();
 }
 
 void PageLoadTracker::RecordTimingHistograms() {
   DCHECK(has_commit_);
+  base::TimeDelta background_delta = GetBackgroundDelta();
+  if (!background_time_.is_null() && (timing_.first_paint.is_zero() ||
+                                      background_delta < timing_.first_paint)) {
+    PAGE_LOAD_HISTOGRAM(kHistogramBackgroundBeforePaint,
+                        background_time_ - navigation_start_);
+  }
+
+  // The rest of the timing histograms require us to have received IPCs from the
+  // renderer. Record UMA for how often this occurs (usually for quickly aborted
+  // loads). For now, don't update observers if this is the case.
   if (timing_.IsEmpty()) {
     RecordInternalError(ERR_NO_IPCS_RECEIVED);
     return;
   }
 
   PageLoadExtraInfo info = GetPageLoadMetricsInfo();
   FOR_EACH_OBSERVER(PageLoadMetricsObserver, *observers_,
                     OnComplete(timing_, info));
 
-  base::TimeDelta background_delta = GetBackgroundDelta();
-
   if (!timing_.dom_content_loaded_event_start.is_zero()) {
     if (timing_.dom_content_loaded_event_start < background_delta) {
       PAGE_LOAD_HISTOGRAM(kHistogramDomContentLoaded,
                           timing_.dom_content_loaded_event_start);
     } else {
       PAGE_LOAD_HISTOGRAM(kBackgroundHistogramDomContentLoaded,
                           timing_.dom_content_loaded_event_start);
     }
   }
   if (!timing_.load_event_start.is_zero()) {
@@ skipping 45 matching lines @@
       PAGE_LOAD_HISTOGRAM(kHistogramFirstContentfulPaint,
                           first_contentful_paint);
     } else {
       PAGE_LOAD_HISTOGRAM(kBackgroundHistogramFirstContentfulPaint,
                           first_contentful_paint);
     }
   }
 
   // Log time to first foreground / time to first background. Log counts that we
   // started a relevant page load in the foreground / background.
   if (!background_time_.is_null()) {

[Bryan McQuade, 2015/11/23 22:39:44]

should this be moved up above the timing_.IsEmpty() check as well given that
these metrics are not based on data in PageLoadTiming? Perhaps add a TODO to
address this in a follow up change.

     PAGE_LOAD_HISTOGRAM(kHistogramFirstBackground, background_delta);
   } else if (!foreground_time_.is_null()) {
     PAGE_LOAD_HISTOGRAM(kHistogramFirstForeground,
                         foreground_time_ - navigation_start_);
   }
 }
 
 void PageLoadTracker::RecordProvisionalEvent(ProvisionalLoadEvent event) {
   if (HasBackgrounded()) {
     UMA_HISTOGRAM_ENUMERATION(kBackgroundProvisionalEvents, event,
@@ skipping 60 matching lines @@
   if (!metrics) {
     metrics =
         new MetricsWebContentsObserver(web_contents, embedder_interface.Pass());
     web_contents->SetUserData(UserDataKey(), metrics);
   }
   return metrics;
 }
 
 MetricsWebContentsObserver::~MetricsWebContentsObserver() {
   // Reset PageLoadTrackers so observers get final notifications.
+  NotifyAbortAllLoads(ABORT_CLOSE);
   committed_load_.reset();
   provisional_loads_.clear();
+  aborted_provisional_loads_.clear();
   FOR_EACH_OBSERVER(PageLoadMetricsObserver, observers_,
                     OnPageLoadMetricsGoingAway());
 }
 
 void MetricsWebContentsObserver::AddObserver(
     PageLoadMetricsObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void MetricsWebContentsObserver::RemoveObserver(
@@ skipping 41 matching lines @@
   scoped_ptr<PageLoadTracker> finished_nav(
       provisional_loads_.take_and_erase(navigation_handle));
   // There's a chance a navigation could have started before we were added to a
   // tab. Bail out early if this is the case.
   if (!finished_nav)
     return;
 
   // Handle a pre-commit error here. Navigations that result in an error page
   // will be ignored. Note that downloads/204s will result in HasCommitted()
   // returning false.
+  // TODO(csharrison): Track changes to NavigationHandle for signals when this
+  // is the case (HTTP response headers).
   if (!navigation_handle->HasCommitted()) {
     net::Error error = navigation_handle->GetNetErrorCode();
-    finished_nav->RecordProvisionalEvent(
-        error == net::OK ? PROVISIONAL_LOAD_STOPPED
+    ProvisionalLoadEvent event = error == net::OK ? PROVISIONAL_LOAD_STOPPED
         : error == net::ERR_ABORTED ? PROVISIONAL_LOAD_ERR_ABORTED
-        : PROVISIONAL_LOAD_ERR_FAILED_NON_ABORT);
+        : PROVISIONAL_LOAD_ERR_FAILED_NON_ABORT;
+    finished_nav->RecordProvisionalEvent(event);
+    if (event != PROVISIONAL_LOAD_ERR_FAILED_NON_ABORT) {

[Bryan McQuade, 2015/11/23 22:39:44]

if event == PROVISIONAL_LOAD_STOPPED, should we pass ABORT_STOP to NotifyAbort?
or does PROVISIONAL_LOAD_STOPPED have a slightly different meaning than the STOP
in ABORT_STOP (in which case is there a better name we should use instead of
PROVISIONAL_LOAD_STOPPED)?

[Charlie Harrison, 2015/11/25 20:15:25]

I think it should represent stop, but I'm not fully sure. Right now they
supposedly should not be occuring but we're still seeing some samples. I think
best to be safe for now and we can continue investigating.

+      finished_nav->NotifyAbort(ABORT_OTHER, base::TimeTicks::Now());
+      aborted_provisional_loads_.push_back(finished_nav.Pass());
+    }
     return;
   }
   finished_nav->RecordProvisionalEvent(PROVISIONAL_LOAD_COMMITTED);
 
   // Don't treat a same-page nav as a new page load.
   if (navigation_handle->IsSamePage())
     return;
 
+  // Notify other loads that they may have been aborted by this committed load.
+  // Note that by using the committed navigation start as the abort cause, we
+  // lose data on provisional loads that were aborted by other provisional
+  // loads. Those will either be listed as ABORT_OTHER or as being aborted by
+  // this load.
+  NotifyAbortAllLoadsWithTimestamp(
+      AbortTypeForPageTransition(navigation_handle->GetPageTransition()),
+      navigation_handle->NavigationStart());
+
   // Eagerly log the previous UMA even if we don't care about the current
   // navigation.
   committed_load_.reset();
+  aborted_provisional_loads_.clear();
 
   const GURL& browser_url = web_contents()->GetLastCommittedURL();
   const std::string& mime_type = web_contents()->GetContentsMimeType();
   DCHECK(!browser_url.is_empty());
   DCHECK(!mime_type.empty());
   if (!IsRelevantNavigation(navigation_handle, browser_url, mime_type))
     return;
 
   committed_load_ = finished_nav.Pass();
   committed_load_->Commit(navigation_handle);
 }
 
+void MetricsWebContentsObserver::NavigationStopped() {
+  NotifyAbortAllLoads(ABORT_STOP);
+}
+
 void MetricsWebContentsObserver::DidRedirectNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
   auto it = provisional_loads_.find(navigation_handle);
   if (it == provisional_loads_.end())
     return;
   it->second->Redirect(navigation_handle);
 }
 
@@ skipping 13 matching lines @@
   for (const auto& kv : provisional_loads_) {
     kv.second->WebContentsHidden();
   }
 }
 
 // This will occur when the process for the main RenderFrameHost exits, either
 // normally or from a crash. We eagerly log data from the last committed load if
 // we have one.
 void MetricsWebContentsObserver::RenderProcessGone(
     base::TerminationStatus status) {
+  NotifyAbortAllLoads(ABORT_CLOSE);
   committed_load_.reset();
+  provisional_loads_.clear();
+  aborted_provisional_loads_.clear();
+}
+
+void MetricsWebContentsObserver::NotifyAbortAllLoads(UserAbortType abort_type) {
+  NotifyAbortAllLoadsWithTimestamp(abort_type, base::TimeTicks::Now());
+}
+
+void MetricsWebContentsObserver::NotifyAbortAllLoadsWithTimestamp(
+    UserAbortType abort_type,
+    const base::TimeTicks& timestamp) {
+  if (committed_load_)
+    committed_load_->NotifyAbort(abort_type, timestamp);
+  for (const auto& kv : provisional_loads_) {
+    kv.second->NotifyAbort(abort_type, timestamp);
+  }
+  for (const auto& plt : aborted_provisional_loads_) {
+    plt->NotifyAbort(abort_type, timestamp);
+  }
 }
 
 void MetricsWebContentsObserver::OnTimingUpdated(
     content::RenderFrameHost* render_frame_host,
     const PageLoadTiming& timing) {
   bool error = false;
   if (!committed_load_) {
     RecordInternalError(ERR_IPC_WITH_NO_COMMITTED_LOAD);
     error = true;
   }
@@ skipping 18 matching lines @@
 
   if (!committed_load_->UpdateTiming(timing)) {
     // If the page load tracker cannot update its timing, something is wrong
     // with the IPC (it's from another load, or it's invalid in some other way).
     // We expect this to be a rare occurrence.
     RecordInternalError(ERR_BAD_TIMING_IPC);
   }
 }
 
 }  // namespace page_load_metrics