Add PLMObserver::FlushMetricsOnAppEnterBackground.

chrome/browser/page_load_metrics/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 CHROME_BROWSER_PAGE_LOAD_METRICS_PAGE_LOAD_METRICS_OBSERVER_H_
 #define CHROME_BROWSER_PAGE_LOAD_METRICS_PAGE_LOAD_METRICS_OBSERVER_H_
 
 #include "base/macros.h"
 #include "base/optional.h"
 #include "chrome/common/page_load_metrics/page_load_timing.h"
@@ skipping 110 matching lines @@
 
   // Extra information supplied to the page load metrics system from the
   // renderer.
   const PageLoadMetadata metadata;
 };
 
 // Interface for PageLoadMetrics observers. All instances of this class are
 // owned by the PageLoadTracker tracking a page load.
 class PageLoadMetricsObserver {
  public:
+  // ObservePolicy is used as a return value on some PageLoadMetricsObserver
+  // callbacks to indicate whether the observer would like to continue observing
+  // metric callbacks. Observers that wish to continue observing metric
+  // callbacks should return CONTINUE_OBSERVING; observers that wish to stop
+  // observing callbacks should return STOP_OBSERVING. Observers that return
+  // STOP_OBSERVING may be deleted.
+  enum ObservePolicy {
+    CONTINUE_OBSERVING,
+    STOP_OBSERVING,
+  };
+
   virtual ~PageLoadMetricsObserver() {}
 
   // The page load started, with the given navigation handle. Note that OnStart
   // is called for same-page navigations. Implementers of OnStart that only want
   // to process non-same-page navigations should also check to see that the page
   // load committed via OnCommit or committed_url in
   // PageLoadExtraInfo. currently_committed_url contains the URL of the
   // committed page load at the time the navigation for navigation_handle was
   // initiated, or the empty URL if there was no committed page load at the time
   // the navigation was initiated.
@@ skipping 57 matching lines @@
                                  const PageLoadExtraInfo& extra_info) {}
   virtual void OnFirstContentfulPaint(const PageLoadTiming& timing,
                                       const PageLoadExtraInfo& extra_info) {}
   virtual void OnFirstMeaningfulPaint(const PageLoadTiming& timing,
                                       const PageLoadExtraInfo& extra_info) {}
   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.
+  // Invoked when there is a change in PageLoadMetadata's behavior_flags.
   virtual void OnLoadingBehaviorObserved(
       const page_load_metrics::PageLoadExtraInfo& extra_info) {}
 
+  // Invoked when the UMA metrics subsystem is persisting metrics as the
+  // application goes into the background, on platforms where the browser
+  // process may be killed after backgrounding (Android). Implementers should
+  // persist any metrics that have been buffered in memory in this callback, as
+  // the application may be killed at any time after this method is invoked
+  // without further notification. Note that this may be called both for
+  // provisional loads as well as committed loads. Implementations that only
+  // want to track committed loads should check extra_info.time_to_commit to
+  // determine if the load had committed. If the implementation returns
+  // CONTINUE_OBSERVING, this method may be called multiple times per observer,
+  // once for each time that the application enters the backround.
+  //
+  // The default implementation does nothing, and returns CONTINUE_OBSERVING.
+  virtual ObservePolicy FlushMetricsOnAppEnterBackground(
+      const PageLoadTiming& timing,
+      const PageLoadExtraInfo& extra_info);
+
   // 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  // CHROME_BROWSER_PAGE_LOAD_METRICS_PAGE_LOAD_METRICS_OBSERVER_H_