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

chrome/browser/extensions/blacklist.cc

 // Copyright 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/blacklist.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 72 matching lines @@
   }
 
  private:
   friend class base::RefCountedThreadSafe<SafeBrowsingClientImpl>;
   virtual ~SafeBrowsingClientImpl() {}
 
   // Pass |database_manager| as a parameter to avoid touching
   // SafeBrowsingService on the IO thread.
   void StartCheck(scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
                   const std::set<std::string>& extension_ids) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
     if (database_manager->CheckExtensionIDs(extension_ids, this)) {
       // Definitely not blacklisted. Callback immediately.
       callback_message_loop_->PostTask(
           FROM_HERE,
           base::Bind(callback_, std::set<std::string>()));
       return;
     }
     // Something might be blacklisted, response will come in
     // OnCheckExtensionsResult.
     AddRef();  // Balanced in OnCheckExtensionsResult
   }
 
   virtual void OnCheckExtensionsResult(
       const std::set<std::string>& hits) OVERRIDE {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
     callback_message_loop_->PostTask(FROM_HERE, base::Bind(callback_, hits));
     Release();  // Balanced in StartCheck.
   }
 
   scoped_refptr<base::MessageLoopProxy> callback_message_loop_;
   OnResultCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingClientImpl);
 };
 
@@ skipping 58 matching lines @@
     if (!prefs->GetInstalledExtensionInfo(*it))
       prefs->DeleteExtensionPrefs(*it);
   }
 }
 
 Blacklist::~Blacklist() {
 }
 
 void Blacklist::GetBlacklistedIDs(const std::set<std::string>& ids,
                                   const GetBlacklistedIDsCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (ids.empty() || !g_database_manager.Get().get().get()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, BlacklistStateMap()));
     return;
   }
 
   // Constructing the SafeBrowsingClientImpl begins the process of asking
   // safebrowsing for the blacklisted extensions. The set of blacklisted
   // extensions returned by SafeBrowsing will then be passed to
@@ skipping 13 matching lines @@
 void Blacklist::IsBlacklisted(const std::string& extension_id,
                               const IsBlacklistedCallback& callback) {
   std::set<std::string> check;
   check.insert(extension_id);
   GetBlacklistedIDs(check, base::Bind(&CheckOneExtensionState, callback));
 }
 
 void Blacklist::GetBlacklistStateForIDs(
     const GetBlacklistedIDsCallback& callback,
     const std::set<std::string>& blacklisted_ids) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::set<std::string> ids_unknown_state;
   BlacklistStateMap extensions_state;
   for (std::set<std::string>::const_iterator it = blacklisted_ids.begin();
        it != blacklisted_ids.end(); ++it) {
     BlacklistStateMap::const_iterator cache_it =
         blacklist_state_cache_.find(*it);
     if (cache_it == blacklist_state_cache_.end() ||
         cache_it->second == BLACKLISTED_UNKNOWN)  // Do not return UNKNOWN
                                                   // from cache, retry request.
@@ skipping 28 matching lines @@
       extensions_state[*it] = cache_it->second;
     // If for some reason we still haven't cached the state of this extension,
     // we silently skip it.
   }
 
   callback.Run(extensions_state);
 }
 
 void Blacklist::RequestExtensionsBlacklistState(
     const std::set<std::string>& ids, const base::Callback<void()>& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!state_fetcher_)
     state_fetcher_.reset(new BlacklistStateFetcher());
 
   state_requests_.push_back(
       make_pair(std::vector<std::string>(ids.begin(), ids.end()), callback));
   for (std::set<std::string>::const_iterator it = ids.begin();
        it != ids.end();
        ++it) {
     state_fetcher_->Request(
         *it,
         base::Bind(&Blacklist::OnBlacklistStateReceived, AsWeakPtr(), *it));
   }
 }
 
 void Blacklist::OnBlacklistStateReceived(const std::string& id,
                                          BlacklistState state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   blacklist_state_cache_[id] = state;
 
   // Go through the opened requests and call the callbacks for those requests
   // for which we already got all the required blacklist states.
   StateRequestsList::iterator requests_it = state_requests_.begin();
   while (requests_it != state_requests_.end()) {
     const std::vector<std::string>& ids = requests_it->first;
 
     bool have_all_in_cache = true;
     for (std::vector<std::string>::const_iterator ids_it = ids.begin();
@@ skipping 17 matching lines @@
 void Blacklist::SetBlacklistStateFetcherForTest(
     BlacklistStateFetcher* fetcher) {
   state_fetcher_.reset(fetcher);
 }
 
 BlacklistStateFetcher* Blacklist::ResetBlacklistStateFetcherForTest() {
   return state_fetcher_.release();
 }
 
 void Blacklist::AddObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.AddObserver(observer);
 }
 
 void Blacklist::RemoveObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observers_.RemoveObserver(observer);
 }
 
 // static
 void Blacklist::SetDatabaseManager(
     scoped_refptr<SafeBrowsingDatabaseManager> database_manager) {
   g_database_manager.Get().set(database_manager);
 }
 
 // static
 scoped_refptr<SafeBrowsingDatabaseManager> Blacklist::GetDatabaseManager() {
   return g_database_manager.Get().get();
 }
 
 void Blacklist::Observe(int type,
                         const content::NotificationSource& source,
                         const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_SAFE_BROWSING_UPDATE_COMPLETE, type);
   FOR_EACH_OBSERVER(Observer, observers_, OnBlacklistUpdated());
 }
 
 }  // namespace extensions