Generalize abort tracking to page end state tracking

chrome/browser/page_load_metrics/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 "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
 
 #include <algorithm>
 #include <ostream>
 #include <string>
 #include <utility>
@@ skipping 64 matching lines @@
   if (!metrics) {
     metrics = new MetricsWebContentsObserver(web_contents,
                                              std::move(embedder_interface));
     web_contents->SetUserData(UserDataKey(), metrics);
   }
   return metrics;
 }
 
 MetricsWebContentsObserver::~MetricsWebContentsObserver() {
   // TODO(csharrison): Use a more user-initiated signal for CLOSE.
-  NotifyAbortAllLoads(ABORT_CLOSE, UserInitiatedInfo::NotUserInitiated());
+  NotifyPageEndAllLoads(END_CLOSE, UserInitiatedInfo::NotUserInitiated());
 }
 
 void MetricsWebContentsObserver::RegisterInputEventObserver(
     content::RenderViewHost* host) {
   if (host != nullptr)
     host->GetWidget()->AddInputEventObserver(this);
 }
 
 void MetricsWebContentsObserver::UnregisterInputEventObserver(
     content::RenderViewHost* host) {
@@ skipping 190 matching lines @@
 
   if (navigation_handle->HasCommitted()) {
     UserInitiatedInfo user_initiated_info =
         finished_nav
             ? finished_nav->user_initiated_info()
             : CreateUserInitiatedInfo(navigation_handle, committed_load_.get());
 
     // Notify other loads that they may have been aborted by this committed
     // load. is_certainly_browser_timestamp is set to false because
     // NavigationStart() could be set in either the renderer or browser process.
-    NotifyAbortAllLoadsWithTimestamp(
-        AbortTypeForPageTransition(navigation_handle->GetPageTransition()),
+    NotifyPageEndAllLoadsWithTimestamp(
+        EndReasonForPageTransition(navigation_handle->GetPageTransition()),
         user_initiated_info, navigation_handle->NavigationStart(), false);
 
     if (should_track) {
       HandleCommittedNavigationForTrackedLoad(navigation_handle,
                                               std::move(finished_nav));
     } else {
       committed_load_.reset();
     }
   } else if (should_track) {
     HandleFailedNavigationForTrackedLoad(navigation_handle,
                                          std::move(finished_nav));
   }
 }
 
 // Handle a pre-commit error. Navigations that result in an error page will be
 // ignored.
 void MetricsWebContentsObserver::HandleFailedNavigationForTrackedLoad(
     content::NavigationHandle* navigation_handle,
     std::unique_ptr<PageLoadTracker> tracker) {
-  tracker->FailedProvisionalLoad(navigation_handle);
+  const base::TimeTicks now = base::TimeTicks::Now();
+  tracker->FailedProvisionalLoad(navigation_handle, now);
 
-  net::Error error = navigation_handle->GetNetErrorCode();
+  const net::Error error = navigation_handle->GetNetErrorCode();
 
   // net::OK: This case occurs when the NavigationHandle finishes and reports
   // !HasCommitted(), but reports no net::Error. This should not occur
   // pre-PlzNavigate, but afterwards it should represent the navigation stopped
   // by the user before it was ready to commit.
-  // net::ERR_ABORTED: An aborted provisional load has error
-  // net::ERR_ABORTED.
-  if ((error == net::OK) || (error == net::ERR_ABORTED)) {
-    tracker->NotifyAbort(ABORT_OTHER, UserInitiatedInfo::NotUserInitiated(),
-                         base::TimeTicks::Now(), true);
+  // net::ERR_ABORTED: An aborted provisional load has error net::ERR_ABORTED.
+  const bool is_aborted_provisional_load =
+      error == net::OK || error == net::ERR_ABORTED;
+
+  // If is_aborted_provisional_load, the page end reason is not yet known, and
+  // will be updated as additional information is available from subsequent
+  // navigations.
+  tracker->NotifyPageEnd(
+      is_aborted_provisional_load ? END_OTHER : END_PROVISIONAL_LOAD_FAILED,
+      UserInitiatedInfo::NotUserInitiated(), now, true);
+
+  if (is_aborted_provisional_load)
     aborted_provisional_loads_.push_back(std::move(tracker));
-  }
 }
 
 void MetricsWebContentsObserver::HandleCommittedNavigationForTrackedLoad(
     content::NavigationHandle* navigation_handle,
     std::unique_ptr<PageLoadTracker> tracker) {
   if (!IsNavigationUserInitiated(navigation_handle) &&
       (navigation_handle->GetPageTransition() &
        ui::PAGE_TRANSITION_CLIENT_REDIRECT) != 0 &&
       committed_load_) {
     // TODO(bmcquade): consider carrying the user_gesture bit forward to the
     // redirected navigation.
     committed_load_->NotifyClientRedirectTo(*tracker);
   }
 
   committed_load_ = std::move(tracker);
   committed_load_->Commit(navigation_handle);
   DCHECK(committed_load_->did_commit());
 }
 
 void MetricsWebContentsObserver::NavigationStopped() {
   // TODO(csharrison): Use a more user-initiated signal for STOP.
-  NotifyAbortAllLoads(ABORT_STOP, UserInitiatedInfo::NotUserInitiated());
+  NotifyPageEndAllLoads(END_STOP, UserInitiatedInfo::NotUserInitiated());
 }
 
 void MetricsWebContentsObserver::OnInputEvent(
     const blink::WebInputEvent& event) {
   // Ignore browser navigation or reload which comes with type Undefined.
   if (event.type() == blink::WebInputEvent::Type::Undefined)
     return;
 
   if (committed_load_)
     committed_load_->OnInputEvent(event);
@@ skipping 43 matching lines @@
   in_foreground_ = false;
   if (committed_load_)
     committed_load_->WebContentsHidden();
   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. Don't notify aborts here because this is probably not user
-// initiated. If it is (e.g. browser shutdown), other code paths will take care
-// of notifying.
+// we have one.
 void MetricsWebContentsObserver::RenderProcessGone(
     base::TerminationStatus status) {
   // Other code paths will be run for normal renderer shutdown. Note that we
   // sometimes get the STILL_RUNNING value on fast shutdown.
   if (status == base::TERMINATION_STATUS_NORMAL_TERMINATION ||
       status == base::TERMINATION_STATUS_STILL_RUNNING) {
     return;
   }
 
+  if (committed_load_) {

[Charlie Harrison, 2017/02/21 19:49:31]

Why not propagate this to all loads, including the aborted loads?

[Bryan McQuade, 2017/02/21 21:51:59]

RenderProcessGone associated with the render frame host for the currently
committed load. We don't know if the pending navs or aborted pending navs are
associated w/ the render process that died, so we can't be sure the info should
propagate to them. I added a comment for this.

+    committed_load_->NotifyPageEnd(END_RENDER_PROCESS_GONE,
+                                   UserInitiatedInfo::NotUserInitiated(),
+                                   base::TimeTicks::Now(), true);
+  }
+
   // If this is a crash, eagerly log the aborted provisional loads and the
   // committed load. |provisional_loads_| don't need to be destroyed here
   // because their lifetime is tied to the NavigationHandle.
   committed_load_.reset();
   aborted_provisional_loads_.clear();
 }
 
-void MetricsWebContentsObserver::NotifyAbortAllLoads(
-    UserAbortType abort_type,
+void MetricsWebContentsObserver::NotifyPageEndAllLoads(
+    PageEndReason page_end_reason,
     UserInitiatedInfo user_initiated_info) {
-  NotifyAbortAllLoadsWithTimestamp(abort_type, user_initiated_info,
-                                   base::TimeTicks::Now(), true);
+  NotifyPageEndAllLoadsWithTimestamp(page_end_reason, user_initiated_info,
+                                     base::TimeTicks::Now(), true);
 }
 
-void MetricsWebContentsObserver::NotifyAbortAllLoadsWithTimestamp(
-    UserAbortType abort_type,
+void MetricsWebContentsObserver::NotifyPageEndAllLoadsWithTimestamp(
+    PageEndReason page_end_reason,
     UserInitiatedInfo user_initiated_info,
     base::TimeTicks timestamp,
     bool is_certainly_browser_timestamp) {
   if (committed_load_) {
-    committed_load_->NotifyAbort(abort_type, user_initiated_info, timestamp,
-                                 is_certainly_browser_timestamp);
+    committed_load_->NotifyPageEnd(page_end_reason, user_initiated_info,
+                                   timestamp, is_certainly_browser_timestamp);
   }
   for (const auto& kv : provisional_loads_) {
-    kv.second->NotifyAbort(abort_type, user_initiated_info, timestamp,
-                           is_certainly_browser_timestamp);
+    kv.second->NotifyPageEnd(page_end_reason, user_initiated_info, timestamp,
+                             is_certainly_browser_timestamp);
   }
   for (const auto& tracker : aborted_provisional_loads_) {
     if (tracker->IsLikelyProvisionalAbort(timestamp)) {
-      tracker->UpdateAbort(abort_type, user_initiated_info, timestamp,
-                           is_certainly_browser_timestamp);
+      tracker->UpdatePageEnd(page_end_reason, user_initiated_info, timestamp,
+                             is_certainly_browser_timestamp);
     }
   }
   aborted_provisional_loads_.clear();
 }
 
 std::unique_ptr<PageLoadTracker>
 MetricsWebContentsObserver::NotifyAbortedProvisionalLoadsNewNavigation(
     content::NavigationHandle* new_navigation,
     UserInitiatedInfo user_initiated_info) {
   // If there are multiple aborted loads that can be attributed to this one,
   // just count the latest one for simplicity. Other loads will fall into the
   // OTHER bucket, though there shouldn't be very many.
   if (aborted_provisional_loads_.size() == 0)
     return nullptr;
   if (aborted_provisional_loads_.size() > 1)
     RecordInternalError(ERR_NAVIGATION_SIGNALS_MULIPLE_ABORTED_LOADS);
 
   std::unique_ptr<PageLoadTracker> last_aborted_load =
       std::move(aborted_provisional_loads_.back());
   aborted_provisional_loads_.pop_back();
 
   base::TimeTicks timestamp = new_navigation->NavigationStart();
   if (last_aborted_load->IsLikelyProvisionalAbort(timestamp)) {
-    last_aborted_load->UpdateAbort(
-        AbortTypeForPageTransition(new_navigation->GetPageTransition()),
+    last_aborted_load->UpdatePageEnd(
+        EndReasonForPageTransition(new_navigation->GetPageTransition()),
         user_initiated_info, timestamp, false);
   }
 
   aborted_provisional_loads_.clear();
   return last_aborted_load;
 }
 
 void MetricsWebContentsObserver::OnTimingUpdated(
     content::RenderFrameHost* render_frame_host,
     const PageLoadTiming& timing,
@@ skipping 35 matching lines @@
     content::NavigationHandle* navigation_handle) const {
   DCHECK(navigation_handle->IsInMainFrame());
   DCHECK(!navigation_handle->HasCommitted() ||
          !navigation_handle->IsSamePage());
 
   return BrowserPageTrackDecider(embedder_interface_.get(), web_contents(),
                                  navigation_handle).ShouldTrack();
 }
 
 }  // namespace page_load_metrics