Refactor PageLoadMetricsObserver completion callback policy

components/page_load_metrics/browser/page_load_metrics_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 COMPONENTS_PAGE_LOAD_METRICS_BROWSER_PAGE_LOAD_METRICS_OBSERVER_H_
 #define COMPONENTS_PAGE_LOAD_METRICS_BROWSER_PAGE_LOAD_METRICS_OBSERVER_H_
 
 #include "base/macros.h"
 #include "base/optional.h"
 #include "components/page_load_metrics/common/page_load_timing.h"
@@ skipping 32 matching lines @@
   ABORT_OTHER,
 
   // The load aborted due to another navigation, but it isn't clear what type of
   // navigation it was.
   ABORT_UNKNOWN_NAVIGATION,
 
   // Add values before this final count.
   ABORT_LAST_ENTRY
 };
 
+// Information related to failed provisional loads.
+struct FailedProvisionalLoadInfo {
+  FailedProvisionalLoadInfo(base::TimeDelta interval, net::Error error);
+  ~FailedProvisionalLoadInfo();
+
+  base::TimeDelta time_to_failed_provisional_load;
+  net::Error error;
+};
+
 struct PageLoadExtraInfo {
   PageLoadExtraInfo(
       const base::Optional<base::TimeDelta>& first_background_time,
       const base::Optional<base::TimeDelta>& first_foreground_time,
       bool started_in_foreground,
       const GURL& committed_url,
       const base::Optional<base::TimeDelta>& time_to_commit,
       UserAbortType abort_type,
       const base::Optional<base::TimeDelta>& time_to_abort,
       const PageLoadMetadata& metadata);
@@ skipping 52 matching lines @@
   // be called multiple times.
   virtual void OnRedirect(content::NavigationHandle* navigation_handle) {}
 
   // OnCommit is triggered when a page load commits, i.e. when we receive the
   // first data for the request. The navigation handle holds relevant data for
   // the navigation, but will be destroyed soon after this call. Don't hold a
   // reference to it.
   // Note that this does not get called for same page navigations.
   virtual void OnCommit(content::NavigationHandle* navigation_handle) {}
 
-  // OnFailedProvisionalLoad is triggered when a provisional load failed and did
-  // not commit. Note that provisional loads that result in downloads or 204s
-  // are aborted by the system, and thus considered failed provisional loads.
-  virtual void OnFailedProvisionalLoad(
-      content::NavigationHandle* navigation_handle) {}
-
   // OnHidden is triggered when a page leaves the foreground. It does not fire
   // when a foreground page is permanently closed; for that, listen to
   // OnComplete instead.
   virtual void OnHidden() {}
 
   // OnShown is triggered when a page is brought to the foreground. It does not
   // fire when the page first loads; for that, listen for OnStart instead.
   virtual void OnShown() {}
 
   // The callbacks below are only invoked after a navigation commits, for
   // tracked page loads. Page loads that don't meet the criteria for being
   // tracked at the time a navigation commits will not receive any of the
   // callbacks below.
 
   // OnTimingUpdate is triggered when an updated PageLoadTiming is
   // available. This method may be called multiple times over the course of the
   // page load. This method is currently only intended for use in testing. Most
   // implementers should implement one of the On* callbacks, such as
   // OnFirstContentfulPaint or OnDomContentLoadedEventStart. Please email
   // loading-dev@chromium.org if you intend to override this method.
   virtual void OnTimingUpdate(const PageLoadTiming& timing,
                               const PageLoadExtraInfo& extra_info) {}
-
   // OnUserInput is triggered when a new user input is passed in to
   // web_contents. Contains a TimeDelta from navigation start.
   virtual void OnUserInput(const blink::WebInputEvent& event) {}
 
   // The following methods are invoked at most once, when the timing for the
   // associated event first becomes available.
   virtual void OnDomContentLoadedEventStart(
       const PageLoadTiming& timing,
       const PageLoadExtraInfo& extra_info) {}
   virtual void OnLoadEventStart(const PageLoadTiming& timing,
@@ skipping 11 matching lines @@
   virtual void OnParseStart(const PageLoadTiming& timing,
                             const PageLoadExtraInfo& extra_info) {}
   virtual void OnParseStop(const PageLoadTiming& timing,
                            const PageLoadExtraInfo& extra_info) {}
 
   // Observer method to be invoked when there is a change in PageLoadMetadata's
   // behavior_flags.
   virtual void OnLoadingBehaviorObserved(
       const page_load_metrics::PageLoadExtraInfo& extra_info) {}
 
-  // OnComplete is invoked for tracked page loads, immediately before the
-  // observer is deleted.  The PageLoadTiming struct contains timing data and
-  // the PageLoadExtraInfo struct contains other useful data collected over the
-  // course of the page load. Most observers should not need to implement this
-  // method, and should implement the On* timing callbacks instead.
+  // One of OnComplete or OnFailedProvisionalLoad is invoked for tracked page
+  // loads, immediately before the observer is deleted. These callbacks will not
+  // be invoked for page loads that did not meet the criteria for being tracked
+  // at the time the navigation completed. The PageLoadTiming struct contains
+  // timing data and the PageLoadExtraInfo struct contains other useful data
+  // collected over the course of the page load. Most observers should not need
+  // to implement these callbacks, and should implement the On* timing callbacks
+  // instead.
+
+  // OnComplete is invoked for tracked page loads that committed, immediately
+  // before the observer is deleted.
   virtual void OnComplete(const PageLoadTiming& timing,
                           const PageLoadExtraInfo& extra_info) {}
+
+  // OnFailedProvisionalLoad is invoked for tracked page loads that did not
+  // commit, immediately before the observer is deleted. Note that provisional
+  // loads that result in downloads or 204s are aborted by the system, and are
+  // also included as failed provisional loads.
+  virtual void OnFailedProvisionalLoad(
+      const FailedProvisionalLoadInfo& failed_provisional_load_info,
+      const PageLoadExtraInfo& extra_info) {}
 };
 
 }  // namespace page_load_metrics
 
 #endif  // COMPONENTS_PAGE_LOAD_METRICS_BROWSER_PAGE_LOAD_METRICS_OBSERVER_H_