Swap ownership of RulesetService and the content delegate

components/subresource_filter/core/browser/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/core/browser/ruleset_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 127 matching lines @@
 
 // Test fixtures --------------------------------------------------------------
 
 using testing::TestRulesetPair;
 using testing::TestRulesetCreator;
 
 class SubresourceFilteringRulesetServiceTest : public ::testing::Test {
  public:
   SubresourceFilteringRulesetServiceTest()
       : task_runner_(new base::TestSimpleTaskRunner),
-        task_runner_handle_(task_runner_),
-        mock_delegate_(nullptr) {}
+        task_runner_handle_(task_runner_) {}
 
  protected:
   void SetUp() override {
     IndexedRulesetVersion::RegisterPrefs(pref_service_.registry());
 
     SetUpTempDir();
     ResetRulesetService();
     RunUntilIdle();
 
     ASSERT_NO_FATAL_FAILURE(
         ruleset_creator_.CreateRulesetToDisallowURLsWithPathSuffix(
             kTestDisallowedSuffix1, &test_ruleset_1_));
     ASSERT_NO_FATAL_FAILURE(
         ruleset_creator_.CreateRulesetToDisallowURLsWithPathSuffix(
             kTestDisallowedSuffix2, &test_ruleset_2_));
     ASSERT_NO_FATAL_FAILURE(
         ruleset_creator_.CreateRulesetToDisallowURLsWithPathSuffix(
             kTestDisallowedSuffix3, &test_ruleset_3_));
   }
 
   virtual void SetUpTempDir() {
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
   }
 
   void ResetRulesetService() {
+    mock_delegate_ = base::MakeUnique<MockRulesetServiceDelegate>();
     service_ = base::MakeUnique<RulesetService>(
-        &pref_service_, task_runner_,
-        base::WrapUnique(mock_delegate_ = new MockRulesetServiceDelegate),
-        base_dir());
+        &pref_service_, task_runner_, mock_delegate_.get(), base_dir());
   }
 
   void ClearRulesetService() {
-    mock_delegate_ = nullptr;
     service_.reset();
+    mock_delegate_.reset();
   }
 
   // Creates a new file with the given license |contents| at a unique temporary
   // path, which is returned in |path|.
   void CreateTestLicenseFile(const std::string& contents,
                              base::FilePath* path) {
     ASSERT_NO_FATAL_FAILURE(
         test_ruleset_creator()->GetUniqueTemporaryPath(path));
     ASSERT_EQ(static_cast<int>(contents.size()),
               base::WriteFile(*path, contents.data(),
@@ skipping 68 matching lines @@
   void AssertReadonlyRulesetFile(base::File* file) {
     const char kTest[] = "t";
     ASSERT_TRUE(file->IsValid());
     ASSERT_EQ(-1, file->Write(0, kTest, sizeof(kTest)));
   }
 
   void AssertNoPendingTasks() { ASSERT_FALSE(task_runner_->HasPendingTask()); }
 
   PrefService* prefs() { return &pref_service_; }
   RulesetService* service() { return service_.get(); }
-  MockRulesetServiceDelegate* mock_delegate() { return mock_delegate_; }
+  MockRulesetServiceDelegate* mock_delegate() { return mock_delegate_.get(); }
 
   virtual base::FilePath effective_temp_dir() const {
     return scoped_temp_dir_.GetPath();
   }
 
   TestRulesetCreator* test_ruleset_creator() { return &ruleset_creator_; }
   const TestRulesetPair& test_ruleset_1() const { return test_ruleset_1_; }
   const TestRulesetPair& test_ruleset_2() const { return test_ruleset_2_; }
   const TestRulesetPair& test_ruleset_3() const { return test_ruleset_3_; }
   base::FilePath base_dir() const {
     return effective_temp_dir().AppendASCII("Rules").AppendASCII("Indexed");
   }
 
  private:
   base::ScopedTempDir scoped_temp_dir_;
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   TestingPrefServiceSimple pref_service_;
 
   TestRulesetCreator ruleset_creator_;
   TestRulesetPair test_ruleset_1_;
   TestRulesetPair test_ruleset_2_;
   TestRulesetPair test_ruleset_3_;
 
   std::unique_ptr<RulesetService> service_;
-  MockRulesetServiceDelegate* mock_delegate_;  // Weak, owned by |service_|.
+  std::unique_ptr<MockRulesetServiceDelegate> mock_delegate_;

[pkalinnikov, 2017/03/09 16:09:01]

Please swap the lines to ensure that |mock_delegate_| outlives |service_|.

[Charlie Harrison, 2017/03/09 16:12:44]

Done.

 
   DISALLOW_COPY_AND_ASSIGN(SubresourceFilteringRulesetServiceTest);
 };
 
 // Specialized test fixture for death tests. It exposes the temporary directory
 // used by the parent process as an environment variable that is consumed by the
 // child process, so that both processes use the same temporary directory. This
 // would not otherwise be the case on Windows, where children are not `forked`
 // and therefore would create their own unique temp directory.
 class SubresourceFilteringRulesetServiceDeathTest
@@ skipping 681 matching lines @@
   mock_delegate()->SimulateStartupCompleted();
   IndexAndStoreAndPublishUpdatedRuleset(test_ruleset_1(), kTestContentVersion1);
   RunUntilIdle();
 
   ASSERT_EQ(1u, mock_delegate()->published_rulesets().size());
   ASSERT_NO_FATAL_FAILURE(
       AssertReadonlyRulesetFile(&mock_delegate()->published_rulesets()[0]));
 }
 
 }  // namespace subresource_filter