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

extensions/browser/api/api_resource_manager.h

 // Copyright 2014 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.
 
 #ifndef EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_
 #define EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_
 
 #include <map>
 
 #include "base/containers/hash_tables.h"
@@ skipping 158 matching lines @@
   class ApiResourceData : public base::RefCountedThreadSafe<ApiResourceData> {
    public:
     typedef std::map<int, linked_ptr<T> > ApiResourceMap;
     // Lookup map from extension id's to allocated resource id's.
     typedef std::map<std::string, base::hash_set<int> > ExtensionToResourceMap;
 
     explicit ApiResourceData(const content::BrowserThread::ID thread_id)
         : next_id_(1), thread_id_(thread_id) {}
 
     int Add(T* api_resource) {
-      DCHECK(content::BrowserThread::CurrentlyOn(thread_id_));
+      DCHECK_CURRENTLY_ON(thread_id_);
       int id = GenerateId();
       if (id > 0) {
         linked_ptr<T> resource_ptr(api_resource);
         api_resource_map_[id] = resource_ptr;
 
         const std::string& extension_id = api_resource->owner_extension_id();
         if (extension_resource_map_.find(extension_id) ==
             extension_resource_map_.end()) {
           extension_resource_map_[extension_id] = base::hash_set<int>();
         }
         extension_resource_map_[extension_id].insert(id);
 
         return id;
       }
       return 0;
     }
 
     void Remove(const std::string& extension_id, int api_resource_id) {
-      DCHECK(content::BrowserThread::CurrentlyOn(thread_id_));
+      DCHECK_CURRENTLY_ON(thread_id_);
       if (GetOwnedResource(extension_id, api_resource_id) != NULL) {
         DCHECK(extension_resource_map_.find(extension_id) !=
                extension_resource_map_.end());
         extension_resource_map_[extension_id].erase(api_resource_id);
         api_resource_map_.erase(api_resource_id);
       }
     }
 
     T* Get(const std::string& extension_id, int api_resource_id) {
-      DCHECK(content::BrowserThread::CurrentlyOn(thread_id_));
+      DCHECK_CURRENTLY_ON(thread_id_);
       return GetOwnedResource(extension_id, api_resource_id);
     }
 
     base::hash_set<int>* GetResourceIds(const std::string& extension_id) {
-      DCHECK(content::BrowserThread::CurrentlyOn(thread_id_));
+      DCHECK_CURRENTLY_ON(thread_id_);
       return GetOwnedResourceIds(extension_id);
     }
 
     void InitiateExtensionUnloadedCleanup(const std::string& extension_id) {
       content::BrowserThread::PostTask(
           thread_id_,
           FROM_HERE,
           base::Bind(&ApiResourceData::CleanupResourcesFromUnloadedExtension,
                      this,
                      extension_id));
@@ skipping 20 matching lines @@
 
     T* GetOwnedResource(const std::string& extension_id, int api_resource_id) {
       linked_ptr<T> ptr = api_resource_map_[api_resource_id];
       T* resource = ptr.get();
       if (resource && extension_id == resource->owner_extension_id())
         return resource;
       return NULL;
     }
 
     base::hash_set<int>* GetOwnedResourceIds(const std::string& extension_id) {
-      DCHECK(content::BrowserThread::CurrentlyOn(thread_id_));
+      DCHECK_CURRENTLY_ON(thread_id_);
       if (extension_resource_map_.find(extension_id) ==
           extension_resource_map_.end())
         return NULL;
 
       return &extension_resource_map_[extension_id];
     }
 
     void CleanupResourcesFromUnloadedExtension(
         const std::string& extension_id) {
       CleanupResourcesFromExtension(extension_id, true);
     }
 
     void CleanupResourcesFromSuspendedExtension(
         const std::string& extension_id) {
       CleanupResourcesFromExtension(extension_id, false);
     }
 
     void CleanupResourcesFromExtension(const std::string& extension_id,
                                        bool remove_all) {
-      DCHECK(content::BrowserThread::CurrentlyOn(thread_id_));
+      DCHECK_CURRENTLY_ON(thread_id_);
 
       if (extension_resource_map_.find(extension_id) ==
           extension_resource_map_.end()) {
         return;
       }
 
       // Remove all resources, or the non persistent ones only if |remove_all|
       // is false.
       base::hash_set<int>& resource_ids = extension_resource_map_[extension_id];
       for (base::hash_set<int>::iterator it = resource_ids.begin();
@@ skipping 15 matching lines @@
         }
       }  // end for
 
       // Remove extension entry if we removed all its resources.
       if (resource_ids.size() == 0) {
         extension_resource_map_.erase(extension_id);
       }
     }
 
     void Cleanup() {
-      DCHECK(content::BrowserThread::CurrentlyOn(thread_id_));
+      DCHECK_CURRENTLY_ON(thread_id_);
 
       api_resource_map_.clear();
       extension_resource_map_.clear();
     }
 
     int GenerateId() { return next_id_++; }
 
     int next_id_;
     const content::BrowserThread::ID thread_id_;
     ApiResourceMap api_resource_map_;
     ExtensionToResourceMap extension_resource_map_;
   };
 
   content::BrowserThread::ID thread_id_;
   content::NotificationRegistrar registrar_;
   scoped_refptr<ApiResourceData> data_;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_