Generalize abort tracking to page end state tracking

chrome/browser/page_load_metrics/page_load_tracker.h

 // Copyright 2016 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_PAGE_LOAD_TRACKER_H_
 #define CHROME_BROWSER_PAGE_LOAD_METRICS_PAGE_LOAD_TRACKER_H_
 
 #include <memory>
 #include <vector>
 
@@ skipping 59 matching lines @@
   // We received an IPC even through the last committed url from the browser
   // was not http/s. This can happen with the renderer sending IPCs for the
   // new tab page. This will often come paired with
   // ERR_IPC_WITH_NO_RELEVANT_LOAD.
   ERR_IPC_FROM_BAD_URL_SCHEME,
 
   // If we track a navigation, but the renderer sends us no IPCs. This could
   // occur if the browser filters loads less aggressively than the renderer.
   ERR_NO_IPCS_RECEIVED,
 
-  // Tracks frequency with which we record an abort time that occurred before
+  // Tracks frequency with which we record an end time that occurred before
   // navigation start. This is expected to happen in some cases (see comments in
   // cc file for details). We use this error counter to understand how often it
   // happens.
-  ERR_ABORT_BEFORE_NAVIGATION_START,
+  ERR_END_BEFORE_NAVIGATION_START,
 
   // A new navigation triggers abort updates in multiple trackers in
   // |aborted_provisional_loads_|, when usually there should only be one (the
   // navigation that just aborted because of this one). If this happens, the
   // latest aborted load is used to track the chain size.
   ERR_NAVIGATION_SIGNALS_MULIPLE_ABORTED_LOADS,
 
   // Received user input without a relevant load. This error type is deprecated,
   // as it is valid to receive user input without a relevant load. We leave the
   // enum value here since it's also used in histogram recording, so it's
   // important that we not re-use this enum entry for a different value.
   DEPRECATED_ERR_USER_INPUT_WITH_NO_RELEVANT_LOAD,
 
   // A TimeTicks value in the browser process has value less than
   // navigation_start_. This could happen if navigation_start_ was computed in
   // renderer process and the system clock has inter process time tick skew.
   ERR_INTER_PROCESS_TIME_TICK_SKEW,
 
   // At the time a PageLoadTracker was destroyed, we had received neither a
   // commit nor a failed provisional load.
   ERR_NO_COMMIT_OR_FAILED_PROVISIONAL_LOAD,
 
+  // No page load end time was recorded for this page load.
+  ERR_NO_PAGE_LOAD_END_TIME,
+
   // Add values before this final count.
   ERR_LAST_ENTRY,
 };
 
 // NOTE: these functions are shared by page_load_tracker.cc and
 // metrics_web_contents_observer.cc. They are declared here to allow both files
 // to access them.
 void RecordInternalError(InternalErrorLoadEvent event);
-UserAbortType AbortTypeForPageTransition(ui::PageTransition transition);
+PageEndReason EndReasonForPageTransition(ui::PageTransition transition);
 void LogAbortChainSameURLHistogram(int aborted_chain_size_same_url);
 bool IsNavigationUserInitiated(content::NavigationHandle* handle);
 
 // This class tracks a given page load, starting from navigation start /
 // provisional load, until a new navigation commits or the navigation fails.
 // MetricsWebContentsObserver manages a set of provisional PageLoadTrackers, as
 // well as a committed PageLoadTracker.
 class PageLoadTracker {
  public:
   // Caller must guarantee that the embedder_interface pointer outlives this
   // class. The PageLoadTracker must not hold on to
   // currently_committed_load_or_null or navigation_handle beyond the scope of
   // the constructor.
   PageLoadTracker(bool in_foreground,
                   PageLoadMetricsEmbedderInterface* embedder_interface,
                   const GURL& currently_committed_url,
                   content::NavigationHandle* navigation_handle,
                   UserInitiatedInfo user_initiated_info,
                   int aborted_chain_size,
                   int aborted_chain_size_same_url);
   ~PageLoadTracker();
   void Redirect(content::NavigationHandle* navigation_handle);
   void WillProcessNavigationResponse(
       content::NavigationHandle* navigation_handle);
   void Commit(content::NavigationHandle* navigation_handle);
-  void FailedProvisionalLoad(content::NavigationHandle* navigation_handle);
+  void FailedProvisionalLoad(content::NavigationHandle* navigation_handle,
+                             base::TimeTicks failed_load_time);
   void WebContentsHidden();
   void WebContentsShown();
 
   void OnInputEvent(const blink::WebInputEvent& event);
 
   // Flush any buffered metrics, as part of the metrics subsystem persisting
   // metrics as the application goes into the background. The application may be
   // killed at any time after this method is invoked without further
   // notification.
   void FlushMetricsOnAppEnterBackground();
 
   void NotifyClientRedirectTo(const PageLoadTracker& destination);
 
   // Returns true if the timing was successfully updated.
   bool UpdateTiming(const PageLoadTiming& timing,
                     const PageLoadMetadata& metadata);
 
   void OnLoadedResource(const ExtraRequestInfo& extra_request_info);
 
   // Signals that we should stop tracking metrics for the associated page load.
   // We may stop tracking a page load if it doesn't meet the criteria for
   // tracking metrics in DidFinishNavigation.
   void StopTracking();
 
   int aborted_chain_size() const { return aborted_chain_size_; }
   int aborted_chain_size_same_url() const {
     return aborted_chain_size_same_url_;
   }
 
-  UserAbortType abort_type() const { return abort_type_; }
-  base::TimeTicks abort_time() const { return abort_time_; }
+  PageEndReason page_end_reason() const { return page_end_reason_; }
+  base::TimeTicks page_end_time() const { return page_end_time_; }
 
   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,
-                   UserInitiatedInfo user_initiated_info,
-                   base::TimeTicks timestamp,
-                   bool is_certainly_browser_timestamp);
-  void UpdateAbort(UserAbortType abort_type,
-                   UserInitiatedInfo user_initiated_info,
-                   base::TimeTicks timestamp,
-                   bool is_certainly_browser_timestamp);
+  void NotifyPageEnd(PageEndReason page_end_reason,
+                     UserInitiatedInfo user_initiated_info,
+                     base::TimeTicks timestamp,
+                     bool is_certainly_browser_timestamp);
+  void UpdatePageEnd(PageEndReason page_end_reason,
+                     UserInitiatedInfo user_initiated_info,
+                     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
+  // END_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
+  // aborted with END_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;
 
   bool MatchesOriginalNavigation(content::NavigationHandle* navigation_handle);
 
   bool did_commit() const { return did_commit_; }
   const GURL& url() const { return url_; }
 
   base::TimeTicks navigation_start() const { return navigation_start_; }
 
@@ skipping 15 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,
-                           UserInitiatedInfo user_initiated_info,
-                           base::TimeTicks timestamp,
-                           bool is_certainly_browser_timestamp);
+  void UpdatePageEndInternal(PageEndReason page_end_reason,
+                             UserInitiatedInfo user_initiated_info,
+                             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);
 
   void MaybeUpdateURL(content::NavigationHandle* navigation_handle);
 
   UserInputTracker input_tracker_;
 
@@ skipping 14 matching lines @@
   GURL url_;
 
   // The start URL for this page load (before redirects).
   GURL start_url_;
 
   // Whether this page load committed.
   bool did_commit_;
 
   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_;
+  // Will be END_NONE if we have not ended this load yet. Otherwise will
+  // be the first page end reason encountered.
+  PageEndReason page_end_reason_;
 
-  // Whether the abort for this page load was user initiated. For example, if
-  // this page load was aborted by a new navigation, this field tracks whether
-  // that new navigation was user-initiated. This field is only useful if this
-  // page load's abort type is a value other than ABORT_NONE. Note that this
-  // value is currently experimental, and is subject to change. In particular,
-  // this field is never set to true for some abort types, such as stop and
-  // close, since we don't yet have sufficient instrumentation to know if a stop
-  // or close was caused by a user action.
-  UserInitiatedInfo abort_user_initiated_info_;
+  // Whether the page end cause for this page load was user initiated. For
+  // example, if this page load was ended by a new navigation, this field tracks
+  // whether that new navigation was user-initiated. This field is only useful
+  // if this page load's end reason is a value other than END_NONE. Note that
+  // this value is currently experimental, and is subject to change. In
+  // particular, this field is never set to true for some page end reasons, such
+  // as stop and close, since we don't yet have sufficient instrumentation to
+  // know if a stop or close was caused by a user action.
+  UserInitiatedInfo page_end_user_initiated_info_;
 
-  base::TimeTicks abort_time_;
+  base::TimeTicks page_end_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_;
@@ skipping 21 matching lines @@
   PageLoadMetricsEmbedderInterface* const embedder_interface_;
 
   std::vector<std::unique_ptr<PageLoadMetricsObserver>> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(PageLoadTracker);
 };
 
 }  // namespace page_load_metrics
 
 #endif  // CHROME_BROWSER_PAGE_LOAD_METRICS_PAGE_LOAD_TRACKER_H_