[SubresourceFilter] Bring up RulesetService in WebLayer

This CL brings up RulesetService in WebLayer as a first step to enabling
the subresource filter component. To facilitate this bringup, this CL
refactors much of the //chrome-level creation of RulesetService into a
static RulesetService::Create() method that is shared between //weblayer
and //chrome.

Bug: 1116095
Change-Id: I285bc68fd59164826696cc700a3fbe7b934e582a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2434342
Commit-Queue: Colin Blundell <blundell@chromium.org>
Reviewed-by: Charlie Harrison <csharrison@chromium.org>
Cr-Commit-Position: refs/heads/master@{#811825}

chrome/browser/browser_process_impl.cc

@@ -111,8 +111,6 @@
 #include "components/safe_browsing/core/safe_browsing_service_interface.h"
 #include "components/sessions/core/session_id_generator.h"
 #include "components/subresource_filter/content/browser/ruleset_service.h"
-#include "components/subresource_filter/core/browser/subresource_filter_constants.h"
-#include "components/subresource_filter/core/browser/subresource_filter_features.h"
 #include "components/translate/core/browser/translate_download_manager.h"
 #include "components/ukm/ukm_service.h"
 #include "components/update_client/update_query_params.h"
@@ -1269,32 +1267,10 @@ void BrowserProcessImpl::CreateSubresourceFilterRulesetService() {
   DCHECK(!subresource_filter_ruleset_service_);
   created_subresource_filter_ruleset_service_ = true;
 
-  if (!base::FeatureList::IsEnabled(
-          subresource_filter::kSafeBrowsingSubresourceFilter)) {
-    return;
-  }
-
-  // Runner for tasks critical for user experience.
-  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner(
-      base::ThreadPool::CreateSequencedTaskRunner(
-          {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
-           base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}));
-
-  // Runner for tasks that do not influence user experience.
-  scoped_refptr<base::SequencedTaskRunner> background_task_runner(
-      base::ThreadPool::CreateSequencedTaskRunner(
-          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
-           base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}));
-
   base::FilePath user_data_dir;
   base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-  base::FilePath indexed_ruleset_base_dir =
-      user_data_dir.Append(subresource_filter::kTopLevelDirectoryName)
-          .Append(subresource_filter::kIndexedRulesetBaseDirectoryName);
   subresource_filter_ruleset_service_ =
-      std::make_unique<subresource_filter::RulesetService>(
-          local_state(), background_task_runner, indexed_ruleset_base_dir,
-          blocking_task_runner);
+      subresource_filter::RulesetService::Create(local_state(), user_data_dir);
 }
 
 void BrowserProcessImpl::CreateFlocBlocklistService() {

components/subresource_filter/content/browser/ruleset_service.cc

@@ -29,6 +29,7 @@
 #include "components/subresource_filter/content/common/subresource_filter_messages.h"
 #include "components/subresource_filter/core/browser/copying_file_stream.h"
 #include "components/subresource_filter/core/browser/subresource_filter_constants.h"
+#include "components/subresource_filter/core/browser/subresource_filter_features.h"
 #include "components/subresource_filter/core/common/common_features.h"
 #include "components/subresource_filter/core/common/indexed_ruleset.h"
 #include "components/subresource_filter/core/common/time_measurements.h"
@@ -161,6 +162,35 @@ decltype(&RulesetService::IndexRuleset) RulesetService::g_index_ruleset_func =
 decltype(&base::ReplaceFile) RulesetService::g_replace_file_func =
     &base::ReplaceFile;
 
+// static
+std::unique_ptr<RulesetService> RulesetService::Create(
+    PrefService* local_state,
+    const base::FilePath& user_data_dir) {
+  if (!base::FeatureList::IsEnabled(kSafeBrowsingSubresourceFilter)) {
+    return nullptr;
+  }
+
+  // Runner for tasks critical for user experience.
+  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner(
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
+           base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}));
+
+  // Runner for tasks that do not influence user experience.
+  scoped_refptr<base::SequencedTaskRunner> background_task_runner(
+      base::ThreadPool::CreateSequencedTaskRunner(
+          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
+           base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}));
+
+  base::FilePath indexed_ruleset_base_dir =
+      user_data_dir.Append(kTopLevelDirectoryName)
+          .Append(kIndexedRulesetBaseDirectoryName);
+
+  return std::make_unique<RulesetService>(local_state, background_task_runner,
+                                          indexed_ruleset_base_dir,
+                                          blocking_task_runner);
+}
+
 RulesetService::RulesetService(
     PrefService* local_state,
     scoped_refptr<base::SequencedTaskRunner> background_task_runner,

components/subresource_filter/content/browser/ruleset_service.h

@@ -144,10 +144,18 @@ class RulesetService : public base::SupportsWeakPtr<RulesetService> {
     MAX,
   };
 
-  // Creates a new instance of a ruleset.  This is then assigned to a
-  // RulesetPublisher that calls Initialize for this ruleset service.
-  // Starts initialization of the RulesetService, performing tasks that won't
-  // slow down Chrome startup, then queues the FinishInitialization task.
+  // Creates a new instance of a ruleset with common configuration for
+  // production usage in embedders.
+  static std::unique_ptr<RulesetService> Create(
+      PrefService* local_state,
+      const base::FilePath& user_data_dir);
+
+  // Creates a new instance of a ruleset This is then assigned to a
+  // RulesetPublisher that calls Initialize for this ruleset service.  Starts
+  // initialization of the RulesetService, performing tasks that won't slow down
+  // Chrome startup, then queues the FinishInitialization task.
+  // NOTE: This constructor supports specifying various params explicitly for
+  // tests. Production code should favor RulesetService::Create().
   RulesetService(
       PrefService* local_state,
       scoped_refptr<base::SequencedTaskRunner> background_task_runner,

weblayer/BUILD.gn

@@ -426,6 +426,8 @@ source_set("weblayer_lib_base") {
     "//components/ssl_errors",
     "//components/startup_metric_utils/browser",
     "//components/strings",
+    "//components/subresource_filter/content/browser",
+    "//components/subresource_filter/core/browser",
     "//components/translate/content/browser",
     "//components/translate/content/renderer",
     "//components/translate/core/browser",

weblayer/browser/DEPS

@@ -56,6 +56,8 @@ include_rules = [
   "+components/ssl_errors",
   "+components/startup_metric_utils",
   "+components/strings",
+  "+components/subresource_filter/content/browser",
+  "+components/subresource_filter/core/browser",
   "+components/translate/content/android",
   "+components/translate/content/browser",
   "+components/translate/core/browser",

weblayer/browser/browser_process.cc

@@ -6,15 +6,18 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/path_service.h"
 #include "base/time/default_clock.h"
 #include "base/time/default_tick_clock.h"
 #include "components/network_time/network_time_tracker.h"
 #include "components/prefs/pref_service.h"
+#include "components/subresource_filter/content/browser/ruleset_service.h"
 #include "content/public/browser/network_quality_observer_factory.h"
 #include "content/public/browser/network_service_instance.h"
 #include "services/network/public/cpp/network_quality_tracker.h"
 #include "weblayer/browser/system_network_context_manager.h"
 #include "weblayer/browser/user_agent.h"
+#include "weblayer/common/weblayer_paths.h"
 
 #if defined(OS_ANDROID)
 #include "weblayer/browser/safe_browsing/safe_browsing_service.h"
@@ -92,6 +95,14 @@ network::NetworkQualityTracker* BrowserProcess::GetNetworkQualityTracker() {
   return network_quality_tracker_.get();
 }
 
+subresource_filter::RulesetService*
+BrowserProcess::subresource_filter_ruleset_service() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  if (!subresource_filter_ruleset_service_)
+    CreateSubresourceFilterRulesetService();
+  return subresource_filter_ruleset_service_.get();
+}
+
 void BrowserProcess::CreateNetworkQualityObserver() {
   DCHECK(!network_quality_observer_);
   network_quality_observer_ =
@@ -99,6 +110,16 @@ void BrowserProcess::CreateNetworkQualityObserver() {
   DCHECK(network_quality_observer_);
 }
 
+void BrowserProcess::CreateSubresourceFilterRulesetService() {
+  DCHECK(!subresource_filter_ruleset_service_);
+
+  base::FilePath user_data_dir;
+  CHECK(base::PathService::Get(DIR_USER_DATA, &user_data_dir));
+  subresource_filter_ruleset_service_ =
+      subresource_filter::RulesetService::Create(GetLocalState(),
+                                                 user_data_dir);
+}
+
 #if defined(OS_ANDROID)
 SafeBrowsingService* BrowserProcess::GetSafeBrowsingService() {
   if (!safe_browsing_service_) {

weblayer/browser/browser_process.h

@@ -23,6 +23,10 @@ namespace network {
 class SharedURLLoaderFactory;
 }
 
+namespace subresource_filter {
+class RulesetService;
+}
+
 namespace weblayer {
 class SafeBrowsingService;
 
@@ -48,6 +52,10 @@ class BrowserProcess {
   network_time::NetworkTimeTracker* GetNetworkTimeTracker();
   network::NetworkQualityTracker* GetNetworkQualityTracker();
 
+  // Returns the service providing versioned storage for rules used by the Safe
+  // Browsing subresource filter. May be null.
+  subresource_filter::RulesetService* subresource_filter_ruleset_service();
+
 #if defined(OS_ANDROID)
   SafeBrowsingService* GetSafeBrowsingService();
   void StopSafeBrowsingService();
@@ -55,6 +63,7 @@ class BrowserProcess {
 
  private:
   void CreateNetworkQualityObserver();
+  void CreateSubresourceFilterRulesetService();
 
   std::unique_ptr<PrefService> local_state_;
   std::unique_ptr<network_time::NetworkTimeTracker> network_time_tracker_;
@@ -66,6 +75,9 @@ class BrowserProcess {
       network::NetworkQualityTracker::RTTAndThroughputEstimatesObserver>
       network_quality_observer_;
 
+  std::unique_ptr<subresource_filter::RulesetService>
+      subresource_filter_ruleset_service_;
+
 #if defined(OS_ANDROID)
   std::unique_ptr<SafeBrowsingService> safe_browsing_service_;
 #endif

weblayer/browser/content_browser_client_impl.cc

@@ -39,6 +39,7 @@
 #include "components/site_isolation/preloaded_isolated_origins.h"
 #include "components/site_isolation/site_isolation_policy.h"
 #include "components/strings/grit/components_locale_settings.h"
+#include "components/subresource_filter/content/browser/ruleset_version.h"
 #include "components/user_prefs/user_prefs.h"
 #include "components/variations/service/variations_service.h"
 #include "content/public/browser/browser_context.h"
@@ -245,6 +246,7 @@ void RegisterPrefs(PrefRegistrySimple* pref_registry) {
   metrics::AndroidMetricsServiceClient::RegisterPrefs(pref_registry);
 #endif
   variations::VariationsService::RegisterPrefs(pref_registry);
+  subresource_filter::IndexedRulesetVersion::RegisterPrefs(pref_registry);
 }
 
 mojo::PendingRemote<prerender::mojom::PrerenderCanceler> GetPrerenderCanceler(

weblayer/browser/subresource_filter_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 "testing/gtest/include/gtest/gtest.h"
+#include "weblayer/browser/browser_process.h"
+#include "weblayer/test/weblayer_browser_test.h"
+
+namespace weblayer {
+
+class SubresourceFilterBrowserTest : public WebLayerBrowserTest {
+ public:
+  SubresourceFilterBrowserTest() = default;
+  ~SubresourceFilterBrowserTest() override = default;
+  SubresourceFilterBrowserTest(const SubresourceFilterBrowserTest&) = delete;
+  SubresourceFilterBrowserTest& operator=(const SubresourceFilterBrowserTest&) =
+      delete;
+};
+
+// Tests that the ruleset service is available.
+IN_PROC_BROWSER_TEST_F(SubresourceFilterBrowserTest, RulesetService) {
+  EXPECT_NE(BrowserProcess::GetInstance()->subresource_filter_ruleset_service(),
+            nullptr);
+}
+
+}  // namespace weblayer

weblayer/test/BUILD.gn

@@ -149,6 +149,7 @@ test("weblayer_browsertests") {
     "../browser/profile_browsertest.cc",
     "../browser/site_isolation_browsertest.cc",
     "../browser/ssl_browsertest.cc",
+    "../browser/subresource_filter_browsertest.cc",
     "../browser/translate_browsertest.cc",
     "../browser/url_bar/url_bar_browsertest.cc",
     "../browser/weblayer_variations_http_browsertest.cc",