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

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

 // Copyright 2013 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_cache_delegate.h"
 
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/declarative/rules_registry.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
@@ skipping 42 matching lines @@
   result += incognito ? ".incognito." : ".";
   return result + event_name;
 }
 
 // This is called from the constructor of RulesRegistry, so it is
 // important that it both
 // 1. calls no (in particular virtual) methods of the rules registry, and
 // 2. does not create scoped_refptr holding the registry. (A short-lived
 // scoped_refptr might delete the rules registry before it is constructed.)
 void RulesCacheDelegate::Init(RulesRegistry* registry) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // WARNING: The first use of |registry_| will bind it to the calling thread
   // so don't use this here.
   registry_ = registry->GetWeakPtr();
 
   profile_ = registry->profile();
   storage_key_ =
       GetDeclarativeRuleStorageKey(registry->event_name(),
                                    profile_->IsOffTheRecord());
   rules_stored_key_ = GetRulesStoredKey(registry->event_name(),
@@ skipping 12 matching lines @@
       FROM_HERE,
       base::Bind(&RulesCacheDelegate::ReadRulesForInstalledExtensions,
                  weak_ptr_factory_.GetWeakPtr()));
   system.ready().Post(FROM_HERE,
                       base::Bind(&RulesCacheDelegate::CheckIfReady,
                                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void RulesCacheDelegate::WriteToStorage(const std::string& extension_id,
                                      scoped_ptr<base::Value> value) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!profile_)
     return;
 
   const base::ListValue* rules = NULL;
   CHECK(value->GetAsList(&rules));
   bool rules_stored_previously = GetDeclarativeRulesStored(extension_id);
   bool store_rules = !rules->empty();
   SetDeclarativeRulesStored(extension_id, store_rules);
   if (!rules_stored_previously && !store_rules)
     return;
 
   StateStore* store = ExtensionSystem::Get(profile_)->rules_store();
   if (store)
     store->SetExtensionValue(extension_id, storage_key_, value.Pass());
 }
 
 void RulesCacheDelegate::CheckIfReady() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (notified_registry_ || !waiting_for_extensions_.empty())
     return;
 
   content::BrowserThread::PostTask(
       rules_registry_thread_,
       FROM_HERE,
       base::Bind(
           &RulesRegistry::MarkReady, registry_, storage_init_time_));
   notified_registry_ = true;
 }
@@ skipping 16 matching lines @@
       bool respects_off_the_record =
           !(profile_->IsOffTheRecord()) ||
           util::IsIncognitoEnabled((*i)->id(), profile_);
       if (needs_apis_storing_rules && respects_off_the_record)
         ReadFromStorage((*i)->id());
     }
   }
 }
 
 void RulesCacheDelegate::ReadFromStorage(const std::string& extension_id) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!profile_)
     return;
 
   if (log_storage_init_delay_ && storage_init_time_.is_null())
     storage_init_time_ = base::Time::Now();
 
   if (!GetDeclarativeRulesStored(extension_id)) {
     ExtensionSystem::Get(profile_)->ready().Post(
         FROM_HERE, base::Bind(&RulesCacheDelegate::CheckIfReady,
                               weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   extensions::StateStore* store = ExtensionSystem::Get(profile_)->rules_store();
   if (!store)
     return;
   waiting_for_extensions_.insert(extension_id);
   store->GetExtensionValue(
       extension_id,
       storage_key_,
       base::Bind(&RulesCacheDelegate::ReadFromStorageCallback,
                  weak_ptr_factory_.GetWeakPtr(),
                  extension_id));
 }
 
 void RulesCacheDelegate::ReadFromStorageCallback(
     const std::string& extension_id,
     scoped_ptr<base::Value> value) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   content::BrowserThread::PostTask(
       rules_registry_thread_,
       FROM_HERE,
       base::Bind(&RulesRegistry::DeserializeAndAddRules,
                  registry_,
                  extension_id,
                  base::Passed(&value)));
 
   waiting_for_extensions_.erase(extension_id);
 
@@ skipping 27 matching lines @@
   DCHECK(extension_service);
   DCHECK(extension_service->GetInstalledExtension(extension_id));
   ExtensionScopedPrefs* extension_prefs = ExtensionPrefs::Get(profile_);
   extension_prefs->UpdateExtensionPref(
       extension_id,
       rules_stored_key_,
       new base::FundamentalValue(rules_stored));
 }
 
 }  // namespace extensions