Swap ownership of RulesetService and the content delegate

components/subresource_filter/core/browser/ruleset_service.h

 // 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.
 
 #ifndef COMPONENTS_SUBRESOURCE_FILTER_CORE_BROWSER_RULESET_SERVICE_H_
 #define COMPONENTS_SUBRESOURCE_FILTER_CORE_BROWSER_RULESET_SERVICE_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 152 matching lines @@
 
     // Insert new values before this line.
     MAX,
   };
 
   // Creates a new instance that will immediately publish the most recently
   // indexed version of the ruleset if one is available according to prefs.
   // See class comments for details of arguments.
   RulesetService(PrefService* local_state,
                  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner,
-                 std::unique_ptr<RulesetServiceDelegate> delegate,
+                 RulesetServiceDelegate* delegate,
                  const base::FilePath& indexed_ruleset_base_dir);
   virtual ~RulesetService();
 
   // Indexes, stores, and publishes the given unindexed ruleset, unless its
   // |content_version| matches that of the most recently indexed version, in
   // which case it does nothing. The files comprising the unindexed ruleset
   // need to remain accessible even after the method returns.
   //
   // Computation-heavy steps and I/O are performed on a background thread.
   // Furthermore, to prevent start-up congestion, new rulesets provided via this
   // method will not be processed until after start-up.
   //
   // Virtual so that it can be mocked out in tests.
   virtual void IndexAndStoreAndPublishRulesetIfNeeded(
       const UnindexedRulesetInfo& unindexed_ruleset_info);
 
-  // Exposed for browser tests.
-  RulesetServiceDelegate* delegate() { return delegate_.get(); }
-
  private:
   friend class SubresourceFilteringRulesetServiceTest;
   FRIEND_TEST_ALL_PREFIXES(SubresourceFilteringRulesetServiceTest,
                            NewRuleset_WriteFailure);
   FRIEND_TEST_ALL_PREFIXES(SubresourceFilteringRulesetServiceDeathTest,
                            NewRuleset_IndexingCrash);
 
   using WriteRulesetCallback =
       base::Callback<void(const IndexedRulesetVersion&)>;
 
@@ skipping 42 matching lines @@
                             const WriteRulesetCallback& success_callback);
 
   void OnWrittenRuleset(const WriteRulesetCallback& result_callback,
                         const IndexedRulesetVersion& version);
 
   void OpenAndPublishRuleset(const IndexedRulesetVersion& version);
   void OnOpenedRuleset(base::File::Error error);
 
   PrefService* const local_state_;
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
-  std::unique_ptr<RulesetServiceDelegate> delegate_;
+
+  // Must outlive this class.

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

nit: Must outlive |this| object.

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

Done.

+  RulesetServiceDelegate* delegate_;
 
   UnindexedRulesetInfo queued_unindexed_ruleset_info_;
   bool is_after_startup_;
 
   const base::FilePath indexed_ruleset_base_dir_;
   std::unique_ptr<base::FileProxy> ruleset_data_;
 
   DISALLOW_COPY_AND_ASSIGN(RulesetService);
 };
 
 }  // namespace subresource_filter
 
 #endif  // COMPONENTS_SUBRESOURCE_FILTER_CORE_BROWSER_RULESET_SERVICE_H_