Swap ownership of RulesetService and the content delegate

chrome/browser/component_updater/subresource_filter_component_installer_unittest.cc

 // Copyright 2016 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 "chrome/browser/component_updater/subresource_filter_component_installer.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/version.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "components/component_updater/mock_component_updater_service.h"
 #include "components/prefs/testing_pref_service.h"
-#include "components/subresource_filter/content/browser/content_ruleset_service_delegate.h"
+#include "components/subresource_filter/content/browser/content_ruleset_service.h"
 #include "components/subresource_filter/core/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/subresource_filter/core/browser/subresource_filter_features_test_support.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace {
 
 static const char kTestRulesetVersion[] = "1.2.3.4";
 
 class TestRulesetService : public subresource_filter::RulesetService {
  public:
   TestRulesetService(PrefService* local_state,
                      scoped_refptr<base::SequencedTaskRunner> task_runner,
+                     subresource_filter::ContentRulesetService* content_service,
                      const base::FilePath& base_dir)
-      : subresource_filter::RulesetService(
-            local_state,
-            task_runner,
-            base::MakeUnique<
-                subresource_filter::ContentRulesetServiceDelegate>(),
-            base_dir) {}
+      : subresource_filter::RulesetService(local_state,
+                                           task_runner,
+                                           content_service,
+                                           base_dir) {}
 
   ~TestRulesetService() override {}
 
   using UnindexedRulesetInfo = subresource_filter::UnindexedRulesetInfo;
   void IndexAndStoreAndPublishRulesetIfNeeded(
       const UnindexedRulesetInfo& unindexed_ruleset_info) override {
     unindexed_ruleset_info_ = unindexed_ruleset_info;
   }
 
   const base::FilePath& ruleset_path() const {
@@ skipping 37 matching lines @@
   SubresourceFilterComponentInstallerTest() {}
 
   void SetUp() override {
     PlatformTest::SetUp();
 
     ASSERT_TRUE(component_install_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(ruleset_service_dir_.CreateUniqueTempDir());
     subresource_filter::IndexedRulesetVersion::RegisterPrefs(
         pref_service_.registry());
 
-    std::unique_ptr<subresource_filter::RulesetService> service(
-        new TestRulesetService(&pref_service_, task_runner_,
-                               ruleset_service_dir_.GetPath()));
+    auto content_service =
+        base::MakeUnique<subresource_filter::ContentRulesetService>();
+    auto test_ruleset_service = base::MakeUnique<TestRulesetService>(
+        &pref_service_, task_runner_, content_service.get(),
+        ruleset_service_dir_.GetPath());
+    test_ruleset_service_ = test_ruleset_service.get();
+    content_service->set_ruleset_service(std::move(test_ruleset_service));
 
-    TestingBrowserProcess::GetGlobal()->SetRulesetService(std::move(service));
+    TestingBrowserProcess::GetGlobal()->SetRulesetService(
+        std::move(content_service));
     traits_.reset(new SubresourceFilterComponentInstallerTraits());
   }
 
-  TestRulesetService* service() {
-    return static_cast<TestRulesetService*>(
-        TestingBrowserProcess::GetGlobal()
-            ->subresource_filter_ruleset_service());
-  }
+  TestRulesetService* service() { return test_ruleset_service_; }
 
   void WriteStringToFile(const std::string data, const base::FilePath& path) {
     ASSERT_EQ(static_cast<int32_t>(data.length()),
               base::WriteFile(path, data.data(), data.length()));
   }
 
   base::FilePath component_install_dir() {
     return component_install_dir_.GetPath();
   }
 
@@ skipping 43 matching lines @@
 
  private:
   base::ScopedTempDir component_install_dir_;
   base::ScopedTempDir ruleset_service_dir_;
 
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<SubresourceFilterComponentInstallerTraits> traits_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   TestingPrefServiceSimple pref_service_;
 
+  TestRulesetService* test_ruleset_service_ = nullptr;
+
   DISALLOW_COPY_AND_ASSIGN(SubresourceFilterComponentInstallerTest);
 };
 
 TEST_F(SubresourceFilterComponentInstallerTest,
        TestComponentRegistrationWhenFeatureDisabled) {
   base::FieldTrialList field_trial_list(nullptr);
   subresource_filter::testing::ScopedSubresourceFilterFeatureToggle
       scoped_feature_toggle(base::FeatureList::OVERRIDE_DISABLE_FEATURE,
                             subresource_filter::kActivationLevelEnabled,
                             subresource_filter::kActivationScopeNoSites);
@@ skipping 100 matching lines @@
 
   base::FieldTrialList field_trial_list(nullptr /* entropy_provider */);
   subresource_filter::testing::ScopedSubresourceFilterFeatureToggle
       scoped_feature_toggle(
           base::FeatureList::OVERRIDE_USE_DEFAULT,
           {{subresource_filter::kRulesetFlavorParameterName, kTagValue}});
   EXPECT_EQ(update_client::InstallerAttributes(), GetInstallerAttributes());
 }
 
 }  // namespace component_updater