[WebLayer] Add entrypoints to Prerender code.

This adds various entrypoints to Prerender code in WebLayer, now that
all the delegate interfaces have implementations and all factories are
in place.

Please see the following spreadsheet to see corresponding chrome
entrypoints and my reasoning for the chrome entrypoints I have left out
of WebLayer:
https://docs.google.com/spreadsheets/d/1u13bzBQiBqibXzDDmkB4Kbvm29DslTQmXmY91864gOU/edit#gid=299677236

Bug: 1096088
Change-Id: I62549bf3a8f6dbd5a5334c87048b197d75fc4001
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2346349
Commit-Queue: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Martin Barbella <mbarbella@chromium.org>
Reviewed-by: Tarun Bansal <tbansal@chromium.org>
Reviewed-by: Ryan Sturm <ryansturm@chromium.org>
Cr-Commit-Position: refs/heads/master@{#797753}

weblayer/BUILD.gn

@@ -214,6 +214,8 @@ source_set("weblayer_lib_base") {
     "browser/no_state_prefetch/prerender_processor_impl_delegate_impl.h",
     "browser/no_state_prefetch/prerender_tab_helper.cc",
     "browser/no_state_prefetch/prerender_tab_helper.h",
+    "browser/no_state_prefetch/prerender_utils.cc",
+    "browser/no_state_prefetch/prerender_utils.h",
     "browser/page_load_metrics_initialize.cc",
     "browser/page_load_metrics_initialize.h",
     "browser/page_specific_content_settings_delegate.cc",
@@ -323,6 +325,8 @@ source_set("weblayer_lib_base") {
     "renderer/content_renderer_client_impl.h",
     "renderer/error_page_helper.cc",
     "renderer/error_page_helper.h",
+    "renderer/url_loader_throttle_provider.cc",
+    "renderer/url_loader_throttle_provider.h",
     "renderer/weblayer_render_frame_observer.cc",
     "renderer/weblayer_render_frame_observer.h",
     "renderer/weblayer_render_thread_observer.cc",
@@ -389,6 +393,11 @@ source_set("weblayer_lib_base") {
     "//components/pref_registry:pref_registry",
     "//components/prefs",
     "//components/prerender/browser",
+    "//components/prerender/common",
+    "//components/prerender/common:mojo_bindings",
+    "//components/prerender/renderer",
+    "//components/safe_browsing/content/common:interfaces",
+    "//components/safe_browsing/content/renderer:throttles",
     "//components/safe_browsing/core:features",
     "//components/security_interstitials/content:security_interstitial_page",
     "//components/security_interstitials/content/renderer:security_interstitial_page_controller",
@@ -551,8 +560,6 @@ source_set("weblayer_lib_base") {
       "common/crash_reporter/crash_keys.h",
       "common/crash_reporter/crash_reporter_client.cc",
       "common/crash_reporter/crash_reporter_client.h",
-      "renderer/url_loader_throttle_provider.cc",
-      "renderer/url_loader_throttle_provider.h",
     ]
     deps += [
       "//android_webview:generate_aw_resources",
@@ -586,8 +593,6 @@ source_set("weblayer_lib_base") {
       "//components/safe_browsing/android:safe_browsing_api_handler",
       "//components/safe_browsing/content",
       "//components/safe_browsing/content/browser",
-      "//components/safe_browsing/content/common:interfaces",
-      "//components/safe_browsing/content/renderer:throttles",
       "//components/safe_browsing/core:ping_manager",
       "//components/safe_browsing/core:verdict_cache_manager",
       "//components/safe_browsing/core/browser",

weblayer/browser/DEPS

@@ -38,6 +38,8 @@ include_rules = [
   "+components/permissions",
   "+components/pref_registry",
   "+components/prefs",
+  "+components/prerender/browser",
+  "+components/prerender/common",
   "+components/resources/android",
   "+components/safe_browsing/core",
   "+components/safe_browsing/core/common",

weblayer/browser/browser_main_parts_impl.cc

@@ -19,6 +19,7 @@
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/main_function_params.h"
+#include "content/public/common/page_visibility_state.h"
 #include "content/public/common/url_constants.h"
 #include "services/service_manager/embedder/result_codes.h"
 #include "ui/base/resource/resource_bundle.h"
@@ -27,6 +28,8 @@
 #include "weblayer/browser/feature_list_creator.h"
 #include "weblayer/browser/host_content_settings_map_factory.h"
 #include "weblayer/browser/i18n_util.h"
+#include "weblayer/browser/no_state_prefetch/prerender_link_manager_factory.h"
+#include "weblayer/browser/no_state_prefetch/prerender_manager_factory.h"
 #include "weblayer/browser/permissions/weblayer_permissions_client.h"
 #include "weblayer/browser/stateful_ssl_host_state_delegate_factory.h"
 #include "weblayer/browser/translate_accept_languages_factory.h"
@@ -81,6 +84,8 @@ void EnsureBrowserContextKeyedServiceFactoriesBuilt() {
   CookieSettingsFactory::GetInstance();
   TranslateAcceptLanguagesFactory::GetInstance();
   TranslateRankerFactory::GetInstance();
+  PrerenderLinkManagerFactory::GetInstance();
+  PrerenderManagerFactory::GetInstance();
 }
 
 void StopMessageLoop(base::OnceClosure quit_closure) {

weblayer/browser/browsing_data_remover_delegate.cc

@@ -6,9 +6,11 @@
 
 #include "base/callback.h"
 #include "components/prefs/pref_service.h"
+#include "components/prerender/browser/prerender_manager.h"
 #include "components/site_isolation//pref_names.h"
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/browser_context.h"
+#include "weblayer/browser/no_state_prefetch/prerender_manager_factory.h"
 
 namespace weblayer {
 
@@ -48,6 +50,19 @@ void BrowsingDataRemoverDelegate::RemoveEmbedderData(
     // list of isolated sites is not directly exposed to users, though, and
     // will be cleared on next restart.
   }
+
+  // The PrerenderManager keeps history of prerendered pages, so clear that.
+  // It also may have a prerendered page. If so, the page could be
+  // considered to have a small amount of historical information, so delete
+  // it, too.
+  prerender::PrerenderManager* prerender_manager =
+      PrerenderManagerFactory::GetForBrowserContext(browser_context_);
+  if (prerender_manager) {
+    prerender_manager->ClearData(
+        prerender::PrerenderManager::CLEAR_PRERENDER_CONTENTS |
+        prerender::PrerenderManager::CLEAR_PRERENDER_HISTORY);
+  }
+
   std::move(callback).Run(/*failed_data_types=*/0);
 }
 

weblayer/browser/content_browser_client_impl.cc

@@ -29,6 +29,8 @@
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service_factory.h"
 #include "components/prefs/scoped_user_pref_update.h"
+#include "components/prerender/browser/prerender_manager.h"
+#include "components/prerender/common/prerender_url_loader_throttle.h"
 #include "components/security_interstitials/content/ssl_cert_reporter.h"
 #include "components/security_interstitials/content/ssl_error_handler.h"
 #include "components/security_interstitials/content/ssl_error_navigation_throttle.h"
@@ -39,6 +41,7 @@
 #include "components/user_prefs/user_prefs.h"
 #include "components/variations/service/variations_service.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/client_certificate_delegate.h"
 #include "content/public/browser/devtools_manager_delegate.h"
 #include "content/public/browser/generated_code_cache_settings.h"
@@ -76,6 +79,8 @@
 #include "weblayer/browser/i18n_util.h"
 #include "weblayer/browser/navigation_controller_impl.h"
 #include "weblayer/browser/navigation_error_navigation_throttle.h"
+#include "weblayer/browser/no_state_prefetch/prerender_manager_factory.h"
+#include "weblayer/browser/no_state_prefetch/prerender_utils.h"
 #include "weblayer/browser/page_specific_content_settings_delegate.h"
 #include "weblayer/browser/password_manager_driver_factory.h"
 #include "weblayer/browser/popup_navigation_delegate_impl.h"
@@ -229,6 +234,14 @@ void RegisterPrefs(PrefRegistrySimple* pref_registry) {
   variations::VariationsService::RegisterPrefs(pref_registry);
 }
 
+mojo::PendingRemote<prerender::mojom::PrerenderCanceler> GetPrerenderCanceler(
+    content::WebContents* web_contents) {
+  mojo::PendingRemote<prerender::mojom::PrerenderCanceler> canceler;
+  weblayer::PrerenderContentsFromWebContents(web_contents)
+      ->AddPrerenderCancelerReceiver(canceler.InitWithNewPipeAndPassReceiver());
+  return canceler;
+}
+
 }  // namespace
 
 ContentBrowserClientImpl::ContentBrowserClientImpl(MainParams* params)
@@ -399,6 +412,18 @@ ContentBrowserClientImpl::CreateURLLoaderThrottles(
   if (signin_throttle)
     result.push_back(std::move(signin_throttle));
 
+  // Create prerender URL throttle.
+  auto* web_contents = wc_getter.Run();
+  auto* prerender_contents = PrerenderContentsFromWebContents(web_contents);
+  if (prerender_contents && prerender_contents->prerender_mode() !=
+                                prerender::mojom::PrerenderMode::kNoPrerender) {
+    result.push_back(std::make_unique<prerender::PrerenderURLLoaderThrottle>(
+        prerender_contents->prerender_mode(),
+        prerender::PrerenderHistograms::GetHistogramPrefix(
+            prerender_contents->origin()),
+        GetPrerenderCanceler(web_contents)));
+  }
+
   return result;
 }
 
@@ -450,6 +475,40 @@ ContentBrowserClientImpl::GetOriginsRequiringDedicatedProcess() {
   return site_isolation::GetBrowserSpecificBuiltInIsolatedOrigins();
 }
 
+bool ContentBrowserClientImpl::MayReuseHost(
+    content::RenderProcessHost* process_host) {
+  // If there is currently a prerender in progress for the host provided,
+  // it may not be shared. We require prerenders to be by themselves in a
+  // separate process so that we can monitor their resource usage.
+  prerender::PrerenderManager* prerender_manager =
+      PrerenderManagerFactory::GetForBrowserContext(
+          process_host->GetBrowserContext());
+  if (prerender_manager &&
+      !prerender_manager->MayReuseProcessHost(process_host)) {
+    return false;
+  }
+
+  return true;
+}
+
+void ContentBrowserClientImpl::OverridePageVisibilityState(
+    content::RenderFrameHost* render_frame_host,
+    content::PageVisibilityState* visibility_state) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  content::WebContents* web_contents =
+      content::WebContents::FromRenderFrameHost(render_frame_host);
+  DCHECK(web_contents);
+
+  prerender::PrerenderManager* prerender_manager =
+      PrerenderManagerFactory::GetForBrowserContext(
+          web_contents->GetBrowserContext());
+  if (prerender_manager &&
+      prerender_manager->IsWebContentsPrerendering(web_contents, nullptr)) {
+    *visibility_state = content::PageVisibilityState::kHiddenButPainting;
+  }
+}
+
 bool ContentBrowserClientImpl::ShouldDisableSiteIsolation() {
   return site_isolation::SiteIsolationPolicy::
       ShouldDisableSiteIsolationDueToMemoryThreshold();

weblayer/browser/content_browser_client_impl.h

@@ -64,6 +64,10 @@ class ContentBrowserClientImpl : public content::ContentBrowserClient {
       int frame_tree_node_id) override;
   bool IsHandledURL(const GURL& url) override;
   std::vector<url::Origin> GetOriginsRequiringDedicatedProcess() override;
+  bool MayReuseHost(content::RenderProcessHost* process_host) override;
+  void OverridePageVisibilityState(
+      content::RenderFrameHost* render_frame_host,
+      content::PageVisibilityState* visibility_state) override;
   bool ShouldDisableSiteIsolation() override;
   std::vector<std::string> GetAdditionalSiteIsolationModes() override;
   void PersistIsolatedOrigin(content::BrowserContext* context,

weblayer/browser/no_state_prefetch/DEPS

-include_rules = [
-  "+components/prerender/browser",
-]

weblayer/browser/no_state_prefetch/no_state_prefetch_browsertest.cc

@@ -2,22 +2,78 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
+#include "base/run_loop.h"
+#include "base/test/metrics/histogram_tester.h"
+#include "base/threading/platform_thread.h"
+#include "components/prerender/browser/prerender_histograms.h"
 #include "components/prerender/browser/prerender_manager.h"
+#include "content/public/test/browser_test_utils.h"
+#include "content/public/test/url_loader_monitor.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/test/embedded_test_server/http_request.h"
+#include "net/test/embedded_test_server/http_response.h"
+#include "services/network/public/cpp/resource_request.h"
 #include "weblayer/browser/no_state_prefetch/prerender_link_manager_factory.h"
 #include "weblayer/browser/no_state_prefetch/prerender_manager_factory.h"
 #include "weblayer/browser/tab_impl.h"
 #include "weblayer/shell/browser/shell.h"
 #include "weblayer/test/weblayer_browser_test.h"
+#include "weblayer/test/weblayer_browser_test_utils.h"
 
 namespace weblayer {
 
 class NoStatePrefetchBrowserTest : public WebLayerBrowserTest {
+ public:
+  void SetUpOnMainThread() override {
+    prerendered_page_fetched_ = std::make_unique<base::RunLoop>();
+    script_resource_fetched_ = std::make_unique<base::RunLoop>();
+
+    https_server_ = std::make_unique<net::EmbeddedTestServer>(
+        net::EmbeddedTestServer::TYPE_HTTPS);
+    https_server_->RegisterRequestHandler(base::BindRepeating(
+        &NoStatePrefetchBrowserTest::HandleRequest, base::Unretained(this)));
+    https_server_->AddDefaultHandlers(
+        base::FilePath(FILE_PATH_LITERAL("weblayer/test/data")));
+    ASSERT_TRUE(https_server_->Start());
+  }
+
+  // Helper methods.
+  std::unique_ptr<net::test_server::HttpResponse> HandleRequest(
+      const net::test_server::HttpRequest& request) {
+    if (request.GetURL().path().find("prerendered_page") != std::string::npos) {
+      if (prerendered_page_fetched_)
+        prerendered_page_fetched_->Quit();
+    }
+    if (request.GetURL().path().find("prefetch.js") != std::string::npos) {
+      script_fetched_ = true;
+      auto iter = request.headers.find("Purpose");
+      purpose_header_value_ = iter->second;
+      if (script_resource_fetched_)
+        script_resource_fetched_->Quit();
+    }
+    if (request.GetURL().path().find("prefetch_meta.js") != std::string::npos) {
+      script_executed_ = true;
+    }
+
+    // The default handlers will take care of this request.
+    return nullptr;
+  }
+
  protected:
   content::BrowserContext* GetBrowserContext() {
     Tab* tab = shell()->tab();
     TabImpl* tab_impl = static_cast<TabImpl*>(tab);
     return tab_impl->web_contents()->GetBrowserContext();
   }
+
+  std::unique_ptr<base::RunLoop> prerendered_page_fetched_;
+  std::unique_ptr<base::RunLoop> script_resource_fetched_;
+  bool script_fetched_ = false;
+  bool script_executed_ = false;
+  std::string purpose_header_value_;
+  std::unique_ptr<net::EmbeddedTestServer> https_server_;
 };
 
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, CreatePrerenderManager) {
@@ -32,4 +88,42 @@ IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, CreatePrerenderLinkManager) {
   EXPECT_TRUE(prerender_link_manager);
 }
 
+// Test that adding a link-rel prerender tag causes a fetch.
+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest,
+                       LinkRelPrerenderPageFetched) {
+  NavigateAndWaitForCompletion(GURL(https_server_->GetURL("/parent_page.html")),
+                               shell());
+  prerendered_page_fetched_->Run();
+}
+
+// Test that only render blocking resources are loaded during NoStatePrefetch.
+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest,
+                       NSPLoadsRenderBlockingResource) {
+  NavigateAndWaitForCompletion(GURL(https_server_->GetURL("/parent_page.html")),
+                               shell());
+  script_resource_fetched_->Run();
+  EXPECT_EQ("prefetch", purpose_header_value_);
+  EXPECT_FALSE(script_executed_);
+}
+
+// Test that navigating to a no-state-prefetched page executes JS and reuses
+// prerendered resources.
+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, NavigateToPrerenderedPage) {
+  NavigateAndWaitForCompletion(GURL(https_server_->GetURL("/parent_page.html")),
+                               shell());
+  script_resource_fetched_->Run();
+
+  // Navigate to the prerendered page and wait for its title to change.
+  auto expected_title = base::ASCIIToUTF16("Prefetch Page");
+  content::TitleWatcher title_watcher(
+      static_cast<TabImpl*>(shell()->tab())->web_contents(), expected_title);
+  script_fetched_ = false;
+  NavigateAndWaitForCompletion(
+      GURL(https_server_->GetURL("/prerendered_page.html")), shell());
+  ASSERT_TRUE(expected_title == title_watcher.WaitAndGetTitle());
+
+  EXPECT_FALSE(script_fetched_);
+  EXPECT_TRUE(script_executed_);
+}
+
 }  // namespace weblayer
\ No newline at end of file

weblayer/browser/no_state_prefetch/prerender_utils.cc

+// Copyright 2020 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 "weblayer/browser/no_state_prefetch/prerender_utils.h"
+
+#include "components/prerender/browser/prerender_contents.h"
+#include "components/prerender/browser/prerender_manager.h"
+#include "content/public/browser/web_contents.h"
+#include "weblayer/browser/no_state_prefetch/prerender_manager_factory.h"
+
+namespace weblayer {
+prerender::PrerenderContents* PrerenderContentsFromWebContents(
+    content::WebContents* web_contents) {
+  if (!web_contents)
+    return nullptr;
+
+  prerender::PrerenderManager* prerender_manager =
+      PrerenderManagerFactory::GetForBrowserContext(
+          web_contents->GetBrowserContext());
+  if (!prerender_manager)
+    return nullptr;
+
+  return prerender_manager->GetPrerenderContents(web_contents);
+}
+
+}  // namespace weblayer

weblayer/browser/no_state_prefetch/prerender_utils.h

+// Copyright 2020 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 WEBLAYER_BROWSER_NO_STATE_PREFETCH_PRERENDER_UTILS_H_
+#define WEBLAYER_BROWSER_NO_STATE_PREFETCH_PRERENDER_UTILS_H_
+
+namespace content {
+class WebContents;
+}
+
+namespace prerender {
+class PrerenderContents;
+}
+
+namespace weblayer {
+
+prerender::PrerenderContents* PrerenderContentsFromWebContents(
+    content::WebContents* web_contents);
+
+}  // namespace weblayer
+
+#endif  // WEBLAYER_BROWSER_NO_STATE_PREFETCH_PRERENDER_UTILS_H_

weblayer/browser/profile_impl.cc

@@ -18,6 +18,7 @@
 #include "base/task/thread_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/prefs/pref_service.h"
 #include "components/web_cache/browser/web_cache_manager.h"
 #include "content/public/browser/browser_task_traits.h"
@@ -219,8 +220,12 @@ ProfileImpl::ProfileImpl(const std::string& name)
 }
 
 ProfileImpl::~ProfileImpl() {
-  if (browser_context_)
+  if (browser_context_) {
+    BrowserContextDependencyManager::GetInstance()
+        ->DestroyBrowserContextServices(browser_context_.get());
     browser_context_->ShutdownStoragePartitions();
+  }
+
   GetProfiles().erase(this);
   for (auto& observer : GetObservers())
     observer.ProfileDestroyed(this);

weblayer/browser/safe_browsing/url_checker_delegate_impl.cc

@@ -5,14 +5,31 @@
 #include "weblayer/browser/safe_browsing/url_checker_delegate_impl.h"
 
 #include "base/bind.h"
+#include "components/prerender/browser/prerender_manager.h"
 #include "components/safe_browsing/core/db/database_manager.h"
 #include "components/security_interstitials/core/unsafe_resource.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
+#include "weblayer/browser/no_state_prefetch/prerender_manager_factory.h"
+#include "weblayer/browser/no_state_prefetch/prerender_utils.h"
 #include "weblayer/browser/safe_browsing/safe_browsing_ui_manager.h"
 
 namespace weblayer {
 
+namespace {
+
+// Destroys the prerender contents associated with the web_contents, if any.
+void DestroyPrerenderContents(
+    content::WebContents::OnceGetter web_contents_getter) {
+  content::WebContents* web_contents = std::move(web_contents_getter).Run();
+
+  auto* prerender_contents = PrerenderContentsFromWebContents(web_contents);
+  if (prerender_contents)
+    prerender_contents->Destroy(prerender::FINAL_STATUS_SAFE_BROWSING);
+}
+
+}  // namespace
+
 UrlCheckerDelegateImpl::UrlCheckerDelegateImpl(
     scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager,
     scoped_refptr<SafeBrowsingUIManager> ui_manager)
@@ -27,7 +44,12 @@ UrlCheckerDelegateImpl::UrlCheckerDelegateImpl(
 UrlCheckerDelegateImpl::~UrlCheckerDelegateImpl() = default;
 
 void UrlCheckerDelegateImpl::MaybeDestroyPrerenderContents(
-    content::WebContents::OnceGetter web_contents_getter) {}
+    content::WebContents::OnceGetter web_contents_getter) {
+  // Destroy the prefetch with FINAL_STATUS_SAFEBROSWING.
+  content::GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(&DestroyPrerenderContents,
+                                std::move(web_contents_getter)));
+}
 
 void UrlCheckerDelegateImpl::StartDisplayingBlockingPageHelper(
     const security_interstitials::UnsafeResource& resource,

weblayer/browser/weblayer_browser_interface_binders.cc

@@ -6,6 +6,9 @@
 
 #include "base/bind.h"
 #include "build/build_config.h"
+#include "components/prerender/browser/prerender_contents.h"
+#include "components/prerender/browser/prerender_processor_impl.h"
+#include "components/prerender/common/prerender_canceler.mojom.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
@@ -13,6 +16,9 @@
 #include "content/public/browser/web_ui_controller.h"
 #include "third_party/blink/public/mojom/installedapp/installed_app_provider.mojom.h"
 #include "third_party/blink/public/mojom/installedapp/related_application.mojom.h"
+#include "third_party/blink/public/mojom/prerender/prerender.mojom.h"
+#include "weblayer/browser/no_state_prefetch/prerender_processor_impl_delegate_impl.h"
+#include "weblayer/browser/no_state_prefetch/prerender_utils.h"
 #include "weblayer/browser/translate_client_impl.h"
 #include "weblayer/browser/webui/weblayer_internals.mojom.h"
 #include "weblayer/browser/webui/weblayer_internals_ui.h"
@@ -65,6 +71,27 @@ void BindPageHandler(
   concrete_controller->BindInterface(std::move(receiver));
 }
 
+void BindPrerenderProcessor(
+    content::RenderFrameHost* frame_host,
+    mojo::PendingReceiver<blink::mojom::PrerenderProcessor> receiver) {
+  prerender::PrerenderProcessorImpl::Create(
+      frame_host, std::move(receiver),
+      std::make_unique<PrerenderProcessorImplDelegateImpl>());
+}
+
+void BindPrerenderCanceler(
+    content::RenderFrameHost* frame_host,
+    mojo::PendingReceiver<prerender::mojom::PrerenderCanceler> receiver) {
+  auto* web_contents = content::WebContents::FromRenderFrameHost(frame_host);
+  if (!web_contents)
+    return;
+
+  auto* prerender_contents = PrerenderContentsFromWebContents(web_contents);
+  if (!prerender_contents)
+    return;
+  prerender_contents->AddPrerenderCancelerReceiver(std::move(receiver));
+}
+
 #if defined(OS_ANDROID)
 // TODO(https://crbug.com/1037884): Remove this.
 class StubInstalledAppProvider : public blink::mojom::InstalledAppProvider {
@@ -109,6 +136,11 @@ void PopulateWebLayerFrameBinders(
   map->Add<translate::mojom::ContentTranslateDriver>(
       base::BindRepeating(&BindContentTranslateDriver));
 
+  map->Add<blink::mojom::PrerenderProcessor>(
+      base::BindRepeating(&BindPrerenderProcessor));
+  map->Add<prerender::mojom::PrerenderCanceler>(
+      base::BindRepeating(&BindPrerenderCanceler));
+
 #if defined(OS_ANDROID)
   // TODO(https://crbug.com/1037884): Remove this.
   map->Add<blink::mojom::InstalledAppProvider>(

weblayer/renderer/DEPS

@@ -6,6 +6,8 @@ include_rules = [
   "+components/error_page/common",
   "+components/grit",
   "+components/page_load_metrics/renderer",
+  "+components/prerender/common",
+  "+components/prerender/renderer",
   "+components/safe_browsing/content/common",
   "+components/safe_browsing/content/renderer",
   "+components/safe_browsing/core/common",

weblayer/renderer/content_renderer_client_impl.cc

@@ -13,11 +13,19 @@
 #include "components/grit/components_scaled_resources.h"
 #include "components/js_injection/renderer/js_communication.h"
 #include "components/page_load_metrics/renderer/metrics_render_frame_observer.h"
+#include "components/prerender/common/prerender_types.mojom.h"
+#include "components/prerender/common/prerender_url_loader_throttle.h"
+#include "components/prerender/renderer/prerender_helper.h"
+#include "components/prerender/renderer/prerender_render_frame_observer.h"
+#include "components/prerender/renderer/prerenderer_client.h"
+#include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
+#include "content/public/renderer/render_view.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "weblayer/common/features.h"
 #include "weblayer/renderer/error_page_helper.h"
+#include "weblayer/renderer/url_loader_throttle_provider.h"
 #include "weblayer/renderer/weblayer_render_frame_observer.h"
 #include "weblayer/renderer/weblayer_render_thread_observer.h"
 
@@ -29,7 +37,6 @@
 #include "content/public/renderer/render_thread.h"
 #include "services/service_manager/public/cpp/local_interface_provider.h"
 #include "third_party/blink/public/platform/web_runtime_features.h"
-#include "weblayer/renderer/url_loader_throttle_provider.h"
 #endif
 
 namespace weblayer {
@@ -82,6 +89,7 @@ void ContentRendererClientImpl::RenderThreadStarted() {
 void ContentRendererClientImpl::RenderFrameCreated(
     content::RenderFrame* render_frame) {
   auto* render_frame_observer = new WebLayerRenderFrameObserver(render_frame);
+  new prerender::PrerenderRenderFrameObserver(render_frame);
 
   ErrorPageHelper::Create(render_frame);
 
@@ -106,6 +114,23 @@ void ContentRendererClientImpl::RenderFrameCreated(
                          local_interface_provider_.get());
 #endif
   new js_injection::JsCommunication(render_frame);
+
+  if (!render_frame->IsMainFrame()) {
+    auto* prerender_helper = prerender::PrerenderHelper::Get(
+        render_frame->GetRenderView()->GetMainRenderFrame());
+    if (prerender_helper) {
+      // Avoid any race conditions from having the browser tell subframes that
+      // they're prerendering.
+      new prerender::PrerenderHelper(render_frame,
+                                     prerender_helper->prerender_mode(),
+                                     prerender_helper->histogram_prefix());
+    }
+  }
+}
+
+void ContentRendererClientImpl::RenderViewCreated(
+    content::RenderView* render_view) {
+  new prerender::PrerendererClient(render_view);
 }
 
 SkBitmap* ContentRendererClientImpl::GetSadPluginBitmap() {
@@ -143,17 +168,8 @@ void ContentRendererClientImpl::PrepareErrorPage(
 std::unique_ptr<content::URLLoaderThrottleProvider>
 ContentRendererClientImpl::CreateURLLoaderThrottleProvider(
     content::URLLoaderThrottleProviderType provider_type) {
-  if (base::FeatureList::IsEnabled(features::kWebLayerSafeBrowsing)) {
-#if defined(OS_ANDROID)
-    // Note: currently the throttle provider is only needed for safebrowsing.
-    return std::make_unique<URLLoaderThrottleProvider>(
-        browser_interface_broker_.get(), provider_type);
-#else
-    return nullptr;
-#endif
-  }
-
-  return nullptr;
+  return std::make_unique<URLLoaderThrottleProvider>(
+      browser_interface_broker_.get(), provider_type);
 }
 
 void ContentRendererClientImpl::AddSupportedKeySystems(
@@ -173,4 +189,11 @@ void ContentRendererClientImpl::
 #endif
 }
 
+bool ContentRendererClientImpl::IsPrefetchOnly(
+    content::RenderFrame* render_frame,
+    const blink::WebURLRequest& request) {
+  return prerender::PrerenderHelper::GetPrerenderMode(render_frame) ==
+         prerender::mojom::PrerenderMode::kPrefetchOnly;
+}
+
 }  // namespace weblayer

weblayer/renderer/content_renderer_client_impl.h

@@ -27,6 +27,7 @@ class ContentRendererClientImpl : public content::ContentRendererClient {
   // content::ContentRendererClient:
   void RenderThreadStarted() override;
   void RenderFrameCreated(content::RenderFrame* render_frame) override;
+  void RenderViewCreated(content::RenderView* render_view) override;
   SkBitmap* GetSadPluginBitmap() override;
   SkBitmap* GetSadWebViewBitmap() override;
   bool HasErrorPage(int http_status_code) override;
@@ -41,6 +42,8 @@ class ContentRendererClientImpl : public content::ContentRendererClient {
       std::vector<std::unique_ptr<::media::KeySystemProperties>>* key_systems)
       override;
   void SetRuntimeFeaturesDefaultsBeforeBlinkInitialization() override;
+  bool IsPrefetchOnly(content::RenderFrame* render_frame,
+                      const blink::WebURLRequest& request) override;
 
  private:
 #if defined(OS_ANDROID)

weblayer/renderer/url_loader_throttle_provider.cc

@@ -7,6 +7,7 @@
 #include <memory>
 
 #include "base/memory/ptr_util.h"
+#include "components/prerender/renderer/prerender_helper.h"
 #include "components/safe_browsing/content/renderer/renderer_url_loader_throttle.h"
 #include "content/public/renderer/render_thread.h"
 #include "third_party/blink/public/common/loader/resource_type_util.h"
@@ -65,6 +66,14 @@ URLLoaderThrottleProvider::CreateThrottles(
             safe_browsing_.get(), render_frame_id));
   }
 
+  if (type_ == content::URLLoaderThrottleProviderType::kFrame &&
+      !is_frame_resource) {
+    auto throttle =
+        prerender::PrerenderHelper::MaybeCreateThrottle(render_frame_id);
+    if (throttle)
+      throttles.push_back(std::move(throttle));
+  }
+
   return throttles;
 }
 

weblayer/renderer/weblayer_render_frame_observer.cc

@@ -8,6 +8,7 @@
 
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
+#include "components/prerender/renderer/prerender_helper.h"
 #include "components/translate/content/renderer/translate_agent.h"
 #include "components/translate/core/common/translate_util.h"
 #include "third_party/blink/public/web/web_document_loader.h"
@@ -107,6 +108,10 @@ void WebLayerRenderFrameObserver::CapturePageText() {
   if (!translate_agent_)
     return;
 
+  // Don't index/capture pages that are being prerendered.
+  if (prerender::PrerenderHelper::IsPrerendering(render_frame()))
+    return;
+
   base::TimeTicks capture_begin_time = base::TimeTicks::Now();
 
   // Retrieve the frame's full text (up to kMaxIndexChars), and pass it to the

weblayer/test/data/parent_page.html

+<html>
+<head><title>Parent Page</title></head>
+<body>
+This page will prerender something.
+<link rel="prerender" href="/prerendered_page.html">
+</body>
+</html>

weblayer/test/data/prefetch.js

+// Copyright 2020 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.
+
+// This isn't used anywhere.
+var theScriptHasExecuted = true;

weblayer/test/data/prefetch_meta.js

+// Copyright 2020 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.
+
+// This isn't used anywhere.
+var theMetaScriptHasExecuted = true;

weblayer/test/data/prerendered_page.html

+<html>
+<!--
+A page that fetches only "prefetch.js" when scanned by NoStatePrefetch, and
+fetches "prefetch_meta.js" in addition to that if javascript execution happens
+on the page. In all cases the scripts are executed in a blocking manner.
+
+By prefetching this page, a browsertest can verify that javascript was not
+executed (prefetch_meta.js should not be requested to load even after the page
+has been fully prefetched (or loaded)).
+
+Note: there is no way to ensure that the script loaded via .appendChild() or a
+sync XHR happens before a preload-scannable request because preload scanner is
+racy and often fetches resources it sees before the inline script has a chance
+to execute.
+-->
+<body>
+  <script>
+    var s = document.createElement("script");
+    s.src = "prefetch_meta.js";
+    document.body.appendChild(s);
+  </script>
+
+  <!-- Ordering is imporant here because the test harness relies on sequential
+    parsing of this page. When a fetch request for prefetch.js happens, it can
+    be safely assumed that the browser has parsed the inline script above.  -->
+  <script src="prefetch.js"></script>
+
+  Some content that is necessary for registering paint metrics.
+</body>
+
+<head>
+  <!-- Ordering on the page is important. -->
+  <title>Prefetch Page</title>
+</head>
+</html>