[page_load_metrics] use data from WebContents::GetOpener

components/page_load_metrics/browser/metrics_web_contents_observer.cc

 // 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.
 
 #include "components/page_load_metrics/browser/metrics_web_contents_observer.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 190 matching lines @@
     UMA_HISTOGRAM_COUNTS(internal::kAbortChainSizeSameURL,
                          aborted_chain_size_same_url);
   }
 }
 
 }  // namespace
 
 PageLoadTracker::PageLoadTracker(
     bool in_foreground,
     PageLoadMetricsEmbedderInterface* embedder_interface,
-    PageLoadTracker* const currently_committed_load_or_null,
+    const GURL& currently_committed_url,
     content::NavigationHandle* navigation_handle,
     int aborted_chain_size,
     int aborted_chain_size_same_url)
     : renderer_tracked_(false),
       navigation_start_(navigation_handle->NavigationStart()),
       url_(navigation_handle->GetURL()),
       abort_type_(ABORT_NONE),
       started_in_foreground_(in_foreground),
       aborted_chain_size_(aborted_chain_size),
       aborted_chain_size_same_url_(aborted_chain_size_same_url),
       embedder_interface_(embedder_interface) {
   DCHECK(!navigation_handle->HasCommitted());
   embedder_interface_->RegisterObservers(this);
-  const GURL& currently_committed_url =
-      currently_committed_load_or_null
-          ? currently_committed_load_or_null->committed_url()
-          : GURL::EmptyGURL();
   for (const auto& observer : observers_) {
     observer->OnStart(navigation_handle, currently_committed_url);
   }
 }
 
 PageLoadTracker::~PageLoadTracker() {
   const PageLoadExtraInfo info = GetPageLoadMetricsInfo();
   if (!info.time_to_commit.is_zero() && renderer_tracked() &&
       timing_.IsEmpty()) {
     RecordInternalError(ERR_NO_IPCS_RECEIVED);
@@ skipping 216 matching lines @@
   abort_type_ = abort_type;
   abort_time_ = timestamp;
 }
 
 // static
 MetricsWebContentsObserver::MetricsWebContentsObserver(
     content::WebContents* web_contents,
     std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface)
     : content::WebContentsObserver(web_contents),
       in_foreground_(false),
-      embedder_interface_(std::move(embedder_interface)) {}
+      embedder_interface_(std::move(embedder_interface)),
+      has_commit_(false) {}
 
 MetricsWebContentsObserver* MetricsWebContentsObserver::CreateForWebContents(
     content::WebContents* web_contents,
     std::unique_ptr<PageLoadMetricsEmbedderInterface> embedder_interface) {
   DCHECK(web_contents);
 
   MetricsWebContentsObserver* metrics = FromWebContents(web_contents);
   if (!metrics) {
     metrics = new MetricsWebContentsObserver(web_contents,
                                              std::move(embedder_interface));
@@ skipping 34 matching lines @@
   if (last_aborted) {
     if (last_aborted->MatchesOriginalNavigation(navigation_handle)) {
       chain_size_same_url = last_aborted->aborted_chain_size_same_url() + 1;
     } else if (last_aborted->aborted_chain_size_same_url() > 0) {
       LogAbortChainSameURLHistogram(
           last_aborted->aborted_chain_size_same_url());
     }
     chain_size = last_aborted->aborted_chain_size() + 1;
   }
 
+  // Pass in the last committed url to the PageLoadTracker. This is used for
+  // FromGWS metrics. If the MWCO has never observed a committed load, use the
+  // last committed url from this WebContent's opener. This is more accurate
+  // than using referrers due to referrer sanitizing and origin referrers. Note
+  // that this could potentially be inaccurate if the opener has since
+  // navigated.
+  content::WebContents* opener = web_contents()->GetOpener();
+  const GURL& opener_url =
+      !has_commit_ && opener
+          ? web_contents()->GetOpener()->GetLastCommittedURL()
+          : GURL::EmptyGURL();
+  const GURL currently_committed_url =

[Bryan McQuade, 2016/04/26 18:36:39]

do you want this to be const GURL or const GURL& ?

[Charlie Harrison, 2016/04/26 19:02:41]

const GURL&. Good catch.

+      committed_load_ ? committed_load_->committed_url() : opener_url;
+
   // We can have two provisional loads in some cases. E.g. a same-site
   // navigation can have a concurrent cross-process navigation started
   // from the omnibox.
   DCHECK_GT(2ul, provisional_loads_.size());
   // Passing raw pointers to observers_ and embedder_interface_ is safe because
   // the MetricsWebContentsObserver owns them both list and they are torn down
   // after the PageLoadTracker. The PageLoadTracker does not hold on to
   // committed_load_ or navigation_handle beyond the scope of the constructor.
   provisional_loads_.insert(std::make_pair(
       navigation_handle,
       base::WrapUnique(new PageLoadTracker(
-          in_foreground_, embedder_interface_.get(), committed_load_.get(),
+          in_foreground_, embedder_interface_.get(), currently_committed_url,
           navigation_handle, chain_size, chain_size_same_url))));
 }
 
 void MetricsWebContentsObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
 
   std::unique_ptr<PageLoadTracker> finished_nav(
       std::move(provisional_loads_[navigation_handle]));
@@ skipping 36 matching lines @@
   // Notify other loads that they may have been aborted by this committed load.
   // Note that by using the committed navigation start as the abort cause, we
   // lose data on provisional loads that were aborted by other provisional
   // loads. Those will either be listed as ABORT_OTHER or as being aborted by
   // this load.
   NotifyAbortAllLoadsWithTimestamp(
       AbortTypeForPageTransition(navigation_handle->GetPageTransition()),
       navigation_handle->NavigationStart());
 
   committed_load_ = std::move(finished_nav);
+  has_commit_ = true;
   aborted_provisional_loads_.clear();
 
   const GURL& browser_url = web_contents()->GetLastCommittedURL();
   const std::string& mime_type = web_contents()->GetContentsMimeType();
   DCHECK(!browser_url.is_empty());
   DCHECK(!mime_type.empty());
   committed_load_->set_renderer_tracked(
       IsRelevantNavigation(navigation_handle, browser_url, mime_type));
 
   committed_load_->Commit(navigation_handle);
@@ skipping 128 matching lines @@
 
   if (!committed_load_->UpdateTiming(timing, metadata)) {
     // If the page load tracker cannot update its timing, something is wrong
     // with the IPC (it's from another load, or it's invalid in some other way).
     // We expect this to be a rare occurrence.
     RecordInternalError(ERR_BAD_TIMING_IPC);
   }
 }
 
 }  // namespace page_load_metrics