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

chrome/browser/extensions/api/storage/managed_value_store_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/storage/managed_value_store_cache.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 203 matching lines @@
     (*components)[(*it)->id()] = schema;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&ExtensionTracker::Register, self,
                                      base::Owned(components.release())));
 }
 
 void ManagedValueStoreCache::ExtensionTracker::Register(
     const policy::ComponentMap* components) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   schema_registry_->RegisterComponents(policy::POLICY_DOMAIN_EXTENSIONS,
                                        *components);
 
   // The first SetReady() call is performed after the ExtensionSystem is ready,
   // even if there are no managed extensions. It will trigger a loading of the
   // initial policy for any managed extensions, and eventually the PolicyService
   // will become ready for POLICY_DOMAIN_EXTENSIONS, and
   // OnPolicyServiceInitialized() will be invoked.
   // Subsequent calls to SetReady() are ignored.
   schema_registry_->SetReady(policy::POLICY_DOMAIN_EXTENSIONS);
 }
 
 ManagedValueStoreCache::ManagedValueStoreCache(
     BrowserContext* context,
     const scoped_refptr<SettingsStorageFactory>& factory,
     const scoped_refptr<SettingsObserverList>& observers)
     : profile_(Profile::FromBrowserContext(context)),
       policy_service_(policy::ProfilePolicyConnectorFactory::GetForProfile(
                           profile_)->policy_service()),
       storage_factory_(factory),
       observers_(observers),
       base_path_(profile_->GetPath().AppendASCII(
           extensions::kManagedSettingsDirectoryName)) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   policy_service_->AddObserver(policy::POLICY_DOMAIN_EXTENSIONS, this);
 
   extension_tracker_.reset(new ExtensionTracker(profile_));
 
   if (policy_service_->IsInitializationComplete(
           policy::POLICY_DOMAIN_EXTENSIONS)) {
     OnPolicyServiceInitialized(policy::POLICY_DOMAIN_EXTENSIONS);
   }
 }
 
 ManagedValueStoreCache::~ManagedValueStoreCache() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   // Delete the PolicyValueStores on FILE.
   store_map_.clear();
 }
 
 void ManagedValueStoreCache::ShutdownOnUI() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   policy_service_->RemoveObserver(policy::POLICY_DOMAIN_EXTENSIONS, this);
   extension_tracker_.reset();
 }
 
 void ManagedValueStoreCache::RunWithValueStoreForExtension(
     const StorageCallback& callback,
     scoped_refptr<const Extension> extension) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   callback.Run(GetStoreFor(extension->id()));
 }
 
 void ManagedValueStoreCache::DeleteStorageSoon(
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   // It's possible that the store exists, but hasn't been loaded yet
   // (because the extension is unloaded, for example). Open the database to
   // clear it if it exists.
   if (!HasStore(extension_id))
     return;
   GetStoreFor(extension_id)->DeleteStorage();
   store_map_.erase(extension_id);
 }
 
 void ManagedValueStoreCache::OnPolicyServiceInitialized(
     policy::PolicyDomain domain) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (domain != policy::POLICY_DOMAIN_EXTENSIONS)
     return;
 
   // The PolicyService now has all the initial policies ready. Send policy
   // for all the managed extensions to their backing stores now.
   policy::SchemaRegistry* registry =
       policy::SchemaRegistryServiceFactory::GetForContext(profile_);
   const policy::ComponentMap* map = registry->schema_map()->GetComponents(
       policy::POLICY_DOMAIN_EXTENSIONS);
   if (!map)
     return;
 
   const policy::PolicyMap empty_map;
   for (policy::ComponentMap::const_iterator it = map->begin();
        it != map->end(); ++it) {
     const policy::PolicyNamespace ns(policy::POLICY_DOMAIN_EXTENSIONS,
                                      it->first);
     // If there is no policy for |ns| then this will clear the previous store,
     // if there is one.
     OnPolicyUpdated(ns, empty_map, policy_service_->GetPolicies(ns));
   }
 }
 
 void ManagedValueStoreCache::OnPolicyUpdated(const policy::PolicyNamespace& ns,
                                              const policy::PolicyMap& previous,
                                              const policy::PolicyMap& current) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!policy_service_->IsInitializationComplete(
            policy::POLICY_DOMAIN_EXTENSIONS)) {
     // OnPolicyUpdated is called whenever a policy changes, but it doesn't
     // mean that all the policy providers are ready; wait until we get the
     // final policy values before passing them to the store.
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ManagedValueStoreCache::UpdatePolicyOnFILE,
                  base::Unretained(this),
                  ns.component_id,
                  base::Passed(current.DeepCopy())));
 }
 
 void ManagedValueStoreCache::UpdatePolicyOnFILE(
     const std::string& extension_id,
     scoped_ptr<policy::PolicyMap> current_policy) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   if (!HasStore(extension_id) && current_policy->empty()) {
     // Don't create the store now if there are no policies configured for this
     // extension. If the extension uses the storage.managed API then the store
     // will be created at RunWithValueStoreForExtension().
     return;
   }
 
   GetStoreFor(extension_id)->SetCurrentPolicy(*current_policy);
 }
 
 PolicyValueStore* ManagedValueStoreCache::GetStoreFor(
     const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   PolicyValueStoreMap::iterator it = store_map_.find(extension_id);
   if (it != store_map_.end())
     return it->second.get();
 
   // Create the store now, and serve the cached policy until the PolicyService
   // sends updated values.
   PolicyValueStore* store = new PolicyValueStore(
       extension_id,
       observers_,
       make_scoped_ptr(storage_factory_->Create(base_path_, extension_id)));
   store_map_[extension_id] = make_linked_ptr(store);
 
   return store;
 }
 
 bool ManagedValueStoreCache::HasStore(const std::string& extension_id) const {
   // TODO(joaodasilva): move this check to a ValueStore method.
   return base::DirectoryExists(base_path_.AppendASCII(extension_id));
 }
 
 }  // namespace extensions