BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

11 files changed, 344 insertions, 116 deletions

diff --git a/chromium/weblayer/browser/safe_browsing/BUILD.gn b/chromium/weblayer/browser/safe_browsing/BUILD.gn
deleted file mode 100644
index 001f036d3e8..00000000000
--- a/chromium/weblayer/browser/safe_browsing/BUILD.gn
+++ /dev/null
@@ -1,41 +0,0 @@
-# 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.
-
-import("//build/config/android/config.gni")
-
-assert(is_android)
-
-source_set("safe_browsing") {
-  sources = [
-    "safe_browsing_blocking_page.cc",
-    "safe_browsing_blocking_page.h",
-    "safe_browsing_navigation_throttle.cc",
-    "safe_browsing_navigation_throttle.h",
-    "safe_browsing_service.cc",
-    "safe_browsing_service.h",
-    "safe_browsing_subresource_helper.cc",
-    "safe_browsing_subresource_helper.h",
-    "safe_browsing_ui_manager.cc",
-    "safe_browsing_ui_manager.h",
-    "url_checker_delegate_impl.cc",
-    "url_checker_delegate_impl.h",
-  ]
-  deps = [
-    "//components/safe_browsing/android:remote_database_manager",
-    "//components/safe_browsing/android:safe_browsing_api_handler",
-    "//components/safe_browsing/content",
-    "//components/safe_browsing/content/browser",
-    "//components/safe_browsing/content/renderer:throttles",
-    "//components/safe_browsing/core/browser",
-    "//components/safe_browsing/core/browser:network_context",
-    "//components/safe_browsing/core/common",
-    "//components/safe_browsing/core/db:database_manager",
-    "//components/security_interstitials/content:security_interstitial_page",
-    "//components/security_interstitials/core:unsafe_resource",
-    "//components/security_interstitials/core/",
-    "//content/public/browser",
-    "//skia",
-    "//third_party/blink/public/common",
-  ]
-}
diff --git a/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.cc b/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.cc
new file mode 100644
index 00000000000..d3bee53a080
--- /dev/null
+++ b/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.cc
@@ -0,0 +1,60 @@
+// 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/safe_browsing/real_time_url_lookup_service_factory.h"
+
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "components/safe_browsing/core/common/utils.h"
+#include "components/safe_browsing/core/realtime/url_lookup_service.h"
+#include "content/public/browser/browser_context.h"
+#include "services/network/public/cpp/cross_thread_pending_shared_url_loader_factory.h"
+#include "weblayer/browser/browser_context_impl.h"
+#include "weblayer/browser/browser_process.h"
+#include "weblayer/browser/feature_list_creator.h"
+#include "weblayer/browser/safe_browsing/safe_browsing_service.h"
+#include "weblayer/browser/user_agent.h"
+#include "weblayer/browser/verdict_cache_manager_factory.h"
+
+namespace weblayer {
+
+// static
+safe_browsing::RealTimeUrlLookupService*
+RealTimeUrlLookupServiceFactory::GetForBrowserContext(
+    content::BrowserContext* browser_context) {
+  return static_cast<safe_browsing::RealTimeUrlLookupService*>(
+      GetInstance()->GetServiceForBrowserContext(browser_context,
+                                                 /* create= */ true));
+}
+
+// static
+RealTimeUrlLookupServiceFactory*
+RealTimeUrlLookupServiceFactory::GetInstance() {
+  return base::Singleton<RealTimeUrlLookupServiceFactory>::get();
+}
+
+RealTimeUrlLookupServiceFactory::RealTimeUrlLookupServiceFactory()
+    : BrowserContextKeyedServiceFactory(
+          "RealTimeUrlLookupService",
+          BrowserContextDependencyManager::GetInstance()) {}
+
+KeyedService* RealTimeUrlLookupServiceFactory::BuildServiceInstanceFor(
+    content::BrowserContext* context) const {
+  auto url_loader_factory =
+      std::make_unique<network::CrossThreadPendingSharedURLLoaderFactory>(
+          BrowserProcess::GetInstance()
+              ->GetSafeBrowsingService(weblayer::GetUserAgent())
+              ->GetURLLoaderFactory());
+
+  return new safe_browsing::RealTimeUrlLookupService(
+      network::SharedURLLoaderFactory::Create(std::move(url_loader_factory)),
+      VerdictCacheManagerFactory::GetForBrowserContext(context),
+      nullptr /* identity manager */, nullptr /* profile sync service */,
+      static_cast<BrowserContextImpl*>(context)->pref_service(),
+      safe_browsing::GetProfileManagementStatus(nullptr),
+      false /* is_under_advanced_protection */,
+      static_cast<BrowserContextImpl*>(context)->IsOffTheRecord(),
+      FeatureListCreator::GetInstance()->variations_service());
+}
+
+}  // namespace weblayer
diff --git a/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.h b/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.h
new file mode 100644
index 00000000000..1d9e6780a26
--- /dev/null
+++ b/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.h
@@ -0,0 +1,53 @@
+// 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_SAFE_BROWSING_REAL_TIME_URL_LOOKUP_SERVICE_FACTORY_H_
+#define WEBLAYER_BROWSER_SAFE_BROWSING_REAL_TIME_URL_LOOKUP_SERVICE_FACTORY_H_
+
+#include "base/memory/singleton.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+class KeyedService;
+
+namespace content {
+class BrowserContext;
+}
+
+namespace safe_browsing {
+class RealTimeUrlLookupService;
+}  // namespace safe_browsing
+
+namespace weblayer {
+
+// Singleton that owns RealTimeUrlLookupService objects and associates them
+// them with BrowserContextImpl instances.
+class RealTimeUrlLookupServiceFactory
+    : public BrowserContextKeyedServiceFactory {
+ public:
+  // Creates the service if it doesn't exist already for the given
+  // |browser_context|. If the service already exists, return its pointer.
+  static safe_browsing::RealTimeUrlLookupService* GetForBrowserContext(
+      content::BrowserContext* browser_context);
+
+  // Get the singleton instance.
+  static RealTimeUrlLookupServiceFactory* GetInstance();
+
+ private:
+  friend struct base::DefaultSingletonTraits<RealTimeUrlLookupServiceFactory>;
+
+  RealTimeUrlLookupServiceFactory();
+  ~RealTimeUrlLookupServiceFactory() override = default;
+  RealTimeUrlLookupServiceFactory(const RealTimeUrlLookupServiceFactory&) =
+      delete;
+  RealTimeUrlLookupServiceFactory& operator=(
+      const RealTimeUrlLookupServiceFactory&) = delete;
+
+  // BrowserContextKeyedServiceFactory:
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* context) const override;
+};
+
+}  // namespace weblayer
+
+#endif  // WEBLAYER_BROWSER_SAFE_BROWSING_REAL_TIME_URL_LOOKUP_SERVICE_FACTORY_H_
diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_blocking_page.cc b/chromium/weblayer/browser/safe_browsing/safe_browsing_blocking_page.cc
index 34cf6cb561d..fd6c603a40f 100644
--- a/chromium/weblayer/browser/safe_browsing/safe_browsing_blocking_page.cc
+++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_blocking_page.cc
@@ -6,7 +6,9 @@
 
 #include "components/security_interstitials/content/security_interstitial_controller_client.h"
 #include "components/security_interstitials/content/unsafe_resource_util.h"
+#include "components/security_interstitials/core/base_safe_browsing_error_ui.h"
 #include "content/public/browser/navigation_entry.h"
+#include "weblayer/browser/browser_context_impl.h"
 #include "weblayer/browser/safe_browsing/safe_browsing_ui_manager.h"
 
 namespace weblayer {
@@ -43,11 +45,23 @@ SafeBrowsingBlockingPage* SafeBrowsingBlockingPage::CreateBlockingPage(
   GURL url =
       (main_frame_url.is_empty() && entry) ? entry->GetURL() : main_frame_url;
 
+  BrowserContextImpl* browser_context =
+      static_cast<BrowserContextImpl*>(web_contents->GetBrowserContext());
+  security_interstitials::BaseSafeBrowsingErrorUI::SBErrorDisplayOptions
+      display_options =
+          BaseBlockingPage::CreateDefaultDisplayOptions(unsafe_resources);
+  display_options.is_extended_reporting_opt_in_allowed =
+      safe_browsing::IsExtendedReportingOptInAllowed(
+          *(browser_context->pref_service()));
+  display_options.is_extended_reporting_enabled =
+      safe_browsing::IsExtendedReportingEnabled(
+          *(browser_context->pref_service()));
+
   return new SafeBrowsingBlockingPage(
       ui_manager, web_contents, url, unsafe_resources,
       CreateControllerClient(web_contents, unsafe_resources, ui_manager,
-                             nullptr /*pref_service*/),
-      BaseBlockingPage::CreateDefaultDisplayOptions(unsafe_resources));
+                             browser_context->pref_service()),
+      display_options);
 }
 
 security_interstitials::SecurityInterstitialPage::TypeID
diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_browsertest.cc b/chromium/weblayer/browser/safe_browsing/safe_browsing_browsertest.cc
index 51bd76179c4..77975384186 100644
--- a/chromium/weblayer/browser/safe_browsing/safe_browsing_browsertest.cc
+++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_browsertest.cc
@@ -4,21 +4,28 @@
 
 #include <map>
 
-#include "base/task/post_task.h"
+#include "components/prefs/pref_service.h"
 #include "components/safe_browsing/android/safe_browsing_api_handler.h"
 #include "components/safe_browsing/content/base_blocking_page.h"
 #include "components/safe_browsing/core/db/v4_protocol_manager_util.h"
 #include "components/security_interstitials/content/security_interstitial_page.h"
 #include "components/security_interstitials/content/security_interstitial_tab_helper.h"
+#include "components/user_prefs/user_prefs.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_utils.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "weblayer/browser/browser_context_impl.h"
+#include "weblayer/browser/browser_impl.h"
+#include "weblayer/browser/profile_impl.h"
 #include "weblayer/browser/safe_browsing/safe_browsing_blocking_page.h"
 #include "weblayer/browser/tab_impl.h"
 #include "weblayer/public/navigation.h"
 #include "weblayer/public/navigation_controller.h"
+#include "weblayer/public/profile.h"
 #include "weblayer/public/tab.h"
 #include "weblayer/shell/browser/shell.h"
 #include "weblayer/test/load_completion_observer.h"
@@ -34,8 +41,8 @@ void RunCallbackOnIOThread(
         callback,
     safe_browsing::SBThreatType threat_type,
     const safe_browsing::ThreatMetadata& metadata) {
-  base::PostTask(FROM_HERE, {content::BrowserThread::IO},
-                 base::BindOnce(std::move(*callback), threat_type, metadata));
+  content::GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(std::move(*callback), threat_type, metadata));
 }
 
 }  // namespace
@@ -79,14 +86,29 @@ class SafeBrowsingBrowserTest : public WebLayerBrowserTest {
   SafeBrowsingBrowserTest() : fake_handler_(new FakeSafeBrowsingApiHandler()) {}
   ~SafeBrowsingBrowserTest() override = default;
 
-  // WebLayerBrowserTest:
   void SetUpOnMainThread() override {
+    InitializeOnMainThread();
+    // Safe Browsing is enabled by default
+    ASSERT_TRUE(GetSafeBrowsingEnabled());
+  }
+
+  void InitializeOnMainThread() {
     NavigateAndWaitForCompletion(GURL("about:blank"), shell());
     safe_browsing::SafeBrowsingApiHandler::SetInstance(fake_handler_.get());
     ASSERT_TRUE(embedded_test_server()->Start());
     url_ = embedded_test_server()->GetURL("/simple_page.html");
   }
 
+  void SetSafeBrowsingEnabled(bool value) {
+    GetProfile()->SetBooleanSetting(SettingType::BASIC_SAFE_BROWSING_ENABLED,
+                                    value);
+  }
+
+  bool GetSafeBrowsingEnabled() {
+    return GetProfile()->GetBooleanSetting(
+        SettingType::BASIC_SAFE_BROWSING_ENABLED);
+  }
+
   void NavigateWithThreatType(const safe_browsing::SBThreatType& threatType,
                               bool expect_interstitial) {
     fake_handler_->AddRestriction(url_, threatType);
@@ -106,6 +128,16 @@ class SafeBrowsingBrowserTest : public WebLayerBrowserTest {
     }
   }
 
+  void NavigateWithSubResourceAndThreatType(
+      const safe_browsing::SBThreatType& threat_type,
+      bool expect_interstitial) {
+    GURL page_with_script_url =
+        embedded_test_server()->GetURL("/simple_page_with_script.html");
+    GURL script_url = embedded_test_server()->GetURL("/script.js");
+    fake_handler_->AddRestriction(script_url, threat_type);
+    Navigate(page_with_script_url, expect_interstitial);
+  }
+
  protected:
   content::WebContents* GetWebContents() {
     Tab* tab = shell()->tab();
@@ -126,6 +158,19 @@ class SafeBrowsingBrowserTest : public WebLayerBrowserTest {
 
   bool HasInterstitial() { return GetSecurityInterstitialPage() != nullptr; }
 
+  void KillRenderer() {
+    content::RenderProcessHost* child_process =
+        static_cast<TabImpl*>(shell()->tab())
+            ->web_contents()
+            ->GetMainFrame()
+            ->GetProcess();
+    content::RenderProcessHostWatcher crash_observer(
+        child_process,
+        content::RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT);
+    child_process->Shutdown(0);
+    crash_observer.Wait();
+  }
+
   std::unique_ptr<FakeSafeBrowsingApiHandler> fake_handler_;
   GURL url_;
 
@@ -133,6 +178,21 @@ class SafeBrowsingBrowserTest : public WebLayerBrowserTest {
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingBrowserTest);
 };
 
+class SafeBrowsingDisabledBrowserTest : public SafeBrowsingBrowserTest {
+ public:
+  SafeBrowsingDisabledBrowserTest() {}
+  ~SafeBrowsingDisabledBrowserTest() override = default;
+
+  void SetUpOnMainThread() override {
+    SetSafeBrowsingEnabled(false);
+    SafeBrowsingBrowserTest::InitializeOnMainThread();
+    ASSERT_FALSE(GetSafeBrowsingEnabled());
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDisabledBrowserTest);
+};
+
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest,
                        DoesNotShowInterstitial_NoRestriction) {
   Navigate(url_, false);
@@ -160,12 +220,70 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest, ShowsInterstitial_Billing) {
 
 IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest,
                        ShowsInterstitial_Malware_Subresource) {
-  GURL page_with_script_url =
-      embedded_test_server()->GetURL("/simple_page_with_script.html");
-  GURL script_url = embedded_test_server()->GetURL("/script.js");
-  fake_handler_->AddRestriction(script_url,
-                                safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
-  Navigate(page_with_script_url, true);
+  NavigateWithSubResourceAndThreatType(
+      safe_browsing::SB_THREAT_TYPE_URL_MALWARE, true);
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest,
+                       DoesNotShowInterstitial_Phishing_disableSB) {
+  // Test that the browser checks the safe browsing setting for new navigations.
+  SetSafeBrowsingEnabled(false);
+  NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_URL_PHISHING, false);
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest,
+                       DoesNotShowInterstitial_Malware_Subresource_disableSB) {
+  // Test that new renderer checks the safe browsing setting.
+  SetSafeBrowsingEnabled(false);
+  KillRenderer();
+  NavigateWithSubResourceAndThreatType(
+      safe_browsing::SB_THREAT_TYPE_URL_MALWARE, false);
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest, CheckSetsPrefs) {
+  // Check that changing safe browsing setting sets corresponding pref,
+  // which is persistent.
+  PrefService* prefs = GetProfile()->GetBrowserContext()->pref_service();
+  SetSafeBrowsingEnabled(true);
+  EXPECT_TRUE(prefs->GetBoolean(::prefs::kSafeBrowsingEnabled));
+  SetSafeBrowsingEnabled(false);
+  EXPECT_FALSE(prefs->GetBoolean(::prefs::kSafeBrowsingEnabled));
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest,
+                       DoesNotShowInterstitial_NoRestriction) {
+  Navigate(url_, false);
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest,
+                       DoesNotShowInterstitial_Safe) {
+  NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_SAFE, false);
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest,
+                       DoesNotShowInterstitial_Malware) {
+  NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_URL_MALWARE, false);
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest,
+                       DoesNotShowInterstitial_Phishing) {
+  NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_URL_PHISHING, false);
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest,
+                       DoesNotShowInterstitial_Unwanted) {
+  NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_URL_UNWANTED, false);
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest,
+                       DoesNotShowInterstitial_Billing) {
+  NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_BILLING, false);
+}
+
+IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest,
+                       DoesNotShowInterstitial_Malware_Subresource) {
+  NavigateWithSubResourceAndThreatType(
+      safe_browsing::SB_THREAT_TYPE_URL_MALWARE, false);
 }
 
-}  // namespace weblayer
+}  // namespace weblayer
\ No newline at end of file
diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_service.cc b/chromium/weblayer/browser/safe_browsing/safe_browsing_service.cc
index 915e9a26f89..fca167feed4 100644
--- a/chromium/weblayer/browser/safe_browsing/safe_browsing_service.cc
+++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_service.cc
@@ -6,19 +6,24 @@
 
 #include "base/bind.h"
 #include "base/path_service.h"
-#include "base/task/post_task.h"
+#include "components/prefs/pref_service.h"
 #include "components/safe_browsing/android/remote_database_manager.h"
 #include "components/safe_browsing/android/safe_browsing_api_handler_bridge.h"
 #include "components/safe_browsing/content/browser/browser_url_loader_throttle.h"
 #include "components/safe_browsing/content/browser/mojo_safe_browsing_impl.h"
 #include "components/safe_browsing/core/browser/safe_browsing_network_context.h"
+#include "components/safe_browsing/core/common/safe_browsing_prefs.h"
+#include "components/safe_browsing/core/realtime/url_lookup_service.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/network_service_instance.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_context.h"
+#include "services/network/public/mojom/network_context.mojom.h"
 #include "services/network/public/mojom/network_service.mojom.h"
 #include "third_party/blink/public/common/loader/url_loader_throttle.h"
+#include "weblayer/browser/browser_context_impl.h"
 #include "weblayer/browser/safe_browsing/safe_browsing_navigation_throttle.h"
 #include "weblayer/browser/safe_browsing/url_checker_delegate_impl.h"
 
@@ -30,12 +35,15 @@ network::mojom::NetworkContextParamsPtr CreateDefaultNetworkContextParams(
     const std::string& user_agent) {
   network::mojom::NetworkContextParamsPtr network_context_params =
       network::mojom::NetworkContextParams::New();
+  network_context_params->cert_verifier_params = content::GetCertVerifierParams(
+      network::mojom::CertVerifierCreationParams::New());
   network_context_params->user_agent = user_agent;
   return network_context_params;
 }
 
-// Helper method that checks the RenderProcessHost is still alive before hopping
-// over to the IO thread.
+// Helper method that checks the RenderProcessHost is still alive and checks the
+// latest Safe Browsing pref value on the UI thread before hopping over to the
+// IO thread.
 void MaybeCreateSafeBrowsing(
     int rph_id,
     content::ResourceContext* resource_context,
@@ -49,8 +57,16 @@ void MaybeCreateSafeBrowsing(
   if (!render_process_host)
     return;
 
-  base::PostTask(
-      FROM_HERE, {content::BrowserThread::IO},
+  bool is_safe_browsing_enabled = safe_browsing::IsSafeBrowsingEnabled(
+      *static_cast<BrowserContextImpl*>(
+           render_process_host->GetBrowserContext())
+           ->pref_service());
+
+  if (!is_safe_browsing_enabled)
+    return;
+
+  content::GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(&safe_browsing::MojoSafeBrowsingImpl::MaybeCreate, rph_id,
                      resource_context, std::move(get_checker_delegate),
                      std::move(receiver)));
@@ -59,7 +75,7 @@ void MaybeCreateSafeBrowsing(
 }  // namespace
 
 SafeBrowsingService::SafeBrowsingService(const std::string& user_agent)
-    : user_agent_(user_agent), safe_browsing_disabled_(false) {}
+    : user_agent_(user_agent) {}
 
 SafeBrowsingService::~SafeBrowsingService() = default;
 
@@ -93,7 +109,8 @@ void SafeBrowsingService::Initialize() {
 std::unique_ptr<blink::URLLoaderThrottle>
 SafeBrowsingService::CreateURLLoaderThrottle(
     const base::RepeatingCallback<content::WebContents*()>& wc_getter,
-    int frame_tree_node_id) {
+    int frame_tree_node_id,
+    safe_browsing::RealTimeUrlLookupServiceBase* url_lookup_service) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   return safe_browsing::BrowserURLLoaderThrottle::Create(
@@ -103,10 +120,7 @@ SafeBrowsingService::CreateURLLoaderThrottle(
           },
           base::Unretained(this)),
       wc_getter, frame_tree_node_id,
-      // rt_lookup_service are used to
-      // perform real time url check, which is gated by UKM opted in. Since
-      // WebLayer currently doesn't support UKM, this feature is not enabled.
-      /*rt_lookup_service*/ nullptr);
+      url_lookup_service ? url_lookup_service->GetWeakPtr() : nullptr);
 }
 
 std::unique_ptr<content::NavigationThrottle>
@@ -122,8 +136,7 @@ SafeBrowsingService::GetSafeBrowsingUrlCheckerDelegate() {
 
   if (!safe_browsing_url_checker_delegate_) {
     safe_browsing_url_checker_delegate_ = new UrlCheckerDelegateImpl(
-        GetSafeBrowsingDBManager(), GetSafeBrowsingUIManager(),
-        safe_browsing_disabled_);
+        GetSafeBrowsingDBManager(), GetSafeBrowsingUIManager());
   }
 
   return safe_browsing_url_checker_delegate_;
@@ -143,7 +156,7 @@ SafeBrowsingUIManager* SafeBrowsingService::GetSafeBrowsingUIManager() {
 
 void SafeBrowsingService::CreateSafeBrowsingUIManager() {
   DCHECK(!ui_manager_);
-  ui_manager_ = new SafeBrowsingUIManager();
+  ui_manager_ = new SafeBrowsingUIManager(this);
 }
 
 void SafeBrowsingService::CreateAndStartSafeBrowsingDBManager() {
@@ -163,8 +176,8 @@ scoped_refptr<network::SharedURLLoaderFactory>
 SafeBrowsingService::GetURLLoaderFactoryOnIOThread() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (!shared_url_loader_factory_on_io_) {
-    base::PostTask(
-        FROM_HERE, {content::BrowserThread::UI},
+    content::GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE,
         base::BindOnce(&SafeBrowsingService::CreateURLLoaderFactoryForIO,
                        base::Unretained(this),
                        url_loader_factory_on_io_.BindNewPipeAndPassReceiver()));
@@ -198,12 +211,12 @@ void SafeBrowsingService::AddInterface(
           base::BindRepeating(
               &SafeBrowsingService::GetSafeBrowsingUrlCheckerDelegate,
               base::Unretained(this))),
-      base::CreateSingleThreadTaskRunner({content::BrowserThread::UI}));
+      content::GetUIThreadTaskRunner({}));
 }
 
 void SafeBrowsingService::StopDBManager() {
-  base::PostTask(FROM_HERE, {content::BrowserThread::IO},
-                 base::BindOnce(&SafeBrowsingService::StopDBManagerOnIOThread,
+  content::GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(&SafeBrowsingService::StopDBManagerOnIOThread,
                                 base::Unretained(this)));
 }
 
@@ -215,24 +228,11 @@ void SafeBrowsingService::StopDBManagerOnIOThread() {
   }
 }
 
-void SafeBrowsingService::SetSafeBrowsingDisabled(bool disabled) {
-  content::GetIOThreadTaskRunner({})->PostTask(
-      FROM_HERE,
-      base::BindOnce(&SafeBrowsingService::SetSafeBrowsingDisabledOnIOThread,
-                     base::Unretained(this), disabled));
-}
-
-void SafeBrowsingService::SetSafeBrowsingDisabledOnIOThread(bool disabled) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-
-  if (safe_browsing_disabled_ != disabled) {
-    safe_browsing_disabled_ = disabled;
-    // If there is no safe_browsing_url_checker_delegate_ yet the opt_out
-    // setting will be set later during its creation.
-    if (safe_browsing_url_checker_delegate_) {
-      safe_browsing_url_checker_delegate_->SetSafeBrowsingDisabled(disabled);
-    }
-  }
+scoped_refptr<network::SharedURLLoaderFactory>
+SafeBrowsingService::GetURLLoaderFactory() {
+  if (!network_context_)
+    return nullptr;
+  return network_context_->GetURLLoaderFactory();
 }
 
 }  // namespace weblayer
diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_service.h b/chromium/weblayer/browser/safe_browsing/safe_browsing_service.h
index 3f5506031d5..1de5c0ff021 100644
--- a/chromium/weblayer/browser/safe_browsing/safe_browsing_service.h
+++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_service.h
@@ -29,6 +29,7 @@ class SharedURLLoaderFactory;
 
 namespace safe_browsing {
 class UrlCheckerDelegate;
+class RealTimeUrlLookupServiceBase;
 class RemoteSafeBrowsingDatabaseManager;
 class SafeBrowsingApiHandler;
 class SafeBrowsingNetworkContext;
@@ -49,13 +50,14 @@ class SafeBrowsingService {
   void Initialize();
   std::unique_ptr<blink::URLLoaderThrottle> CreateURLLoaderThrottle(
       const base::RepeatingCallback<content::WebContents*()>& wc_getter,
-      int frame_tree_node_id);
+      int frame_tree_node_id,
+      safe_browsing::RealTimeUrlLookupServiceBase* url_lookup_service);
   std::unique_ptr<content::NavigationThrottle>
   CreateSafeBrowsingNavigationThrottle(content::NavigationHandle* handle);
   void AddInterface(service_manager::BinderRegistry* registry,
                     content::RenderProcessHost* render_process_host);
   void StopDBManager();
-  void SetSafeBrowsingDisabled(bool disabled);
+  scoped_refptr<network::SharedURLLoaderFactory> GetURLLoaderFactory();
 
  private:
   SafeBrowsingUIManager* GetSafeBrowsingUIManager();
@@ -72,7 +74,6 @@ class SafeBrowsingService {
   void CreateURLLoaderFactoryForIO(
       mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver);
   void StopDBManagerOnIOThread();
-  void SetSafeBrowsingDisabledOnIOThread(bool disabled);
 
   // The UI manager handles showing interstitials. Accessed on both UI and IO
   // thread.
@@ -98,8 +99,6 @@ class SafeBrowsingService {
 
   std::string user_agent_;
 
-  bool safe_browsing_disabled_;
-
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingService);
 };
 
diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.cc b/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.cc
index e2eecc83687..a616dfef1b7 100644
--- a/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.cc
+++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.cc
@@ -4,15 +4,28 @@
 
 #include "weblayer/browser/safe_browsing/safe_browsing_ui_manager.h"
 
+#include "components/safe_browsing/core/ping_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "weblayer/browser/safe_browsing/safe_browsing_blocking_page.h"
+#include "weblayer/browser/safe_browsing/safe_browsing_service.h"
 #include "weblayer/browser/safe_browsing/safe_browsing_subresource_helper.h"
 
 using content::BrowserThread;
 
+namespace {
+
+std::string GetProtocolConfigClientName() {
+  // Return a weblayer specific client name.
+  return "weblayer";
+}
+
+}  // namespace
+
 namespace weblayer {
 
-SafeBrowsingUIManager::SafeBrowsingUIManager() {
+SafeBrowsingUIManager::SafeBrowsingUIManager(
+    SafeBrowsingService* safe_browsing_service)
+    : safe_browsing_service_(safe_browsing_service) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
@@ -21,8 +34,19 @@ SafeBrowsingUIManager::~SafeBrowsingUIManager() = default;
 void SafeBrowsingUIManager::SendSerializedThreatDetails(
     const std::string& serialized) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  // TODO(timvolodine): figure out if we want to send any threat reporting here.
-  // Note the base implementation does not send anything.
+
+  if (!ping_manager_) {
+    ping_manager_ = ::safe_browsing::PingManager::Create(
+        safe_browsing_service_->GetURLLoaderFactory(),
+        safe_browsing::GetV4ProtocolConfig(GetProtocolConfigClientName(),
+                                           false /* auto_update */));
+  }
+
+  if (serialized.empty())
+    return;
+
+  DVLOG(1) << "Sending serialized threat details";
+  ping_manager_->ReportThreatDetails(serialized);
 }
 
 safe_browsing::BaseBlockingPage*
diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.h b/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.h
index 54e1c5136b5..989183c9c02 100644
--- a/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.h
+++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.h
@@ -14,16 +14,21 @@ class WebContents;
 
 namespace safe_browsing {
 class BaseBlockingPage;
+class PingManager;
 }
 
 namespace weblayer {
+class SafeBrowsingService;
 
 class SafeBrowsingUIManager : public safe_browsing::BaseUIManager {
  public:
   // Construction needs to happen on the UI thread.
-  SafeBrowsingUIManager();
+  SafeBrowsingUIManager(SafeBrowsingService* safe_browsing_service);
 
   // BaseUIManager overrides.
+
+  // Called on the UI thread by the ThreatDetails with the serialized
+  // protocol buffer, so the service can send it over.
   void SendSerializedThreatDetails(const std::string& serialized) override;
 
  protected:
@@ -35,6 +40,11 @@ class SafeBrowsingUIManager : public safe_browsing::BaseUIManager {
       const GURL& blocked_url,
       const UnsafeResource& unsafe_resource) override;
 
+  // Provides phishing and malware statistics. Accessed on IO thread.
+  std::unique_ptr<safe_browsing::PingManager> ping_manager_;
+
+  SafeBrowsingService* safe_browsing_service_;
+
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingUIManager);
 };
 
diff --git a/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.cc b/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.cc
index 5eb42c49e92..7ff46a3158c 100644
--- a/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.cc
+++ b/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.cc
@@ -5,7 +5,6 @@
 #include "weblayer/browser/safe_browsing/url_checker_delegate_impl.h"
 
 #include "base/bind.h"
-#include "base/task/post_task.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"
@@ -16,11 +15,9 @@ namespace weblayer {
 
 UrlCheckerDelegateImpl::UrlCheckerDelegateImpl(
     scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager,
-    scoped_refptr<SafeBrowsingUIManager> ui_manager,
-    bool disabled)
+    scoped_refptr<SafeBrowsingUIManager> ui_manager)
     : database_manager_(std::move(database_manager)),
       ui_manager_(std::move(ui_manager)),
-      safe_browsing_disabled_(disabled),
       threat_types_(safe_browsing::CreateSBThreatTypeSet(
           {safe_browsing::SB_THREAT_TYPE_URL_MALWARE,
            safe_browsing::SB_THREAT_TYPE_URL_PHISHING,
@@ -38,8 +35,8 @@ void UrlCheckerDelegateImpl::StartDisplayingBlockingPageHelper(
     const net::HttpRequestHeaders& headers,
     bool is_main_frame,
     bool has_user_gesture) {
-  base::PostTask(
-      FROM_HERE, {content::BrowserThread::UI},
+  content::GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(
           &UrlCheckerDelegateImpl::StartDisplayingDefaultBlockingPage,
           base::Unretained(this), resource));
@@ -61,8 +58,8 @@ void UrlCheckerDelegateImpl::StartDisplayingDefaultBlockingPage(
   }
 
   // Report back that it is not ok to proceed with loading the URL.
-  base::PostTask(FROM_HERE, {content::BrowserThread::IO},
-                 base::BindOnce(resource.callback, false /* proceed */,
+  content::GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(resource.callback, false /* proceed */,
                                 false /* showed_interstitial */));
 }
 
@@ -71,17 +68,13 @@ bool UrlCheckerDelegateImpl::IsUrlWhitelisted(const GURL& url) {
   return false;
 }
 
-void UrlCheckerDelegateImpl::SetSafeBrowsingDisabled(bool disabled) {
-  safe_browsing_disabled_ = disabled;
-}
-
 bool UrlCheckerDelegateImpl::ShouldSkipRequestCheck(
     const GURL& original_url,
     int frame_tree_node_id,
     int render_process_id,
     int render_frame_id,
     bool originated_from_service_worker) {
-  return safe_browsing_disabled_ ? true : false;
+  return false;
 }
 
 void UrlCheckerDelegateImpl::NotifySuspiciousSiteDetected(
diff --git a/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.h b/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.h
index d59745bed10..c940d7f7c98 100644
--- a/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.h
+++ b/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.h
@@ -23,8 +23,7 @@ class UrlCheckerDelegateImpl : public safe_browsing::UrlCheckerDelegate {
   UrlCheckerDelegateImpl(
       scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager>
           database_manager,
-      scoped_refptr<SafeBrowsingUIManager> ui_manager,
-      bool disabled);
+      scoped_refptr<SafeBrowsingUIManager> ui_manager);
 
   void SetSafeBrowsingDisabled(bool disabled);
 
@@ -61,7 +60,6 @@ class UrlCheckerDelegateImpl : public safe_browsing::UrlCheckerDelegate {
 
   scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager_;
   scoped_refptr<SafeBrowsingUIManager> ui_manager_;
-  bool safe_browsing_disabled_;
   safe_browsing::SBThreatTypeSet threat_types_;
 
   DISALLOW_COPY_AND_ASSIGN(UrlCheckerDelegateImpl);