RulesRegistryWithCache::ProcessChangedRules speed-up

chrome/browser/extensions/api/declarative/rules_registry_with_cache.cc

 // 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.
 
 #include "chrome/browser/extensions/api/declarative/rules_registry_with_cache.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 24 matching lines @@
 }
 
 std::vector<linked_ptr<extensions::RulesRegistry::Rule> > RulesFromValue(
     const base::Value* value) {
   std::vector<linked_ptr<extensions::RulesRegistry::Rule> > rules;
 
   const base::ListValue* list = NULL;
   if (!value || !value->GetAsList(&list))
     return rules;
 
+  rules.reserve(list->GetSize());
   for (size_t i = 0; i < list->GetSize(); ++i) {
     const base::DictionaryValue* dict = NULL;
     if (!list->GetDictionary(i, &dict))
       continue;
     linked_ptr<extensions::RulesRegistry::Rule> rule(
         new extensions::RulesRegistry::Rule());
     if (extensions::RulesRegistry::Rule::Populate(*dict, rule.get()))
       rules.push_back(rule);
   }
 
@@ skipping 49 matching lines @@
 }
 
 void RulesRegistryWithCache::AddReadyCallback(const base::Closure& callback) {
   ready_callbacks_.push_back(callback);
 }
 
 std::string RulesRegistryWithCache::AddRules(
     const std::string& extension_id,
     const std::vector<linked_ptr<Rule> >& rules) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  RulesDictionary& current_rules = rules_[extension_id];
 
   // Verify that all rule IDs are new.
   for (std::vector<linked_ptr<Rule> >::const_iterator i =
       rules.begin(); i != rules.end(); ++i) {
     const RuleId& rule_id = *((*i)->id);
-    RulesDictionaryKey key(extension_id, rule_id);
-    if (rules_.find(key) != rules_.end())
+    if (current_rules.find(rule_id) != current_rules.end())
       return base::StringPrintf(kDuplicateRuleId, rule_id.c_str());
   }
 
   std::string error = AddRulesImpl(extension_id, rules);
 
   if (!error.empty())
     return error;
 
   // Commit all rules into |rules_| on success.
   for (std::vector<linked_ptr<Rule> >::const_iterator i =
       rules.begin(); i != rules.end(); ++i) {
     const RuleId& rule_id = *((*i)->id);
-    RulesDictionaryKey key(extension_id, rule_id);
-    rules_[key] = *i;
+    current_rules[rule_id] = *i;
   }
 
   ProcessChangedRules(extension_id);
   return kSuccess;
 }
 
 std::string RulesRegistryWithCache::RemoveRules(
     const std::string& extension_id,
     const std::vector<std::string>& rule_identifiers) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
 
   std::string error = RemoveRulesImpl(extension_id, rule_identifiers);
 
   if (!error.empty())
     return error;
 
   // Commit removal of rules from |rules_| on success.
+  RulesDictionary& current_rules = rules_[extension_id];
   for (std::vector<std::string>::const_iterator i =
       rule_identifiers.begin(); i != rule_identifiers.end(); ++i) {
-    RulesDictionaryKey lookup_key(extension_id, *i);
-    rules_.erase(lookup_key);
+    current_rules.erase(*i);
   }
+  if (current_rules.empty())
+    rules_.erase(extension_id);
 
   ProcessChangedRules(extension_id);
   return kSuccess;
 }
 
 std::string RulesRegistryWithCache::RemoveAllRules(
     const std::string& extension_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
 
   std::string error = RemoveAllRulesImpl(extension_id);
 
   if (!error.empty())
     return error;
 
   // Commit removal of rules from |rules_| on success.
-  for (RulesDictionary::const_iterator i = rules_.begin();
-      i != rules_.end();) {
-    const RulesDictionaryKey& key = i->first;
-    ++i;
-    if (key.first == extension_id)
-      rules_.erase(key);
-  }
+  rules_.erase(extension_id);
 
   ProcessChangedRules(extension_id);
   return kSuccess;
 }
 
 std::string RulesRegistryWithCache::GetRules(
     const std::string& extension_id,
     const std::vector<std::string>& rule_identifiers,
     std::vector<linked_ptr<RulesRegistry::Rule> >* out) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
 
+  RulesDictionary& current_rules = rules_[extension_id];
   for (std::vector<std::string>::const_iterator i = rule_identifiers.begin();
       i != rule_identifiers.end(); ++i) {
-    RulesDictionaryKey lookup_key(extension_id, *i);
-    RulesDictionary::iterator entry = rules_.find(lookup_key);
-    if (entry != rules_.end())
+    RulesDictionary::iterator entry = current_rules.find(*i);
+    if (entry != current_rules.end())
       out->push_back(entry->second);
   }
   return kSuccess;
 }
 
 std::string RulesRegistryWithCache::GetAllRules(
     const std::string& extension_id,
     std::vector<linked_ptr<RulesRegistry::Rule> >* out) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
 
-  for (RulesDictionary::const_iterator i = rules_.begin();
-      i != rules_.end(); ++i) {
-    const RulesDictionaryKey& key = i->first;
-    if (key.first == extension_id)
-      out->push_back(i->second);
+  RulesDictionary& current_rules = rules_[extension_id];
+  out->reserve(out->size() + current_rules.size());
+  for (RulesDictionary::const_iterator i = current_rules.begin();
+      i != current_rules.end(); ++i) {
+    out->push_back(i->second);
   }
   return kSuccess;
 }
 
 void RulesRegistryWithCache::OnExtensionUnloaded(
     const std::string& extension_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
   std::string error = RemoveAllRules(extension_id);
   if (!error.empty())
     LOG(ERROR) << error;
@@ skipping 23 matching lines @@
     scoped_ptr<base::Value> rules) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
 
   AddRules(extension_id, RulesFromValue(rules.get()));
 }
 
 void RulesRegistryWithCache::ProcessChangedRules(
     const std::string& extension_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
 
-  std::vector<linked_ptr<RulesRegistry::Rule> > new_rules;
-  std::string error = GetAllRules(extension_id, &new_rules);
+  scoped_ptr<RulesVector> new_rules(new RulesVector());
+  std::string error = GetAllRules(extension_id, new_rules.get());
   DCHECK_EQ(std::string(), error);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&RuleStorageOnUI::WriteToStorage,
                  storage_on_ui_,
                  extension_id,
-                 base::Passed(RulesToValue(new_rules))));
+                 base::Passed(&new_rules)));
 }
 
 // RulesRegistryWithCache::RuleStorageOnUI
 
 RulesRegistryWithCache::RuleStorageOnUI::RuleStorageOnUI(
     Profile* profile,
     const std::string& storage_key,
     content::BrowserThread::ID rules_registry_thread,
     base::WeakPtr<RulesRegistryWithCache> registry,
     bool log_storage_init_delay)
@@ skipping 46 matching lines @@
     // can post tasks for the not-yet-initialized registry to run, we need to
     // postpone checking for being ready (=all rules loaded), on the registry's
     // thread.
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&RuleStorageOnUI::CheckIfReady, GetWeakPtr()));
   }
 }
 
 void RulesRegistryWithCache::RuleStorageOnUI::WriteToStorage(
     const std::string& extension_id,
-    scoped_ptr<base::Value> value) {
+    scoped_ptr<RulesVector> new_rules) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!profile_)
     return;
 
   StateStore* store = ExtensionSystem::Get(profile_)->rules_store();
-  if (store)
-    store->SetExtensionValue(extension_id, storage_key_, value.Pass());
+  if (store) {
+    store->SetExtensionValue(
+        extension_id, storage_key_, RulesToValue(*new_rules));
+  }
 }
 
 void RulesRegistryWithCache::RuleStorageOnUI::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (type == chrome::NOTIFICATION_EXTENSION_LOADED) {
     const extensions::Extension* extension =
         content::Details<const extensions::Extension>(details).ptr();
@@ skipping 60 matching lines @@
                  registry_,
                  extension_id,
                  base::Passed(&value)));
 
   waiting_for_extensions_.erase(extension_id);
 
   CheckIfReady();
 }
 
 }  // namespace extensions