Decouple RulesCacheDelegate from RulesRegistry

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

 // Copyright (c) 2012 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_REGISTRY_H__
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_H__
 
 #include "chrome/browser/extensions/api/declarative/rules_registry.h"
 
 #include <map>
@@ skipping 26 matching lines @@
 // RulesRegistry::Rule objects. It contains all the methods that need to run on
 // the registry thread; methods that need to run on the UI thread are separated
 // in the RulesCacheDelegate object.
 class RulesRegistry : public base::RefCountedThreadSafe<RulesRegistry> {
  public:
   typedef extensions::api::events::Rule Rule;
 
   enum Defaults { DEFAULT_PRIORITY = 100 };
   // After the RulesCacheDelegate object (the part of the registry which runs on
   // the UI thread) is created, a pointer to it is passed to |*ui_part|.
-  // If |log_storage_init_delay| is set, the delay caused by loading and
-  // registering rules on initialization will be logged with UMA.
   // In tests, |profile| and |ui_part| can be NULL (at the same time). In that
   // case the storage functionality disabled (no RulesCacheDelegate object
-  // created) and the |log_storage_init_delay| flag is ignored.
+  // created).
   RulesRegistry(Profile* profile,
                 const std::string& event_name,
                 content::BrowserThread::ID owner_thread,
-                bool log_storage_init_delay,
-                scoped_ptr<RulesCacheDelegate>* ui_part);
+                RulesCacheDelegate* cache_delegate);
 
   const OneShotEvent& ready() const {
     return ready_;
   }
 
   // RulesRegistry implementation:
 
   // Registers |rules|, owned by |extension_id| to this RulesRegistry.
   // If a concrete RuleRegistry does not support some of the rules,
   // it may ignore them.
@@ skipping 49 matching lines @@
       std::vector<linked_ptr<RulesRegistry::Rule> >* out);
 
   // Called to notify the RulesRegistry that an extension has been unloaded
   // and all rules of this extension need to be removed.
   void OnExtensionUnloaded(const std::string& extension_id);
 
   // Returns the number of entries in used_rule_identifiers_ for leak detection.
   // Every ExtensionId counts as one entry, even if it contains no rules.
   size_t GetNumberOfUsedRuleIdentifiersForTesting() const;
 
+  // Returns the profile where the rules registry lives.
+  Profile* profile() const { return profile_; }
+
   // Returns the ID of the thread on which the rules registry lives.
   // It is safe to call this function from any thread.
   content::BrowserThread::ID owner_thread() const { return owner_thread_; }
 
   // The name of the event with which rules are registered.
   const std::string& event_name() const { return event_name_; }
 
  protected:
   virtual ~RulesRegistry();
 
@@ skipping 21 matching lines @@
   enum ProcessChangedRulesState {
     // ProcessChangedRules can never be called, |cache_delegate_| is NULL.
     NEVER_PROCESS,
     // A task to call ProcessChangedRules is scheduled for future execution.
     SCHEDULED_FOR_PROCESSING,
     // No task to call ProcessChangedRules is scheduled yet, but it is possible
     // to schedule one.
     NOT_SCHEDULED_FOR_PROCESSING
   };
 
+  base::WeakPtr<RulesRegistry> GetWeakPtr() {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    return weak_ptr_factory_.GetWeakPtr();
+  }
+
   // Common processing after extension's rules have changed.
   void ProcessChangedRules(const std::string& extension_id);
 
   // Calls ProcessChangedRules if |process_changed_rules_requested_| ==
   // NOT_SCHEDULED_FOR_PROCESSING.
   void MaybeProcessChangedRules(const std::string& extension_id);
 
-  // Process the callbacks once the registry gets ready.
   void MarkReady(base::Time storage_init_time);
 
   // Deserialize the rules from the given Value object and add them to the
   // RulesRegistry.
   void DeserializeAndAddRules(const std::string& extension_id,
                               scoped_ptr<base::Value> rules);
 
+  // The profile to which this rules registry belongs.
+  Profile* profile_;
 
   // The ID of the thread on which the rules registry lives.
   const content::BrowserThread::ID owner_thread_;
 
   // The name of the event with which rules are registered.
   const std::string event_name_;
 
   RulesDictionary rules_;
 
   // Signaled when we have finished reading from storage for all extensions that
   // are loaded on startup.
   OneShotEvent ready_;
 
   // The factory needs to be declared before |cache_delegate_|, so that it can
   // produce a pointer as a construction argument for |cache_delegate_|.
   base::WeakPtrFactory<RulesRegistry> weak_ptr_factory_;
 
   // |cache_delegate_| is owned by the registry service. If |cache_delegate_| is
   // NULL, then the storage functionality is disabled (this is used in tests).
   // This registry cannot own |cache_delegate_| because during the time after
   // rules registry service shuts down on UI thread, and the registry is
   // destroyed on its thread, the use of the |cache_delegate_| would not be
   // safe. The registry only ever associates with one RulesCacheDelegate
   // instance.
-  const base::WeakPtr<RulesCacheDelegate> cache_delegate_;
+  base::WeakPtr<RulesCacheDelegate> cache_delegate_;
 
   ProcessChangedRulesState process_changed_rules_requested_;
 
   // Returns whether any existing rule is registered with identifier |rule_id|
   // for extension |extension_id|.
   bool IsUniqueId(const std::string& extension_id,
                   const std::string& rule_id) const;
 
   // Creates an ID that is unique within the scope of|extension_id|.
   std::string GenerateUniqueId(const std::string& extension_id);
@@ skipping 21 matching lines @@
   typedef std::map<ExtensionId, std::set<RuleIdentifier> > RuleIdentifiersMap;
   RuleIdentifiersMap used_rule_identifiers_;
   int last_generated_rule_identifier_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RulesRegistry);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_H__