Thread user gesture through page_load_metrics abort pipeline

chrome/browser/page_load_metrics/metrics_web_contents_observer.h

 // 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.
 
 #ifndef CHROME_BROWSER_PAGE_LOAD_METRICS_METRICS_WEB_CONTENTS_OBSERVER_H_
 #define CHROME_BROWSER_PAGE_LOAD_METRICS_METRICS_WEB_CONTENTS_OBSERVER_H_
 
 #include <map>
 #include <memory>
 #include <vector>
@@ skipping 164 matching lines @@
   void AddObserver(std::unique_ptr<PageLoadMetricsObserver> observer);
 
   // If the user performs some abort-like action while we are tracking this page
   // load, notify the tracker. Note that we may not classify this as an abort if
   // we've already performed a first paint.
   // is_certainly_browser_timestamp signifies if the timestamp passed is taken
   // in the
   // browser process or not. We need this to possibly clamp browser timestamp on
   // a machine with inter process time tick skew.
   void NotifyAbort(UserAbortType abort_type,
+                   bool user_initiated,
                    base::TimeTicks timestamp,
                    bool is_certainly_browser_timestamp);
   void UpdateAbort(UserAbortType abort_type,
+                   bool user_initiated,
                    base::TimeTicks timestamp,
                    bool is_certainly_browser_timestamp);
 
   // This method returns true if this page load has been aborted with type of
   // ABORT_OTHER, and the |abort_cause_time| is within a sufficiently close
   // delta to when it was aborted. Note that only provisional loads can be
   // aborted with ABORT_OTHER. While this heuristic is coarse, it works better
   // and is simpler than other feasible methods. See https://goo.gl/WKRG98.
   bool IsLikelyProvisionalAbort(base::TimeTicks abort_cause_time) const;
 
@@ skipping 14 matching lines @@
  private:
   // This function converts a TimeTicks value taken in the browser process
   // to navigation_start_ if:
   // - base::TimeTicks is not comparable across processes because the clock
   // is not system wide monotonic.
   // - *event_time < navigation_start_
   void ClampBrowserTimestampIfInterProcessTimeTickSkew(
       base::TimeTicks* event_time);
 
   void UpdateAbortInternal(UserAbortType abort_type,
+                           bool user_initiated,
                            base::TimeTicks timestamp,
                            bool is_certainly_browser_timestamp);
 
   // If |final_navigation| is null, then this is an "unparented" abort chain,
   // and represents a sequence of provisional aborts that never ends with a
   // committed load.
   void LogAbortChainHistograms(content::NavigationHandle* final_navigation);
 
   // Whether we stopped tracking this navigation after it was initiated. We may
   // stop tracking a navigation if it doesn't meet the criteria for tracking
@@ skipping 13 matching lines @@
 
   // The URL of this page load. This is the provisional url before commit
   // (before redirects), and the committed url after commit.
   GURL url_;
 
   std::unique_ptr<FailedProvisionalLoadInfo> failed_provisional_load_info_;
 
   // Will be ABORT_NONE if we have not aborted this load yet. Otherwise will
   // be the first abort action the user performed.
   UserAbortType abort_type_;
+
+  // This boolean is only an approximation. As the aborts pipeline is updated,
+  // more abort types will have this set to true. Currently, this is only set
+  // for navigations aborting navigations.
+  bool abort_user_initiated_;
+
   base::TimeTicks abort_time_;
 
   // We record separate metrics for events that occur after a background,
   // because metrics like layout/paint are delayed artificially
   // when they occur in the background.
   base::TimeTicks background_time_;
   base::TimeTicks foreground_time_;
   bool started_in_foreground_;
 
   PageLoadTiming timing_;
   PageLoadMetadata metadata_;
 
   ui::PageTransition page_transition_;
 
   // Note: these are only approximations, based on WebContents attribution from
   // ResourceRequestInfo objects while this is the currently committed load in
   // the WebContents.
   int num_cache_requests_;
   int num_network_requests_;
 
+  // This is derived from the user gesture bit in the renderer. For browser
+  // initiated navigations this will always be true.
+  bool user_gesture_;
+
   // This is a subtle member. If a provisional load A gets aborted by
   // provisional load B, which gets aborted by C that eventually commits, then
   // there exists an abort chain of length 2, starting at A's navigation_start.
   // This is useful because it allows histograming abort chain lengths based on
   // what the last load's transition type is. i.e. holding down F-5 to spam
   // reload will produce a long chain with the RELOAD transition.
   const int aborted_chain_size_;
 
   // This member counts consecutive provisional aborts that share a url. It will
   // always be less than or equal to |aborted_chain_size_|.
@@ skipping 62 matching lines @@
   void HandleFailedNavigationForTrackedLoad(
       content::NavigationHandle* navigation_handle,
       std::unique_ptr<PageLoadTracker> tracker);
 
   void HandleCommittedNavigationForTrackedLoad(
       content::NavigationHandle* navigation_handle,
       std::unique_ptr<PageLoadTracker> tracker);
 
   // Notify all loads, provisional and committed, that we performed an action
   // that might abort them.
-  void NotifyAbortAllLoads(UserAbortType abort_type);
+  void NotifyAbortAllLoads(UserAbortType abort_type, bool user_initiated);
   void NotifyAbortAllLoadsWithTimestamp(UserAbortType abort_type,
+                                        bool user_initiated,
                                         base::TimeTicks timestamp,
                                         bool is_certainly_browser_timestamp);
 
   // Register / Unregister input event callback to given RenderViewHost
   void RegisterInputEventObserver(content::RenderViewHost* host);
   void UnregisterInputEventObserver(content::RenderViewHost* host);
 
   // Notify aborted provisional loads that a new navigation occurred. This is
   // used for more consistent attribution tracking for aborted provisional
   // loads. This method returns the provisional load that was likely aborted
@@ skipping 33 matching lines @@
 
   // Has the MWCO observed at least one navigation?
   bool has_navigated_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsWebContentsObserver);
 };
 
 }  // namespace page_load_metrics
 
 #endif  // CHROME_BROWSER_PAGE_LOAD_METRICS_METRICS_WEB_CONTENTS_OBSERVER_H_