RulesRegistryWithCache::ProcessChangedRules postponed

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 26 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_(profile ? this : NULL),
       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_(profile ? NOT_SCHEDULED_FOR_PROCESSING
+                                               : NEVER_PROCESS) {
   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);
+  MaybeProcessChangedRules(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);
+  MaybeProcessChangedRules(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);
+  MaybeProcessChangedRules(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_ = NOT_SCHEDULED_FOR_PROCESSING;
+
   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))));
 }
 
+void RulesRegistryWithCache::MaybeProcessChangedRules(
+    const std::string& extension_id) {
+  if (process_changed_rules_requested_ != NOT_SCHEDULED_FOR_PROCESSING)
+    return;
+
+  process_changed_rules_requested_ = SCHEDULED_FOR_PROCESSING;
+  ready_.Post(FROM_HERE,
+              base::Bind(&RulesRegistryWithCache::ProcessChangedRules,
+                         weak_ptr_factory_.GetWeakPtr(),
+                         extension_id));
+}
+
 // RulesRegistryWithCache::RuleStorageOnUI
 
 const char RulesRegistryWithCache::RuleStorageOnUI::kRulesStoredKey[] =
     "has_declarative_rules";
 
 RulesRegistryWithCache::RuleStorageOnUI::RuleStorageOnUI(
     Profile* profile,
     const std::string& storage_key,
     content::BrowserThread::ID rules_registry_thread,
     base::WeakPtr<RulesRegistryWithCache> registry,
@@ skipping 164 matching lines @@
 void RulesRegistryWithCache::RuleStorageOnUI::SetDeclarativeRulesStored(
     const std::string& extension_id,
     bool rules_stored) {
   CHECK(profile_);
   ExtensionScopedPrefs* extension_prefs = ExtensionPrefs::Get(profile_);
   extension_prefs->UpdateExtensionPref(
       extension_id, kRulesStoredKey, new base::FundamentalValue(rules_stored));
 }
 
 }  // namespace extensions