RulesRegistryWithCache::ProcessChangedRules speed-up

chrome/browser/extensions/api/declarative/rules_registry_with_cache.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_WITH_CACHE_H__
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_WITH_CACHE_H__
 
 #include "chrome/browser/extensions/api/declarative/rules_registry.h"
 
 #include <map>
@@ skipping 11 matching lines @@
 class Profile;
 
 namespace extensions {
 
 // A base class for RulesRegistries that takes care of storing the
 // 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 RuleStorageOnUI object.
 class RulesRegistryWithCache : public RulesRegistry {
  public:
+  typedef std::vector<linked_ptr<RulesRegistry::Rule> > RulesVector;
   // RuleStorageOnUI 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.
   // If |log_storage_init_delay| is set, the delay caused by loading and
   // registering rules on initialization will be logged with UMA.
   class RuleStorageOnUI : public content::NotificationObserver {
    public:
     RuleStorageOnUI(Profile* profile,
                     const std::string& storage_key,
                     content::BrowserThread::ID rules_registry_thread,
                     base::WeakPtr<RulesRegistryWithCache> registry,
                     bool log_storage_init_delay);
 
     virtual ~RuleStorageOnUI();
 
     // Initialize the storage functionality.
     void Init();
 
     void WriteToStorage(const std::string& extension_id,
-                        scoped_ptr<base::Value> value);
+                        scoped_ptr<RulesVector> new_rules);
 
     base::WeakPtr<RuleStorageOnUI> GetWeakPtr() {
       DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
       return weak_ptr_factory_.GetWeakPtr();
     }
 
    private:
     enum ReadyState {    // Our increasing states of readiness.
       NOT_READY,         // Waiting for NOTIFICATION_EXTENSIONS_READY.
       EXTENSIONS_READY,  // Observed NOTIFICATION_EXTENSIONS_READY.
@@ skipping 92 matching lines @@
       const std::vector<linked_ptr<RulesRegistry::Rule> >& rules) = 0;
   virtual std::string RemoveRulesImpl(
       const std::string& extension_id,
       const std::vector<std::string>& rule_identifiers) = 0;
   virtual std::string RemoveAllRulesImpl(
       const std::string& extension_id) = 0;
 
  private:
   typedef std::string ExtensionId;
   typedef std::string RuleId;
-  typedef std::pair<ExtensionId, RuleId> RulesDictionaryKey;
-  typedef std::map<RulesDictionaryKey, linked_ptr<RulesRegistry::Rule> >
-      RulesDictionary;
+  typedef std::map<RuleId, linked_ptr<RulesRegistry::Rule> > RulesDictionary;
 
   // Common processing after extension's rules have changed.
   void ProcessChangedRules(const std::string& extension_id);
 
   // Process the callbacks once the registry gets ready.
   void OnReady(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);
 
 
-  RulesDictionary rules_;
+  std::map<ExtensionId, RulesDictionary> rules_;

[battre, 2013/05/07 16:22:09]

This variable is going to be deleted with my CL. I think there is no purpose
then of pursuing this CL, right? 

 
   std::vector<base::Closure> ready_callbacks_;
 
   // True when we have finished reading from storage for all extensions that
   // are loaded on startup.
   bool ready_;
 
   // The factory needs to be declared before |storage_on_ui_|, so that it can
   // produce a pointer as a construction argument for |storage_on_ui_|.
   base::WeakPtrFactory<RulesRegistryWithCache> weak_ptr_factory_;
 
   // |storage_on_ui_| is owned by the registry service. If |storage_on_ui_| is
   // NULL, then the storage functionality is disabled (this is used in tests).
   // This registry cannot own |storage_on_ui_| 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 |storage_on_ui_| would not be
   // safe. The registry only ever associates with one RuleStorageOnUI instance.
   const base::WeakPtr<RuleStorageOnUI> storage_on_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(RulesRegistryWithCache);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_RULES_REGISTRY_WITH_CACHE_H__