Additional heuristic user interaction attribution for page load metrics

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 19 matching lines @@
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/net_errors.h"
 #include "ui/base/page_transition_types.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(
     page_load_metrics::MetricsWebContentsObserver);
 
 namespace page_load_metrics {
 
+namespace {
+
+UserInitiatedInfo CreateUserInitiatedInfo(
+    content::NavigationHandle* navigation_handle,
+    PageLoadTracker* committed_load) {
+  if (!navigation_handle->IsRendererInitiated())
+    return UserInitiatedInfo::BrowserInitiated();
+
+  return UserInitiatedInfo::RenderInitiated(
+      navigation_handle->HasUserGesture(),
+      committed_load &&
+          committed_load->input_tracker()->FindAndConsumeInputEventsBefore(
+              navigation_handle->NavigationStart()));
+}
+
+}  // namespace
+
 // static
 MetricsWebContentsObserver::MetricsWebContentsObserver(
     content::WebContents* web_contents,
     std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface)
     : content::WebContentsObserver(web_contents),
       in_foreground_(false),
       embedder_interface_(std::move(embedder_interface)),
       has_navigated_(false) {
   RegisterInputEventObserver(web_contents->GetRenderViewHost());
 }
 
 MetricsWebContentsObserver* MetricsWebContentsObserver::CreateForWebContents(
     content::WebContents* web_contents,
     std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface) {
   DCHECK(web_contents);
 
   MetricsWebContentsObserver* metrics = FromWebContents(web_contents);
   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, false);
+  NotifyAbortAllLoads(ABORT_CLOSE, UserInitiatedInfo::NotUserInitiated());
 }
 
 void MetricsWebContentsObserver::RegisterInputEventObserver(
     content::RenderViewHost* host) {
   if (host != nullptr)
     host->GetWidget()->AddInputEventObserver(this);
 }
 
 void MetricsWebContentsObserver::UnregisterInputEventObserver(
     content::RenderViewHost* host) {
@@ skipping 22 matching lines @@
 }
 
 void MetricsWebContentsObserver::WillStartNavigationRequest(
     content::NavigationHandle* navigation_handle) {
   // Same-page navigations should never go through WillStartNavigationRequest.
   DCHECK(!navigation_handle->IsSamePage());
 
   if (!navigation_handle->IsInMainFrame())
     return;
 
+  UserInitiatedInfo user_initiated_info(
+      CreateUserInitiatedInfo(navigation_handle, committed_load_.get()));
   std::unique_ptr<PageLoadTracker> last_aborted =
-      NotifyAbortedProvisionalLoadsNewNavigation(navigation_handle);
+      NotifyAbortedProvisionalLoadsNewNavigation(navigation_handle,
+                                                 user_initiated_info);
 
   int chain_size_same_url = 0;
   int chain_size = 0;
   if (last_aborted) {
     if (last_aborted->MatchesOriginalNavigation(navigation_handle)) {
       chain_size_same_url = last_aborted->aborted_chain_size_same_url() + 1;
     } else if (last_aborted->aborted_chain_size_same_url() > 0) {
       LogAbortChainSameURLHistogram(
           last_aborted->aborted_chain_size_same_url());
     }
@@ skipping 22 matching lines @@
   // from the omnibox.
   DCHECK_GT(2ul, provisional_loads_.size());
   // Passing raw pointers to observers_ and embedder_interface_ is safe because
   // the MetricsWebContentsObserver owns them both list and they are torn down
   // after the PageLoadTracker. The PageLoadTracker does not hold on to
   // committed_load_ or navigation_handle beyond the scope of the constructor.
   provisional_loads_.insert(std::make_pair(
       navigation_handle,
       base::MakeUnique<PageLoadTracker>(
           in_foreground_, embedder_interface_.get(), currently_committed_url,
-          navigation_handle, chain_size, chain_size_same_url)));
+          navigation_handle, user_initiated_info, chain_size,
+          chain_size_same_url)));
 }
 
 void MetricsWebContentsObserver::OnRequestComplete(
     content::ResourceType resource_type,
     bool was_cached,
     int net_error) {
   // For simplicity, only count subresources. Navigations are hard to attribute
   // here because we won't have a committed load by the time data streams in
   // from the IO thread.
   if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME &&
@@ skipping 37 matching lines @@
     return;
   }
 
   const bool should_track =
       finished_nav && ShouldTrackNavigation(navigation_handle);
 
   if (finished_nav && !should_track)
     finished_nav->StopTracking();
 
   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()),
-        IsNavigationUserInitiated(navigation_handle),
-        navigation_handle->NavigationStart(), false);
+        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);
 
   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, false, base::TimeTicks::Now(), true);
+    tracker->NotifyAbort(ABORT_OTHER, UserInitiatedInfo::NotUserInitiated(),
+                         base::TimeTicks::Now(), true);
     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_)
+      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);
 }
 
 void MetricsWebContentsObserver::NavigationStopped() {
   // TODO(csharrison): Use a more user-initiated signal for STOP.
-  NotifyAbortAllLoads(ABORT_STOP, false);
+  NotifyAbortAllLoads(ABORT_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 61 matching lines @@
     return;
   }
 
   // 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,
-                                                     bool user_initiated) {
-  NotifyAbortAllLoadsWithTimestamp(abort_type, user_initiated,
+void MetricsWebContentsObserver::NotifyAbortAllLoads(
+    UserAbortType abort_type,
+    UserInitiatedInfo user_initiated_info) {
+  NotifyAbortAllLoadsWithTimestamp(abort_type, user_initiated_info,
                                    base::TimeTicks::Now(), true);
 }
 
 void MetricsWebContentsObserver::NotifyAbortAllLoadsWithTimestamp(
     UserAbortType abort_type,
-    bool user_initiated,
+    UserInitiatedInfo user_initiated_info,
     base::TimeTicks timestamp,
     bool is_certainly_browser_timestamp) {
   if (committed_load_) {
-    committed_load_->NotifyAbort(abort_type, user_initiated, timestamp,
+    committed_load_->NotifyAbort(abort_type, user_initiated_info, timestamp,
                                  is_certainly_browser_timestamp);
   }
   for (const auto& kv : provisional_loads_) {
-    kv.second->NotifyAbort(abort_type, user_initiated, timestamp,
+    kv.second->NotifyAbort(abort_type, 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, timestamp,
+      tracker->UpdateAbort(abort_type, user_initiated_info, timestamp,
                            is_certainly_browser_timestamp);
     }
   }
   aborted_provisional_loads_.clear();
 }
 
 std::unique_ptr<PageLoadTracker>
 MetricsWebContentsObserver::NotifyAbortedProvisionalLoadsNewNavigation(
-    content::NavigationHandle* new_navigation) {
+    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()),
-        IsNavigationUserInitiated(new_navigation), timestamp, false);
+        user_initiated_info, timestamp, false);
   }
 
   aborted_provisional_loads_.clear();
   return last_aborted_load;
 }
 
 void MetricsWebContentsObserver::OnTimingUpdated(
     content::RenderFrameHost* render_frame_host,
     const PageLoadTiming& timing,
     const PageLoadMetadata& metadata) {
@@ skipping 34 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