[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_navigated_(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 18 matching lines @@
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void MetricsWebContentsObserver::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame())
     return;
   if (embedder_interface_->IsPrerendering(web_contents()))
     return;
+  if (navigation_handle->GetURL().spec().compare(url::kAboutBlankURL) == 0)
+    return;
 
   std::unique_ptr<PageLoadTracker> last_aborted =
       NotifyAbortedProvisionalLoadsNewNavigation(navigation_handle);
 
   int chain_size_same_url = 0;
   int chain_size = 0;
   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. 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_navigated_ && opener
+          ? web_contents()->GetOpener()->GetLastCommittedURL()
+          : GURL::EmptyGURL();
+  const GURL& currently_committed_url =
+      committed_load_ ? committed_load_->committed_url() : opener_url;
+  has_navigated_ = true;
+
   // 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 184 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