Remove a bunch of prerender lookups in PLM and metrics code

This patch should change no behavior.

Looking up the prerender contents / manager is not free, This patch
removes four instances in PLM navigation code, and one on every resource
request completion.

Bug: 792524
Change-Id: Ie1dbcd07eedcc82c9e210b0fc378cfd4072b208f
Reviewed-on: https://chromium-review.googlesource.com/822830Reviewed-by: David Roger <droger@chromium.org>
Reviewed-by: Bryan McQuade <bmcquade@chromium.org>
Commit-Queue: Charlie Harrison <csharrison@chromium.org>
Cr-Commit-Position: refs/heads/master@{#529105}

chrome/browser/loader/chrome_resource_dispatcher_host_delegate.cc

@@ -173,17 +173,15 @@ prerender::PrerenderManager* GetPrerenderManager(
 void UpdatePrerenderNetworkBytesCallback(content::WebContents* web_contents,
                                          int64_t bytes) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  // PrerenderContents::FromWebContents handles the NULL case.
-  prerender::PrerenderContents* prerender_contents =
-      prerender::PrerenderContents::FromWebContents(web_contents);
-
-  if (prerender_contents)
-    prerender_contents->AddNetworkBytes(bytes);
-
   prerender::PrerenderManager* prerender_manager =
       GetPrerenderManager(web_contents);
-  if (prerender_manager)
+  if (prerender_manager) {
     prerender_manager->AddProfileNetworkBytesIfEnabled(bytes);
+    prerender::PrerenderContents* prerender_contents =
+        prerender_manager->GetPrerenderContents(web_contents);
+    if (prerender_contents)
+      prerender_contents->AddNetworkBytes(bytes);
+  }
 }
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)

chrome/browser/page_load_metrics/observers/no_state_prefetch_page_load_metrics_observer.cc

@@ -4,9 +4,7 @@
 
 #include "chrome/browser/page_load_metrics/observers/no_state_prefetch_page_load_metrics_observer.h"
 
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/prerender/prerender_manager.h"
-#include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/web_contents.h"
 #include "net/http/http_response_headers.h"
@@ -14,13 +12,11 @@
 // static
 std::unique_ptr<NoStatePrefetchPageLoadMetricsObserver>
 NoStatePrefetchPageLoadMetricsObserver::CreateIfNeeded(
-    content::WebContents* web_contents) {
-  prerender::PrerenderManager* manager =
-      prerender::PrerenderManagerFactory::GetForBrowserContext(
-          web_contents->GetBrowserContext());
+    content::WebContents* web_contents,
+    prerender::PrerenderManager* manager) {
   if (!manager)
     return nullptr;
-  return base::MakeUnique<NoStatePrefetchPageLoadMetricsObserver>(manager);
+  return std::make_unique<NoStatePrefetchPageLoadMetricsObserver>(manager);
 }
 
 NoStatePrefetchPageLoadMetricsObserver::NoStatePrefetchPageLoadMetricsObserver(

chrome/browser/page_load_metrics/observers/no_state_prefetch_page_load_metrics_observer.h

@@ -5,6 +5,8 @@
 #ifndef CHROME_BROWSER_PAGE_LOAD_METRICS_OBSERVERS_NO_STATE_PREFETCH_PAGE_LOAD_METRICS_OBSERVER_H_
 #define CHROME_BROWSER_PAGE_LOAD_METRICS_OBSERVERS_NO_STATE_PREFETCH_PAGE_LOAD_METRICS_OBSERVER_H_
 
+#include <memory>
+
 #include "base/macros.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_observer.h"
 #include "components/ukm/ukm_source.h"
@@ -37,7 +39,8 @@ class NoStatePrefetchPageLoadMetricsObserver
   // needed. Note: can return nullptr at startup, which is believed to be
   // happening rarely.
   static std::unique_ptr<NoStatePrefetchPageLoadMetricsObserver> CreateIfNeeded(
-      content::WebContents* web_contents);
+      content::WebContents* web_contents,
+      prerender::PrerenderManager* manager);
 
   explicit NoStatePrefetchPageLoadMetricsObserver(
       prerender::PrerenderManager* manager);

chrome/browser/page_load_metrics/observers/prerender_page_load_metrics_observer.cc

@@ -5,26 +5,22 @@
 #include "chrome/browser/page_load_metrics/observers/prerender_page_load_metrics_observer.h"
 
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/prerender/prerender_manager.h"
-#include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "content/public/browser/web_contents.h"
 #include "net/http/http_response_headers.h"
 
 // static
 std::unique_ptr<page_load_metrics::PageLoadMetricsObserver>
 PrerenderPageLoadMetricsObserver::CreateIfNeeded(
-    content::WebContents* web_contents) {
-  prerender::PrerenderManager* manager =
-      prerender::PrerenderManagerFactory::GetForBrowserContext(
-          web_contents->GetBrowserContext());
+    content::WebContents* web_contents,
+    prerender::PrerenderManager* manager) {
   if (!manager)
     return nullptr;
 
   if (manager->PageLoadMetricsObserverDisabledForTesting())
     return nullptr;
 
-  return base::MakeUnique<PrerenderPageLoadMetricsObserver>(manager,
+  return std::make_unique<PrerenderPageLoadMetricsObserver>(manager,
                                                             web_contents);
 }
 

chrome/browser/page_load_metrics/observers/prerender_page_load_metrics_observer.h

@@ -5,6 +5,8 @@
 #ifndef CHROME_BROWSER_PAGE_LOAD_METRICS_OBSERVERS_PRERENDER_PAGE_LOAD_METRICS_OBSERVER_H_
 #define CHROME_BROWSER_PAGE_LOAD_METRICS_OBSERVERS_PRERENDER_PAGE_LOAD_METRICS_OBSERVER_H_
 
+#include <memory>
+
 #include "base/macros.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_observer.h"
 #include "components/ukm/ukm_source.h"
@@ -28,7 +30,8 @@ class PrerenderPageLoadMetricsObserver
  public:
   // Returns a PrerenderPageLoadMetricsObserver, or nullptr if it is not needed.
   static std::unique_ptr<page_load_metrics::PageLoadMetricsObserver>
-  CreateIfNeeded(content::WebContents* web_contents);
+  CreateIfNeeded(content::WebContents* web_contents,
+                 prerender::PrerenderManager* manager);
 
   // Public for testing. Normally one should use CreateIfNeeded. Both the
   // manager and the web_contents must outlive this observer.

chrome/browser/page_load_metrics/page_load_metrics_initialize.cc

@@ -9,6 +9,7 @@
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
@@ -42,7 +43,8 @@
 #include "chrome/browser/page_load_metrics/observers/use_counter_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_embedder_interface.h"
 #include "chrome/browser/page_load_metrics/page_load_tracker.h"
-#include "chrome/browser/prerender/prerender_contents.h"
+#include "chrome/browser/prerender/prerender_manager.h"
+#include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
 #include "components/rappor/rappor_service_impl.h"
@@ -71,8 +73,6 @@ class PageLoadMetricsEmbedder
   std::unique_ptr<base::Timer> CreateTimer() override;
 
  private:
-  bool IsPrerendering() const;
-
   content::WebContents* const web_contents_;
 
   DISALLOW_COPY_AND_ASSIGN(PageLoadMetricsEmbedder);
@@ -86,7 +86,12 @@ PageLoadMetricsEmbedder::~PageLoadMetricsEmbedder() {}
 
 void PageLoadMetricsEmbedder::RegisterObservers(
     page_load_metrics::PageLoadTracker* tracker) {
-  if (!IsPrerendering()) {
+  prerender::PrerenderManager* prerender_manager =
+      prerender::PrerenderManagerFactory::GetForBrowserContext(
+          web_contents_->GetBrowserContext());
+  bool is_prerendering =
+      !!prerender_manager->GetPrerenderContents(web_contents_);
+  if (!is_prerendering) {
     tracker->AddObserver(base::MakeUnique<AbortsPageLoadMetricsObserver>());
     tracker->AddObserver(base::MakeUnique<AMPPageLoadMetricsObserver>());
     tracker->AddObserver(base::MakeUnique<CorePageLoadMetricsObserver>());
@@ -132,7 +137,7 @@ void PageLoadMetricsEmbedder::RegisterObservers(
     std::unique_ptr<page_load_metrics::PageLoadMetricsObserver>
         no_state_prefetch_observer =
             NoStatePrefetchPageLoadMetricsObserver::CreateIfNeeded(
-                web_contents_);
+                web_contents_, prerender_manager);
     if (no_state_prefetch_observer)
       tracker->AddObserver(std::move(no_state_prefetch_observer));
 #if defined(OS_ANDROID)
@@ -152,23 +157,19 @@ void PageLoadMetricsEmbedder::RegisterObservers(
     tracker->AddObserver(
         base::MakeUnique<LocalNetworkRequestsPageLoadMetricsObserver>());
   } else {
+    UMA_HISTOGRAM_BOOLEAN("PageLoad.Internal.Prerender", true);
     std::unique_ptr<page_load_metrics::PageLoadMetricsObserver>
-        prerender_observer =
-            PrerenderPageLoadMetricsObserver::CreateIfNeeded(web_contents_);
+        prerender_observer = PrerenderPageLoadMetricsObserver::CreateIfNeeded(
+            web_contents_, prerender_manager);
     if (prerender_observer)
       tracker->AddObserver(std::move(prerender_observer));
   }
   tracker->AddObserver(
-      base::MakeUnique<OmniboxSuggestionUsedMetricsObserver>(IsPrerendering()));
+      base::MakeUnique<OmniboxSuggestionUsedMetricsObserver>(is_prerendering));
   tracker->AddObserver(
       base::MakeUnique<DelayNavigationPageLoadMetricsObserver>());
 }
 
-bool PageLoadMetricsEmbedder::IsPrerendering() const {
-  return prerender::PrerenderContents::FromWebContents(web_contents_) !=
-         nullptr;
-}
-
 std::unique_ptr<base::Timer> PageLoadMetricsEmbedder::CreateTimer() {
   return base::MakeUnique<base::OneShotTimer>();
 }

chrome/browser/page_load_metrics/page_load_tracker.cc

@@ -16,7 +16,6 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_embedder_interface.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
-#include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/common/page_load_metrics/page_load_timing.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_handle.h"
@@ -66,7 +65,6 @@ const char kPageLoadCompletedAfterAppBackground[] =
     "PageLoad.Internal.PageLoadCompleted.AfterAppBackground";
 const char kPageLoadStartedInForeground[] =
     "PageLoad.Internal.NavigationStartedInForeground";
-const char kPageLoadPrerender[] = "PageLoad.Internal.Prerender";
 
 }  // namespace internal
 
@@ -195,11 +193,6 @@ PageLoadTracker::PageLoadTracker(
 
   UMA_HISTOGRAM_BOOLEAN(internal::kPageLoadStartedInForeground,
                         started_in_foreground_);
-  const bool is_prerender = prerender::PrerenderContents::FromWebContents(
-                                navigation_handle->GetWebContents()) != nullptr;
-  if (is_prerender) {
-    UMA_HISTOGRAM_BOOLEAN(internal::kPageLoadPrerender, true);
-  }
 }
 
 PageLoadTracker::~PageLoadTracker() {