Notify page load metrics when the app enters the background.

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 121 matching lines @@
                   int aborted_chain_size_same_url);
   ~PageLoadTracker();
   void Redirect(content::NavigationHandle* navigation_handle);
   void Commit(content::NavigationHandle* navigation_handle);
   void FailedProvisionalLoad(content::NavigationHandle* navigation_handle);
   void WebContentsHidden();
   void WebContentsShown();
 
   void OnInputEvent(const blink::WebInputEvent& event);
 
+  void FlushMetricsOnAppEnterBackground();
+
   void NotifyClientRedirectTo(const PageLoadTracker& destination);
 
   // Returns true if the timing was successfully updated.
   bool UpdateTiming(const PageLoadTiming& timing,
                     const PageLoadMetadata& metadata);
 
   // 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();
@@ skipping 57 matching lines @@
   // 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
   // metrics in DidFinishNavigation.
   bool did_stop_tracking_;
 
+  // Whether the application went into the background when this PageLoadTracker
+  // was active. This is a temporary boolean for UMA tracking.
+  bool app_entered_background_;
+
   // The navigation start in TimeTicks, not the wall time reported by Blink.
   const base::TimeTicks navigation_start_;
 
   // Time this page load was committed. If this page load hasn't committed,
   // |commit_time_| will be zero.
   base::TimeTicks commit_time_;
 
   // The URL of this page load. This is the provisional url before commit
   // (before redirects), and the committed url after commit.
   GURL url_;
@@ skipping 45 matching lines @@
  public:
   // Note that the returned metrics is owned by the web contents.
   static MetricsWebContentsObserver* CreateForWebContents(
       content::WebContents* web_contents,
       std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface);
   MetricsWebContentsObserver(
       content::WebContents* web_contents,
       std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface);
   ~MetricsWebContentsObserver() override;
 
+  // Returns all currently active MetricsWebContentsObservers. Callers should
+  // not hold on to the returned observers beyond the scope of the current
+  // function, as the MetricsWebContentsObservers may be destroyed as their
+  // associated WebContents are destroyed.
+  static std::vector<MetricsWebContentsObserver*> GetAllObservers();
+
   // content::WebContentsObserver implementation:
   bool OnMessageReceived(const IPC::Message& message,
                          content::RenderFrameHost* render_frame_host) override;
   void DidStartNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidFinishNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidRedirectNavigation(
       content::NavigationHandle* navigation_handle) override;
   void NavigationStopped() override;
   void OnInputEvent(const blink::WebInputEvent& event) override;
   void WasShown() override;
   void WasHidden() override;
   void RenderProcessGone(base::TerminationStatus status) override;
   void RenderViewHostChanged(content::RenderViewHost* old_host,
                              content::RenderViewHost* new_host) override;
 
+  void FlushMetricsOnAppEnterBackground();

[Charlie Harrison, 2016/07/28 14:45:28]

Do we need to include "flush metrics" in the name? Can observers just do what
they want with the knowledge that they app entered the background?

[Bryan McQuade, 2016/07/28 16:26:11]

Yeah - I debated this. Technically, this method is coupled to the metrics
subsystem's backgrounding logic. This callback is guaranteed to be called before
the metrics subsystem writes metrics out to disk as part of its backgrounding
logic. A generic OnAppEnterBackground wouldn't necessarily make this guarantee -
it might get called during backgrounding, but after the metrics subsystem has
finished flushing metrics, which wouldn't be the right timing for flushing
metrics. Similarly, if there's some other chrome subsystem that observers need
to interact with as part of backgrounding in the future, we'll probably need a
separate callback that's guaranteed to get called as part of the backgrounding
flow for that component, so we can be sure it's called e.g. before that other
subsystem is done persisting its data. Given all this, I decided it was better
to explicitly include 'FlushMetrics' in the name.

I added a comment to better explain.

[Charlie Harrison, 2016/07/28 16:38:04]

SGTM.

+
   // This getter function is required for testing.
   const PageLoadExtraInfo GetPageLoadExtraInfoForCommittedLoad();
 
  private:
   friend class content::WebContentsUserData<MetricsWebContentsObserver>;
 
   void HandleFailedNavigationForTrackedLoad(
       content::NavigationHandle* navigation_handle,
       std::unique_ptr<PageLoadTracker> tracker);
 
@@ skipping 51 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_