[chrome/browser/download] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/download/download_request_limiter.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/download/download_request_limiter.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/download/download_permission_request.h"
@@ skipping 269 matching lines @@
 }
 
 void DownloadRequestLimiter::CanDownloadOnIOThread(
     int render_process_host_id,
     int render_view_id,
     const GURL& url,
     const std::string& request_method,
     const Callback& callback) {
   // This is invoked on the IO thread. Schedule the task to run on the UI
   // thread so that we can query UI state.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadRequestLimiter::CanDownload, this,
                  render_process_host_id, render_view_id, url,
                  request_method, callback));
 }
 
 DownloadRequestLimiter::TabDownloadState*
 DownloadRequestLimiter::GetDownloadState(
     content::WebContents* web_contents,
@@ skipping 11 matching lines @@
       new TabDownloadState(this, web_contents, originating_web_contents);
   state_map_[web_contents] = state;
   return state;
 }
 
 void DownloadRequestLimiter::CanDownload(int render_process_host_id,
                                          int render_view_id,
                                          const GURL& url,
                                          const std::string& request_method,
                                          const Callback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   content::WebContents* originating_contents =
       tab_util::GetWebContentsByID(render_process_host_id, render_view_id);
   if (!originating_contents) {
     // The WebContents was closed, don't allow the download.
     ScheduleNotification(callback, false);
     return;
   }
 
   if (!originating_contents->GetDelegate()) {
@@ skipping 17 matching lines @@
       url,
       request_method,
       can_download_callback);
 }
 
 void DownloadRequestLimiter::OnCanDownloadDecided(
     int render_process_host_id,
     int render_view_id,
     const std::string& request_method,
     const Callback& orig_callback, bool allow) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   content::WebContents* originating_contents =
       tab_util::GetWebContentsByID(render_process_host_id, render_view_id);
   if (!originating_contents || !allow) {
     ScheduleNotification(orig_callback, false);
     return;
   }
 
   CanDownloadImpl(originating_contents,
                   request_method,
                   orig_callback);
@@ skipping 86 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(callback, allow));
 }
 
 void DownloadRequestLimiter::Remove(TabDownloadState* state,
                                     content::WebContents* contents) {
   DCHECK(ContainsKey(state_map_, contents));
   state_map_.erase(contents);
   delete state;
 }