Decouple RulesCacheDelegate from RulesRegistry

chrome/browser/extensions/api/declarative/rules_cache_delegate.h

 // Copyright 2013 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 CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__
 
 #include <set>
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/values.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class Profile;
 
 namespace extensions {
 
 class RulesRegistry;
 
 // RulesCacheDelegate implements the part of the RulesRegistry which works on
-// the UI thread. It should only be used on the UI thread. It gets created
-// by the RulesRegistry, but right after that it changes owner to the
-// RulesRegistryService, and is deleted by the service.
+// the UI thread. It should only be used on the UI thread.
 // If |log_storage_init_delay| is set, the delay caused by loading and
 // registering rules on initialization will be logged with UMA.
 class RulesCacheDelegate : public content::NotificationObserver {
-  public:
-  // |event_name| identifies the JavaScript event for which rules are
-  // registered. For example, for WebRequestRulesRegistry the name is
-  // "declarativeWebRequest.onRequest".
-  RulesCacheDelegate(Profile* profile,
-                     const std::string& event_name,
-                     content::BrowserThread::ID rules_registry_thread,
-                     base::WeakPtr<RulesRegistry> registry,
-                     bool log_storage_init_delay);
+ public:
+
+  explicit RulesCacheDelegate(bool log_storage_init_delay);
 
   virtual ~RulesCacheDelegate();
 
   // Returns a key for the state store. The associated preference is a boolean
   // indicating whether there are some declarative rules stored in the rule
   // store.
   static std::string GetRulesStoredKey(const std::string& event_name,
                                        bool incognito);
 
   // Initialize the storage functionality.
-  void Init();
+  void Init(RulesRegistry* registry);
 
   void WriteToStorage(const std::string& extension_id,
                       scoped_ptr<base::Value> value);
 
   base::WeakPtr<RulesCacheDelegate> GetWeakPtr() {
     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
     return weak_ptr_factory_.GetWeakPtr();
   }
 
-  private:
+ private:
   FRIEND_TEST_ALL_PREFIXES(RulesRegistryWithCacheTest,
                            DeclarativeRulesStored);
   FRIEND_TEST_ALL_PREFIXES(RulesRegistryWithCacheTest,
                            RulesStoredFlagMultipleRegistries);
 
   static const char kRulesStoredKey[];
 
   // NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
@@ skipping 19 matching lines @@
   bool GetDeclarativeRulesStored(const std::string& extension_id) const;
   // Modify the preference to |rules_stored|.
   void SetDeclarativeRulesStored(const std::string& extension_id,
                                  bool rules_stored);
 
   content::NotificationRegistrar registrar_;
 
   Profile* profile_;
 
   // The key under which rules are stored.
-  const std::string storage_key_;
+  std::string storage_key_;
 
   // The key under which we store whether the rules have been stored.
-  const std::string rules_stored_key_;
+  std::string rules_stored_key_;
 
   // A set of extension IDs that have rules we are reading from storage.
   std::set<std::string> waiting_for_extensions_;
 
   // We measure the time spent on loading rules on init. The result is logged
   // with UMA once per each RulesCacheDelegate instance, unless in Incognito.
   base::Time storage_init_time_;
   bool log_storage_init_delay_;
 
   // Weak pointer to post tasks to the owning rules registry.
-  const base::WeakPtr<RulesRegistry> registry_;
+  base::WeakPtr<RulesRegistry> registry_;
 
   // The thread |registry_| lives on.
-  const content::BrowserThread::ID rules_registry_thread_;
+  content::BrowserThread::ID rules_registry_thread_;
 
   // We notified the RulesRegistry that the rules are loaded.
   bool notified_registry_;
 
   // Use this factory to generate weak pointers bound to the UI thread.
   base::WeakPtrFactory<RulesCacheDelegate> weak_ptr_factory_;
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_CACHE_DELEGATE_H__