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

chrome/browser/extensions/blacklist_state_fetcher.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/blacklist_state_fetcher.h"
 
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/safe_browsing/protocol_manager_helper.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/safe_browsing/crx_info.pb.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 
 namespace {
 
 class BlacklistRequestContextGetter : public net::URLRequestContextGetter {
  public:
   explicit BlacklistRequestContextGetter(
       net::URLRequestContextGetter* parent_context_getter) :
           network_task_runner_(
               BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
     url_request_context_.reset(new net::URLRequestContext());
     url_request_context_->CopyFrom(
         parent_context_getter->GetURLRequestContext());
   }
 
   static void Create(
       scoped_refptr<net::URLRequestContextGetter> parent_context_getter,
       base::Callback<void(scoped_refptr<net::URLRequestContextGetter>)>
           callback) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     scoped_refptr<net::URLRequestContextGetter> context_getter =
         new BlacklistRequestContextGetter(parent_context_getter);
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(callback, context_getter));
   }
 
   virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
     return url_request_context_.get();
   }
 
   virtual scoped_refptr<base::SingleThreadTaskRunner> GetNetworkTaskRunner()
       const OVERRIDE {
     return network_task_runner_;
   }
 
  protected:
   virtual ~BlacklistRequestContextGetter() {
     url_request_context_->AssertNoURLRequests();
   }
 
  private:
   scoped_ptr<net::URLRequestContext> url_request_context_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 };
 
 }  // namespace
 
 namespace extensions {
 
 BlacklistStateFetcher::BlacklistStateFetcher()
     : url_fetcher_id_(0),
       weak_ptr_factory_(this) {}
 
 BlacklistStateFetcher::~BlacklistStateFetcher() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   STLDeleteContainerPairFirstPointers(requests_.begin(), requests_.end());
   requests_.clear();
 }
 
 void BlacklistStateFetcher::Request(const std::string& id,
                                     const RequestCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!safe_browsing_config_) {
     if (g_browser_process && g_browser_process->safe_browsing_service()) {
       SetSafeBrowsingConfig(
           g_browser_process->safe_browsing_service()->GetProtocolConfig());
     } else {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE, base::Bind(callback, BLACKLISTED_UNKNOWN));
       return;
     }
   }
@@ skipping 21 matching lines @@
                    parent_request_context,
                    base::Bind(&BlacklistStateFetcher::SaveRequestContext,
                               weak_ptr_factory_.GetWeakPtr(),
                               id)));
   }
 }
 
 void BlacklistStateFetcher::SaveRequestContext(
     const std::string& id,
     scoped_refptr<net::URLRequestContextGetter> request_context_getter) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!url_request_context_getter_)
     url_request_context_getter_ = request_context_getter;
   SendRequest(id);
 }
 
 void BlacklistStateFetcher::SendRequest(const std::string& id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ClientCRXListInfoRequest request;
   request.set_id(id);
   std::string request_str;
   request.SerializeToString(&request_str);
 
   GURL request_url = RequestUrl();
   net::URLFetcher* fetcher = net::URLFetcher::Create(url_fetcher_id_++,
                                                      request_url,
                                                      net::URLFetcher::POST,
@@ skipping 24 matching lines @@
       safe_browsing_config_->version.c_str());
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty()) {
     base::StringAppendF(&url, "&key=%s",
                         net::EscapeQueryParamValue(api_key, true).c_str());
   }
   return GURL(url);
 }
 
 void BlacklistStateFetcher::OnURLFetchComplete(const net::URLFetcher* source) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::map<const net::URLFetcher*, std::string>::iterator it =
      requests_.find(source);
   if (it == requests_.end()) {
     NOTREACHED();
     return;
   }
 
   scoped_ptr<const net::URLFetcher> fetcher;
 
@@ skipping 30 matching lines @@
        callback_it != range.second;
        ++callback_it) {
     callback_it->second.Run(state);
   }
 
   callbacks_.erase(range.first, range.second);
 }
 
 }  // namespace extensions