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 16 matching lines @@
 
 // RulesRegistryWithCache
 
 RulesRegistryWithCache::RulesRegistryWithCache(
     Profile* profile,
     const char* event_name,
     content::BrowserThread::ID owner_thread,
     bool log_storage_init_delay,
     scoped_ptr<RuleStorageOnUI>* ui_part)
     : RulesRegistry(owner_thread, event_name),
-      weak_ptr_factory_((profile) ? this : NULL),
+      weak_ptr_factory_(this),
       storage_on_ui_((profile
                           ? (new RuleStorageOnUI(profile,
                                                  GetDeclarativeRuleStorageKey(
                                                      event_name,
                                                      profile->IsOffTheRecord()),
                                                  owner_thread,
                                                  weak_ptr_factory_.GetWeakPtr(),
                                                  log_storage_init_delay))
                                 ->GetWeakPtr()
-                          : base::WeakPtr<RuleStorageOnUI>())) {
+                          : base::WeakPtr<RuleStorageOnUI>())),
+      process_changed_rules_requested_(false) {
   if (!profile) {
     CHECK(!ui_part);
     return;
   }
 
   ui_part->reset(storage_on_ui_.get());
 
   storage_on_ui_->Init();
 }
 
@@ skipping 17 matching lines @@
     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;
   }
 
-  ProcessChangedRules(extension_id);
+  if (!process_changed_rules_requested_) {
+    process_changed_rules_requested_ = true;
+    ready_.Post(FROM_HERE,
+                base::Bind(&RulesRegistryWithCache::ProcessChangedRules,
+                           weak_ptr_factory_.GetWeakPtr(),
+                           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.
   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);
   }
 
-  ProcessChangedRules(extension_id);
+  if (!process_changed_rules_requested_) {
+    process_changed_rules_requested_ = true;
+    ready_.Post(FROM_HERE,
+                base::Bind(&RulesRegistryWithCache::ProcessChangedRules,
+                           weak_ptr_factory_.GetWeakPtr(),
+                           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);
   }
 
-  ProcessChangedRules(extension_id);
+  if (!process_changed_rules_requested_) {
+    process_changed_rules_requested_ = true;
+    ready_.Post(FROM_HERE,
+                base::Bind(&RulesRegistryWithCache::ProcessChangedRules,
+                           weak_ptr_factory_.GetWeakPtr(),
+                           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()));
 
   for (std::vector<std::string>::const_iterator i = rule_identifiers.begin();
@@ skipping 47 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()));
 
+  process_changed_rules_requested_ = false;
+
   std::vector<linked_ptr<RulesRegistry::Rule> > new_rules;
   std::string error = GetAllRules(extension_id, &new_rules);
   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))));
@@ skipping 135 matching lines @@
                  base::Passed(&value)));
 
   waiting_for_extensions_.erase(extension_id);
 
   if (waiting_for_extensions_.empty())
     ExtensionSystem::Get(profile_)->ready().Post(
         FROM_HERE, base::Bind(&RuleStorageOnUI::CheckIfReady, GetWeakPtr()));
 }
 
 }  // namespace extensions