Provide currently_committed_url to PageLoadMetricsObservers

components/page_load_metrics/browser/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 COMPONENTS_PAGE_LOAD_METRICS_BROWSER_METRICS_WEB_CONTENTS_OBSERVER_H_
 #define COMPONENTS_PAGE_LOAD_METRICS_BROWSER_METRICS_WEB_CONTENTS_OBSERVER_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 88 matching lines @@
   virtual void RegisterObservers(PageLoadTracker* metrics) = 0;
 };
 
 // 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.
+  // class. The PageLoadTracker must not hold on to
+  // currently_committed_load_or_null beyond the scope of the constructor.

[Charlie Harrison, 2016/04/15 16:51:38]

Might as well as the same thing about the NavigationHandle while you're at it.

[Bryan McQuade, 2016/04/15 17:21:44]

Done

   PageLoadTracker(bool in_foreground,
                   PageLoadMetricsEmbedderInterface* embedder_interface,
+                  PageLoadTracker* const currently_committed_load_or_null,
                   content::NavigationHandle* navigation_handle,
                   int aborted_chain_size,
                   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();
 
   // Returns true if the timing was successfully updated.
   bool UpdateTiming(const PageLoadTiming& timing,
                     const PageLoadMetadata& metadata);
-  bool HasBackgrounded();
 
   void set_renderer_tracked(bool renderer_tracked);
   bool renderer_tracked() const { return renderer_tracked_; }
 
   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_; }
 
   void AddObserver(scoped_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.
   void NotifyAbort(UserAbortType abort_type, base::TimeTicks timestamp);
   void UpdateAbort(UserAbortType abort_type, base::TimeTicks 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);
 
   bool MatchesOriginalNavigation(content::NavigationHandle* navigation_handle);
 
+  // Only valid to call post-commit.
+  const GURL& committed_url() const {
+    DCHECK(!commit_time_.is_null());
+    return url_;
+  }
+
  private:
   PageLoadExtraInfo GetPageLoadMetricsInfo();
 
-  // Only valid to call post-commit.
-  const GURL& committed_url();
-
   void UpdateAbortInternal(UserAbortType abort_type,
                            base::TimeTicks 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 the renderer should be sending timing IPCs to this page load.
   bool renderer_tracked_;
@@ skipping 115 matching lines @@
   std::vector<scoped_ptr<PageLoadTracker>> aborted_provisional_loads_;
 
   scoped_ptr<PageLoadTracker> committed_load_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsWebContentsObserver);
 };
 
 }  // namespace page_load_metrics
 
 #endif  // COMPONENTS_PAGE_LOAD_METRICS_BROWSER_METRICS_WEB_CONTENTS_OBSERVER_H_