Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in extensions.

chrome/browser/extensions/api/declarative/rules_registry.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.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 77 matching lines @@
       last_generated_rule_identifier_id_(0) {
   if (cache_delegate) {
     cache_delegate_ = cache_delegate->GetWeakPtr();
     cache_delegate->Init(this);
   }
 }
 
 std::string RulesRegistry::AddRulesNoFill(
     const std::string& extension_id,
     const std::vector<linked_ptr<Rule> >& rules) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
 
   // 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);
     // Every rule should have a priority assigned.
     DCHECK((*i)->priority);
     RulesDictionaryKey key(extension_id, rule_id);
     if (rules_.find(key) != rules_.end())
       return base::StringPrintf(kDuplicateRuleId, rule_id.c_str());
@@ skipping 12 matching lines @@
     rules_[key] = *i;
   }
 
   MaybeProcessChangedRules(extension_id);
   return kSuccess;
 }
 
 std::string RulesRegistry::AddRules(
     const std::string& extension_id,
     const std::vector<linked_ptr<Rule> >& rules) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
 
   std::string error = CheckAndFillInOptionalRules(extension_id, rules);
   if (!error.empty())
     return error;
   FillInOptionalPriorities(rules);
 
   return AddRulesNoFill(extension_id, rules);
 }
 
 std::string RulesRegistry::RemoveRules(
     const std::string& extension_id,
     const std::vector<std::string>& rule_identifiers) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
 
   std::string error = RemoveRulesImpl(extension_id, rule_identifiers);
 
   if (!error.empty())
     return error;
 
   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);
   }
 
   MaybeProcessChangedRules(extension_id);
   RemoveUsedRuleIdentifiers(extension_id, rule_identifiers);
   return kSuccess;
 }
 
 std::string RulesRegistry::RemoveAllRules(const std::string& extension_id) {
   std::string result = RulesRegistry::RemoveAllRulesNoStoreUpdate(extension_id);
   MaybeProcessChangedRules(extension_id);  // Now update the prefs and store.
   return result;
 }
 
 std::string RulesRegistry::RemoveAllRulesNoStoreUpdate(
     const std::string& extension_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
 
   std::string error = RemoveAllRulesImpl(extension_id);
 
   if (!error.empty())
     return error;
 
   for (RulesDictionary::const_iterator i = rules_.begin();
       i != rules_.end();) {
     const RulesDictionaryKey& key = i->first;
     ++i;
     if (key.first == extension_id)
       rules_.erase(key);
   }
 
   RemoveAllUsedRuleIdentifiers(extension_id);
   return kSuccess;
 }
 
 void RulesRegistry::GetRules(const std::string& extension_id,
                              const std::vector<std::string>& rule_identifiers,
                              std::vector<linked_ptr<Rule> >* out) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
 
   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())
       out->push_back(entry->second);
   }
 }
 
 void RulesRegistry::GetAllRules(const std::string& extension_id,
                                 std::vector<linked_ptr<Rule> >* out) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(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);
   }
 }
 
 void RulesRegistry::OnExtensionUnloaded(const std::string& extension_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
   std::string error = RemoveAllRulesImpl(extension_id);
   if (!error.empty())
     LOG(ERROR) << error;
 }
 
 void RulesRegistry::OnExtensionUninstalled(const std::string& extension_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
   std::string error = RemoveAllRulesNoStoreUpdate(extension_id);
   if (!error.empty())
     LOG(ERROR) << error;
 }
 
 void RulesRegistry::OnExtensionLoaded(const std::string& extension_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
   std::vector<linked_ptr<Rule> > rules;
   GetAllRules(extension_id, &rules);
   std::string error = AddRulesImpl(extension_id, rules);
   if (!error.empty())
     LOG(ERROR) << error;
 }
 
 size_t RulesRegistry::GetNumberOfUsedRuleIdentifiersForTesting() const {
   size_t entry_count = 0u;
   for (RuleIdentifiersMap::const_iterator extension =
            used_rule_identifiers_.begin();
        extension != used_rule_identifiers_.end();
        ++extension) {
     // Each extension is counted as 1 just for being there. Otherwise we miss
     // keys with empty values.
     entry_count += 1u + extension->second.size();
   }
   return entry_count;
 }
 
 void RulesRegistry::DeserializeAndAddRules(
     const std::string& extension_id,
     scoped_ptr<base::Value> rules) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
 
   AddRulesNoFill(extension_id, RulesFromValue(rules.get()));
 }
 
 RulesRegistry::~RulesRegistry() {
 }
 
 void RulesRegistry::MarkReady(base::Time storage_init_time) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
 
   if (!storage_init_time.is_null()) {
     UMA_HISTOGRAM_TIMES("Extensions.DeclarativeRulesStorageInitialization",
                         base::Time::Now() - storage_init_time);
   }
 
   ready_.Signal();
 }
 
 void RulesRegistry::ProcessChangedRules(const std::string& extension_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(owner_thread()));
+  DCHECK_CURRENTLY_ON(owner_thread());
 
   DCHECK(ContainsKey(process_changed_rules_requested_, extension_id));
   process_changed_rules_requested_[extension_id] = NOT_SCHEDULED_FOR_PROCESSING;
 
   std::vector<linked_ptr<Rule> > new_rules;
   GetAllRules(extension_id, &new_rules);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&RulesCacheDelegate::WriteToStorage,
@@ skipping 86 matching lines @@
   for (i = identifiers.begin(); i != identifiers.end(); ++i)
     used_rule_identifiers_[extension_id].erase(*i);
 }
 
 void RulesRegistry::RemoveAllUsedRuleIdentifiers(
     const std::string& extension_id) {
   used_rule_identifiers_.erase(extension_id);
 }
 
 }  // namespace extensions