Swap ownership of RulesetService and the content delegate

components/subresource_filter/content/browser/content_ruleset_service_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 "components/subresource_filter/content/browser/content_ruleset_service_delegate.h"
+#include "components/subresource_filter/content/browser/content_ruleset_service.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <tuple>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 71 matching lines @@
 
 // Extracts and takes ownership of the ruleset file handle in the IPC message.
 base::File ExtractRulesetFromMessage(const IPC::Message* message) {
   std::tuple<IPC::PlatformFileForTransit> arg;
   SubresourceFilterMsg_SetRulesetForProcess::Read(message, &arg);
   return IPC::PlatformFileForTransitToFile(std::get<0>(arg));
 }
 
 }  // namespace
 
-class SubresourceFilterContentRulesetServiceDelegateTest
-    : public ::testing::Test {
+class SubresourceFilterContentRulesetServiceTest : public ::testing::Test {
  public:
-  SubresourceFilterContentRulesetServiceDelegateTest()
+  SubresourceFilterContentRulesetServiceTest()
       : old_browser_client_(nullptr), existing_renderer_(&browser_context_) {}
 
  protected:
   void SetUp() override {
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
     old_browser_client_ = content::SetBrowserClientForTesting(&browser_client_);
   }
 
   void TearDown() override {
     content::SetBrowserClientForTesting(old_browser_client_);
@@ skipping 16 matching lines @@
   }
 
  private:
   base::ScopedTempDir scoped_temp_dir_;
   TestContentBrowserClient browser_client_;
   content::ContentBrowserClient* old_browser_client_;
   content::TestBrowserThreadBundle thread_bundle_;
   content::TestBrowserContext browser_context_;
   NotifyingMockRenderProcessHost existing_renderer_;
 
-  DISALLOW_COPY_AND_ASSIGN(SubresourceFilterContentRulesetServiceDelegateTest);
+  DISALLOW_COPY_AND_ASSIGN(SubresourceFilterContentRulesetServiceTest);
 };
 
-TEST_F(SubresourceFilterContentRulesetServiceDelegateTest,
-       NoRuleset_NoIPCMessages) {
+TEST_F(SubresourceFilterContentRulesetServiceTest, NoRuleset_NoIPCMessages) {
   NotifyingMockRenderProcessHost existing_renderer(browser_context());
-  ContentRulesetServiceDelegate delegate;
+  ContentRulesetService service;
   NotifyingMockRenderProcessHost new_renderer(browser_context());
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, existing_renderer.sink().message_count());
   EXPECT_EQ(0u, new_renderer.sink().message_count());
 }
 
-TEST_F(SubresourceFilterContentRulesetServiceDelegateTest,
+TEST_F(SubresourceFilterContentRulesetServiceTest,
        PublishedRuleset_IsDistributedToExistingAndNewRenderers) {
   const char kTestFileContents[] = "foobar";
   base::WriteFile(scoped_temp_file(), kTestFileContents,
                   strlen(kTestFileContents));
 
   base::File file;
   file.Initialize(scoped_temp_file(),
                   base::File::FLAG_OPEN | base::File::FLAG_READ);
 
   NotifyingMockRenderProcessHost existing_renderer(browser_context());
-  ContentRulesetServiceDelegate delegate;
+  ContentRulesetService service;
   MockClosureTarget publish_callback_target;
-  delegate.SetRulesetPublishedCallbackForTesting(base::Bind(
+  service.SetRulesetPublishedCallbackForTesting(base::Bind(
       &MockClosureTarget::Call, base::Unretained(&publish_callback_target)));
   EXPECT_CALL(publish_callback_target, Call()).Times(1);
-  delegate.PublishNewRulesetVersion(std::move(file));
+  service.PublishNewRulesetVersion(std::move(file));
   base::RunLoop().RunUntilIdle();
   ::testing::Mock::VerifyAndClearExpectations(&publish_callback_target);
 
   ASSERT_EQ(1u, existing_renderer.sink().message_count());
   ASSERT_NO_FATAL_FAILURE(AssertSetRulesetForProcessMessageWithContent(
       existing_renderer.sink().GetMessageAt(0), kTestFileContents));
 
   NotifyingMockRenderProcessHost second_renderer(browser_context());
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(1u, second_renderer.sink().message_count());
   ASSERT_NO_FATAL_FAILURE(AssertSetRulesetForProcessMessageWithContent(
       second_renderer.sink().GetMessageAt(0), kTestFileContents));
 }
 
-TEST_F(SubresourceFilterContentRulesetServiceDelegateTest,
-       PostAfterStartupTask) {
-  ContentRulesetServiceDelegate delegate;
+TEST_F(SubresourceFilterContentRulesetServiceTest, PostAfterStartupTask) {
+  ContentRulesetService service;
 
   MockClosureTarget mock_closure_target;
-  delegate.PostAfterStartupTask(base::Bind(
+  service.PostAfterStartupTask(base::Bind(
       &MockClosureTarget::Call, base::Unretained(&mock_closure_target)));
 
   EXPECT_CALL(mock_closure_target, Call()).Times(1);
   browser_client()->RunAfterStartupTask();
 }
 
 }  // namespace subresource_filter