favor DCHECK_CURRENTLY_ON for better logs in chrome/browser/chromeos/

chrome/browser/chromeos/fileapi/external_file_url_request_job.cc

 // 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.
 
 #include "chrome/browser/chromeos/fileapi/external_file_url_request_job.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 223 matching lines @@
 
   // Check if the entry has a redirect URL.
   file_system_context_->external_backend()->GetRedirectURLForContents(
       file_system_url_,
       base::Bind(&ExternalFileURLRequestJob::OnRedirectURLObtained,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ExternalFileURLRequestJob::OnRedirectURLObtained(
     const GURL& redirect_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   redirect_url_ = redirect_url;
   if (!redirect_url_.is_empty()) {
     NotifyHeadersComplete();
     return;
   }
 
   // Obtain file system context.
   file_system_context_->operation_runner()->GetMetadata(
       file_system_url_,
       base::Bind(&ExternalFileURLRequestJob::OnFileInfoObtained,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ExternalFileURLRequestJob::OnFileInfoObtained(
     base::File::Error result,
     const base::File::Info& file_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (result == base::File::FILE_ERROR_NOT_FOUND) {
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_FILE_NOT_FOUND));
     return;
   }
 
   if (result != base::File::FILE_OK || file_info.is_directory ||
       file_info.size < 0) {
     NotifyStartError(
@@ skipping 19 matching lines @@
   if (!stream_reader_) {
     NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                            net::ERR_FILE_NOT_FOUND));
     return;
   }
 
   NotifyHeadersComplete();
 }
 
 void ExternalFileURLRequestJob::Kill() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   stream_reader_.reset();
   isolated_file_system_scope_.reset();
   file_system_context_ = NULL;
   net::URLRequestJob::Kill();
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 bool ExternalFileURLRequestJob::GetMimeType(std::string* mime_type) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   mime_type->assign(mime_type_);
   return !mime_type->empty();
 }
 
 bool ExternalFileURLRequestJob::IsRedirectResponse(GURL* location,
                                                    int* http_status_code) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (redirect_url_.is_empty())
     return false;
 
   // Redirect a hosted document.
   *location = redirect_url_;
   const int kHttpFound = 302;
   *http_status_code = kHttpFound;
   return true;
 }
 
 bool ExternalFileURLRequestJob::ReadRawData(net::IOBuffer* buf,
                                             int buf_size,
                                             int* bytes_read) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(stream_reader_);
 
   if (remaining_bytes_ == 0) {
     *bytes_read = 0;
     return true;
   }
 
   const int result = stream_reader_->Read(
       buf,
       std::min<int64>(buf_size, remaining_bytes_),
@@ skipping 14 matching lines @@
   // Reading has been finished immediately.
   *bytes_read = result;
   remaining_bytes_ -= result;
   return true;
 }
 
 ExternalFileURLRequestJob::~ExternalFileURLRequestJob() {
 }
 
 void ExternalFileURLRequestJob::OnReadCompleted(int read_result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (read_result < 0) {
     DCHECK_NE(read_result, net::ERR_IO_PENDING);
     NotifyDone(
         net::URLRequestStatus(net::URLRequestStatus::FAILED, read_result));
   }
 
   remaining_bytes_ -= read_result;
   SetStatus(net::URLRequestStatus());  // Clear the IO_PENDING status.
   NotifyReadComplete(read_result);
 }
 
 }  // namespace chromeos