[WebLayer] Add prerender delegate impls and PrerenderManagerFactory.

This adds PrerenderContentsDelegateImpl, PrerenderManagerDelegateImpl
and PrerenderManagerFactory.

A simple browsertest has been added to verify functionality.

Bug: 1096088
Change-Id: I8682eecc2deb10ac5da77d0892a7abf544aa839d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2339463Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Commit-Queue: Mugdha Lakhani <nator@chromium.org>
Cr-Commit-Position: refs/heads/master@{#796225}

components/prerender/browser/BUILD.gn

@@ -8,6 +8,7 @@ static_library("browser") {
     "prerender_config.h",
     "prerender_contents.cc",
     "prerender_contents.h",
+    "prerender_contents_delegate.cc",
     "prerender_contents_delegate.h",
     "prerender_field_trial.cc",
     "prerender_field_trial.h",
@@ -21,6 +22,7 @@ static_library("browser") {
     "prerender_link_manager.h",
     "prerender_manager.cc",
     "prerender_manager.h",
+    "prerender_manager_delegate.cc",
     "prerender_manager_delegate.h",
     "prerender_processor_impl.cc",
     "prerender_processor_impl.h",

components/prerender/browser/prerender_contents_delegate.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 "components/prerender/browser/prerender_contents_delegate.h"
+
+namespace prerender {
+
+PrerenderContentsDelegate::PrerenderContentsDelegate() = default;
+
+void PrerenderContentsDelegate::OnPrerenderContentsCreated(
+    content::WebContents* web_contents) {}
+
+void PrerenderContentsDelegate::ReleasePrerenderContents(
+    content::WebContents* web_contents) {}
+
+}  // namespace prerender
\ No newline at end of file

components/prerender/browser/prerender_contents_delegate.h

@@ -18,14 +18,14 @@ namespace prerender {
 // PrerenderContents logic.
 class PrerenderContentsDelegate {
  public:
+  PrerenderContentsDelegate();
   virtual ~PrerenderContentsDelegate() = default;
 
   // Handle creation of new PrerenderContents.
-  virtual void OnPrerenderContentsCreated(
-      content::WebContents* web_contents) = 0;
+  virtual void OnPrerenderContentsCreated(content::WebContents* web_contents);
 
   // Prepare for |web_contents| to no longer be PrerenderContents.
-  virtual void ReleasePrerenderContents(content::WebContents* web_contents) = 0;
+  virtual void ReleasePrerenderContents(content::WebContents* web_contents);
 };
 
 }  // namespace prerender

components/prerender/browser/prerender_manager_delegate.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 "components/prerender/browser/prerender_manager_delegate.h"
+
+namespace prerender {
+
+PrerenderManagerDelegate::PrerenderManagerDelegate() = default;
+
+void PrerenderManagerDelegate::MaybePreconnect(const GURL& url) {}
+
+bool PrerenderManagerDelegate::IsPredictionEnabled(Origin origin) {
+  return true;
+}
+
+bool PrerenderManagerDelegate::IsPredictionEnabled() {
+  return true;
+}
+
+bool PrerenderManagerDelegate::IsPredictionDisabledDueToNetwork(Origin origin) {
+  return false;
+}
+
+std::string PrerenderManagerDelegate::GetReasonForDisablingPrediction() {
+  return std::string();
+}
+
+}  // namespace prerender
\ No newline at end of file

components/prerender/browser/prerender_manager_delegate.h

@@ -20,6 +20,7 @@ namespace prerender {
 // PrerenderManager logic.
 class PrerenderManagerDelegate {
  public:
+  PrerenderManagerDelegate();
   virtual ~PrerenderManagerDelegate() = default;
 
   // Checks whether third party cookies should be blocked.
@@ -27,23 +28,23 @@ class PrerenderManagerDelegate {
   GetCookieSettings() = 0;
 
   // Perform preconnect, if feasible.
-  virtual void MaybePreconnect(const GURL& url) = 0;
+  virtual void MaybePreconnect(const GURL& url);
 
   // Get the prerender contents delegate.
   virtual std::unique_ptr<PrerenderContentsDelegate>
   GetPrerenderContentsDelegate() = 0;
 
   // Check whether predictive loading of web pages is enabled for |origin|.
-  virtual bool IsPredictionEnabled(Origin origin) = 0;
+  virtual bool IsPredictionEnabled(Origin origin);
 
   // Check whether predictive loading of web pages is enabled.
-  virtual bool IsPredictionEnabled() = 0;
+  virtual bool IsPredictionEnabled();
 
   // Check whether predictive loading of web pages is disabled due to network.
-  virtual bool IsPredictionDisabledDueToNetwork(Origin origin) = 0;
+  virtual bool IsPredictionDisabledDueToNetwork(Origin origin);
 
   // Gets the reason why predictive loading of web pages was disabld.
-  virtual std::string GetReasonForDisablingPrediction() = 0;
+  virtual std::string GetReasonForDisablingPrediction();
 };
 
 }  // namespace prerender

weblayer/BUILD.gn

@@ -204,6 +204,10 @@ source_set("weblayer_lib_base") {
     "browser/navigation_error_navigation_throttle.h",
     "browser/navigation_impl.cc",
     "browser/navigation_impl.h",
+    "browser/no_state_prefetch/prerender_manager_delegate_impl.cc",
+    "browser/no_state_prefetch/prerender_manager_delegate_impl.h",
+    "browser/no_state_prefetch/prerender_manager_factory.cc",
+    "browser/no_state_prefetch/prerender_manager_factory.h",
     "browser/page_load_metrics_initialize.cc",
     "browser/page_load_metrics_initialize.h",
     "browser/password_manager_driver_factory.cc",
@@ -378,6 +382,7 @@ source_set("weblayer_lib_base") {
     "//components/policy/core/browser",
     "//components/pref_registry:pref_registry",
     "//components/prefs",
+    "//components/prerender/browser",
     "//components/safe_browsing/core:features",
     "//components/security_interstitials/content:security_interstitial_page",
     "//components/security_interstitials/content/renderer:security_interstitial_page_controller",

weblayer/browser/no_state_prefetch/DEPS

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

weblayer/browser/no_state_prefetch/no_state_prefetch_browsertest.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 "components/prerender/browser/prerender_manager.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"
+
+namespace weblayer {
+
+class NoStatePrefetchBrowserTest : public WebLayerBrowserTest {
+ protected:
+  content::BrowserContext* GetBrowserContext() {
+    Tab* tab = shell()->tab();
+    TabImpl* tab_impl = static_cast<TabImpl*>(tab);
+    return tab_impl->web_contents()->GetBrowserContext();
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, CreatePrerenderManager) {
+  auto* prerender_manager =
+      PrerenderManagerFactory::GetForBrowserContext(GetBrowserContext());
+  EXPECT_TRUE(prerender_manager);
+}
+
+}  // namespace weblayer
\ No newline at end of file

weblayer/browser/no_state_prefetch/prerender_manager_delegate_impl.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_manager_delegate_impl.h"
+
+#include "components/prerender/browser/prerender_contents_delegate.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "weblayer/browser/cookie_settings_factory.h"
+
+namespace weblayer {
+
+PrerenderManagerDelegateImpl::PrerenderManagerDelegateImpl(
+    content::BrowserContext* browser_context)
+    : browser_context_(browser_context) {}
+
+scoped_refptr<content_settings::CookieSettings>
+PrerenderManagerDelegateImpl::GetCookieSettings() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  return CookieSettingsFactory::GetForBrowserContext(browser_context_);
+}
+
+std::unique_ptr<prerender::PrerenderContentsDelegate>
+PrerenderManagerDelegateImpl::GetPrerenderContentsDelegate() {
+  return std::make_unique<prerender::PrerenderContentsDelegate>();
+}
+
+}  // namespace weblayer

weblayer/browser/no_state_prefetch/prerender_manager_delegate_impl.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_MANAGER_DELEGATE_IMPL_H_
+#define WEBLAYER_BROWSER_NO_STATE_PREFETCH_PRERENDER_MANAGER_DELEGATE_IMPL_H_
+
+#include "components/content_settings/core/browser/cookie_settings.h"
+#include "components/prerender/browser/prerender_manager_delegate.h"
+
+namespace content {
+class BrowserContext;
+}
+
+namespace weblayer {
+
+class PrerenderManagerDelegateImpl
+    : public prerender::PrerenderManagerDelegate {
+ public:
+  explicit PrerenderManagerDelegateImpl(
+      content::BrowserContext* browser_context);
+  ~PrerenderManagerDelegateImpl() override = default;
+
+  // PrerenderManagerDelegate overrides.
+  scoped_refptr<content_settings::CookieSettings> GetCookieSettings() override;
+  std::unique_ptr<prerender::PrerenderContentsDelegate>
+  GetPrerenderContentsDelegate() override;
+
+ private:
+  content::BrowserContext* browser_context_;
+};
+
+}  // namespace weblayer
+
+#endif  // WEBLAYER_BROWSER_NO_STATE_PREFETCH_PRERENDER_MANAGER_DELEGATE_IMPL_H_

weblayer/browser/no_state_prefetch/prerender_manager_factory.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_manager_factory.h"
+
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "components/prerender/browser/prerender_manager.h"
+#include "weblayer/browser/no_state_prefetch/prerender_manager_delegate_impl.h"
+
+namespace weblayer {
+
+// static
+prerender::PrerenderManager* PrerenderManagerFactory::GetForBrowserContext(
+    content::BrowserContext* context) {
+  return static_cast<prerender::PrerenderManager*>(
+      GetInstance()->GetServiceForBrowserContext(context, true));
+}
+
+// static
+PrerenderManagerFactory* PrerenderManagerFactory::GetInstance() {
+  return base::Singleton<PrerenderManagerFactory>::get();
+}
+
+PrerenderManagerFactory::PrerenderManagerFactory()
+    : BrowserContextKeyedServiceFactory(
+          "PrerenderManager",
+          BrowserContextDependencyManager::GetInstance()) {}
+
+KeyedService* PrerenderManagerFactory::BuildServiceInstanceFor(
+    content::BrowserContext* browser_context) const {
+  return new prerender::PrerenderManager(
+      browser_context,
+      std::make_unique<PrerenderManagerDelegateImpl>(browser_context));
+}
+
+content::BrowserContext* PrerenderManagerFactory::GetBrowserContextToUse(
+    content::BrowserContext* context) const {
+  return context;
+}
+
+}  // namespace weblayer

weblayer/browser/no_state_prefetch/prerender_manager_factory.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_MANAGER_FACTORY_H_
+#define WEBLAYER_BROWSER_NO_STATE_PREFETCH_PRERENDER_MANAGER_FACTORY_H_
+
+#include "base/memory/singleton.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+namespace content {
+class BrowserContext;
+}
+
+namespace prerender {
+class PrerenderManager;
+}
+
+namespace weblayer {
+
+// Singleton that owns all PrerenderManagers and associates them with
+// BrowserContexts. Listens for the BrowserContext's destruction notification
+// and cleans up the associated PrerenderManager.
+class PrerenderManagerFactory : public BrowserContextKeyedServiceFactory {
+ public:
+  // Returns the PrerenderManager for |context|.
+  static prerender::PrerenderManager* GetForBrowserContext(
+      content::BrowserContext* context);
+
+  static PrerenderManagerFactory* GetInstance();
+
+ private:
+  friend struct base::DefaultSingletonTraits<PrerenderManagerFactory>;
+
+  PrerenderManagerFactory();
+  ~PrerenderManagerFactory() override = default;
+
+  // BrowserContextKeyedServiceFactory:
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* browser) const override;
+  content::BrowserContext* GetBrowserContextToUse(
+      content::BrowserContext* context) const override;
+};
+
+}  // namespace weblayer
+
+#endif  // WEBLAYER_BROWSER_NO_STATE_PREFETCH_PRERENDER_MANAGER_FACTORY_H_

weblayer/test/BUILD.gn

@@ -103,6 +103,7 @@ test("weblayer_browsertests") {
     "//components/network_time",
     "//components/page_load_metrics/browser:browser",
     "//components/prefs",
+    "//components/prerender/browser",
     "//components/security_interstitials/content:security_interstitial_page",
     "//components/sessions:test_support",
     "//components/signin/core/browser",
@@ -138,6 +139,7 @@ test("weblayer_browsertests") {
     "../browser/js_communication/web_message_browsertest.cc",
     "../browser/navigation_browsertest.cc",
     "../browser/navigation_error_navigation_throttle_browsertest.cc",
+    "../browser/no_state_prefetch/no_state_prefetch_browsertest.cc",
     "../browser/page_load_metrics_browsertest.cc",
     "../browser/popup_blocker_browsertest.cc",
     "../browser/prefetch_browsertest.cc",