favor DCHECK_CURRENTLY_ON for better logs in content/browser/[a-d]*

content/browser/download/download_resource_handler.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 "content/browser/download/download_resource_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 28 matching lines @@
   GURL tab_url;
   GURL tab_referrer_url;
 };
 
 namespace {
 
 void CallStartedCBOnUIThread(
     const DownloadUrlParameters::OnStartedCallback& started_cb,
     DownloadItem* item,
     DownloadInterruptReason interrupt_reason) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (started_cb.is_null())
     return;
   started_cb.Run(item, interrupt_reason);
 }
 
 // Static function in order to prevent any accidental accesses to
 // DownloadResourceHandler members from the UI thread.
 static void StartOnUIThread(
     scoped_ptr<DownloadCreateInfo> info,
     DownloadResourceHandler::DownloadTabInfo* tab_info,
     scoped_ptr<ByteStreamReader> stream,
     const DownloadUrlParameters::OnStartedCallback& started_cb) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DownloadManager* download_manager = info->request_handle.GetDownloadManager();
   if (!download_manager) {
     // NULL in unittests or if the page closed right after starting the
     // download.
     if (!started_cb.is_null())
       started_cb.Run(NULL, DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
 
     // |stream| gets deleted on non-FILE thread, but it's ok since
     // we're not using stream_writer_ yet.
 
     return;
   }
 
   info->tab_url = tab_info->tab_url;
   info->tab_referrer_url = tab_info->tab_referrer_url;
 
   download_manager->StartDownload(info.Pass(), stream.Pass(), started_cb);
 }
 
 void InitializeDownloadTabInfoOnUIThread(
     const DownloadRequestHandle& request_handle,
     DownloadResourceHandler::DownloadTabInfo* tab_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   WebContents* web_contents = request_handle.GetWebContents();
   if (web_contents) {
     NavigationEntry* entry = web_contents->GetController().GetVisibleEntry();
     if (entry) {
       tab_info->tab_url = entry->GetURL();
       tab_info->tab_referrer_url = entry->GetReferrer().url;
     }
   }
 }
@@ skipping 45 matching lines @@
     const net::RedirectInfo& redirect_info,
     ResourceResponse* response,
     bool* defer) {
   return true;
 }
 
 // Send the download creation information to the download thread.
 bool DownloadResourceHandler::OnResponseStarted(
     ResourceResponse* response,
     bool* defer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // There can be only one (call)
   DCHECK(!on_response_started_called_);
   on_response_started_called_ = true;
 
   DVLOG(20) << __FUNCTION__ << "()" << DebugString();
   download_start_time_ = base::TimeTicks::Now();
 
   // If it's a download, we don't want to poison the cache with it.
   request()->StopCaching();
 
@@ skipping 89 matching lines @@
   tab_info_ = NULL;
   // Guaranteed to be called in StartOnUIThread
   started_cb_.Reset();
 
   return true;
 }
 
 void DownloadResourceHandler::CallStartedCB(
     DownloadItem* item,
     DownloadInterruptReason interrupt_reason) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (started_cb_.is_null())
     return;
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
           &CallStartedCBOnUIThread, started_cb_, item, interrupt_reason));
   started_cb_.Reset();
 }
 
 bool DownloadResourceHandler::OnWillStart(const GURL& url, bool* defer) {
   return true;
 }
 
 bool DownloadResourceHandler::OnBeforeNetworkStart(const GURL& url,
                                                    bool* defer) {
   return true;
 }
 
 // Create a new buffer, which will be handed to the download thread for file
 // writing and deletion.
 bool DownloadResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                          int* buf_size,
                                          int min_size) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(buf && buf_size);
   DCHECK(!read_buffer_.get());
 
   *buf_size = min_size < 0 ? kReadBufSize : min_size;
   last_buffer_size_ = *buf_size;
   read_buffer_ = new net::IOBuffer(*buf_size);
   *buf = read_buffer_.get();
   return true;
 }
 
 // Pass the buffer to the download file writer.
 bool DownloadResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(read_buffer_.get());
 
   base::TimeTicks now(base::TimeTicks::Now());
   if (!last_read_time_.is_null()) {
     double seconds_since_last_read = (now - last_read_time_).InSecondsF();
     if (now == last_read_time_)
       // Use 1/10 ms as a "very small number" so that we avoid
       // divide-by-zero error and still record a very high potential bandwidth.
       seconds_since_last_read = 0.00001;
 
@@ skipping 21 matching lines @@
   if (pause_count_ > 0)
     *defer = was_deferred_ = true;
 
   return true;
 }
 
 void DownloadResourceHandler::OnResponseCompleted(
     const net::URLRequestStatus& status,
     const std::string& security_info,
     bool* defer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int response_code = status.is_success() ? request()->GetResponseCode() : 0;
   DVLOG(20) << __FUNCTION__ << "()" << DebugString()
             << " status.status() = " << status.status()
             << " status.error() = " << status.error()
             << " response_code = " << response_code;
 
   net::Error error_code = net::OK;
   if (status.status() == net::URLRequestStatus::FAILED ||
       // Note cancels as failures too.
       status.status() == net::URLRequestStatus::CANCELED) {
@@ skipping 102 matching lines @@
 
   stream_writer_.reset();  // We no longer need the stream.
   read_buffer_ = NULL;
 }
 
 void DownloadResourceHandler::OnDataDownloaded(int bytes_downloaded) {
   NOTREACHED();
 }
 
 void DownloadResourceHandler::PauseRequest() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ++pause_count_;
 }
 
 void DownloadResourceHandler::ResumeRequest() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_LT(0, pause_count_);
 
   --pause_count_;
 
   if (!was_deferred_)
     return;
   if (pause_count_ > 0)
     return;
 
   was_deferred_ = false;
   if (!last_stream_pause_time_.is_null()) {
     total_pause_time_ += (base::TimeTicks::Now() - last_stream_pause_time_);
     last_stream_pause_time_ = base::TimeTicks();
   }
 
   controller()->Resume();
 }
 
 void DownloadResourceHandler::CancelRequest() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const ResourceRequestInfo* info = GetRequestInfo();
   ResourceDispatcherHostImpl::Get()->CancelRequest(
       info->GetChildID(),
       info->GetRequestID());
   // This object has been deleted.
 }
 
 std::string DownloadResourceHandler::DebugString() const {
   const ResourceRequestInfo* info = GetRequestInfo();
   return base::StringPrintf("{"
                             " url_ = " "\"%s\""
                             " info = {"
                             " child_id = " "%d"
                             " request_id = " "%d"
                             " route_id = " "%d"
                             " }"
                             " }",
                             request() ?
                                 request()->url().spec().c_str() :
                                 "<NULL request>",
                             info->GetChildID(),
                             info->GetRequestID(),
                             info->GetRouteID());
 }
 
 DownloadResourceHandler::~DownloadResourceHandler() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // This won't do anything if the callback was called before.
   // If it goes through, it will likely be because OnWillStart() returned
   // false somewhere in the chain of resource handlers.
   CallStartedCB(NULL, DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED);
 
   // Remove output stream callback if a stream exists.
   if (stream_writer_)
     stream_writer_->RegisterCallback(base::Closure());
 
   // tab_info_ must be destroyed on UI thread, since
   // InitializeDownloadTabInfoOnUIThread might still be using it.
   if (tab_info_)
     BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, tab_info_);
 
   UMA_HISTOGRAM_TIMES("SB2.DownloadDuration",
                       base::TimeTicks::Now() - download_start_time_);
 }
 
 }  // namespace content