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

chrome/browser/chromeos/drive/drive_file_stream_reader.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/chromeos/drive/drive_file_stream_reader.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/callback_helpers.h"
@@ skipping 78 matching lines @@
   return offset;
 }
 
 }  // namespace
 
 LocalReaderProxy::LocalReaderProxy(
     scoped_ptr<util::LocalFileReader> file_reader, int64 length)
     : file_reader_(file_reader.Pass()),
       remaining_length_(length),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(file_reader_);
 }
 
 LocalReaderProxy::~LocalReaderProxy() {
 }
 
 int LocalReaderProxy::Read(net::IOBuffer* buffer, int buffer_length,
                            const net::CompletionCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(file_reader_);
 
   if (buffer_length > remaining_length_) {
     // Here, narrowing is safe.
     buffer_length = static_cast<int>(remaining_length_);
   }
 
   if (!buffer_length)
     return 0;
 
   file_reader_->Read(buffer, buffer_length,
                      base::Bind(&LocalReaderProxy::OnReadCompleted,
                                 weak_ptr_factory_.GetWeakPtr(), callback));
   return net::ERR_IO_PENDING;
 }
 
 void LocalReaderProxy::OnGetContent(scoped_ptr<std::string> data) {
   // This method should never be called, because no data should be received
   // from the network during the reading of local-cache file.
   NOTREACHED();
 }
 
 void LocalReaderProxy::OnCompleted(FileError error) {
   // If this method is called, no network error should be happened.
   DCHECK_EQ(FILE_ERROR_OK, error);
 }
 
 void LocalReaderProxy::OnReadCompleted(const net::CompletionCallback& callback,
                                        int read_result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(file_reader_);
 
   if (read_result >= 0) {
     // |read_result| bytes data is read.
     DCHECK_LE(read_result, remaining_length_);
     remaining_length_ -= read_result;
   } else {
     // An error occurs. Close the |file_reader_|.
     file_reader_.reset();
   }
   callback.Run(read_result);
 }
 
 NetworkReaderProxy::NetworkReaderProxy(
     int64 offset,
     int64 content_length,
     int64 full_content_length,
     const base::Closure& job_canceller)
     : remaining_offset_(offset),
       remaining_content_length_(content_length),
       is_full_download_(offset + content_length == full_content_length),
       error_code_(net::OK),
       buffer_length_(0),
       job_canceller_(job_canceller) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 NetworkReaderProxy::~NetworkReaderProxy() {
   if (!job_canceller_.is_null()) {
     job_canceller_.Run();
   }
 }
 
 int NetworkReaderProxy::Read(net::IOBuffer* buffer, int buffer_length,
                              const net::CompletionCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Check if there is no pending Read operation.
   DCHECK(!buffer_.get());
   DCHECK_EQ(buffer_length_, 0);
   DCHECK(callback_.is_null());
   // Validate the arguments.
   DCHECK(buffer);
   DCHECK_GT(buffer_length, 0);
   DCHECK(!callback.is_null());
 
   if (error_code_ != net::OK) {
@@ skipping 26 matching lines @@
   // Although OnCompleted() should reset |job_canceller_| when download is done,
   // due to timing issues the ReaderProxy instance may be destructed before the
   // notification. To fix the case we reset here earlier.
   if (is_full_download_ && remaining_content_length_ == 0)
     job_canceller_.Reset();
 
   return result;
 }
 
 void NetworkReaderProxy::OnGetContent(scoped_ptr<std::string> data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(data && !data->empty());
 
   if (remaining_offset_ >= static_cast<int64>(data->length())) {
     // Skip unneeded leading data.
     remaining_offset_ -= data->length();
     return;
   }
 
   if (remaining_offset_ > 0) {
     // Erase unnecessary leading bytes.
@@ skipping 14 matching lines @@
   if (is_full_download_ && remaining_content_length_ == 0)
     job_canceller_.Reset();
 
   buffer_ = NULL;
   buffer_length_ = 0;
   DCHECK(!callback_.is_null());
   base::ResetAndReturn(&callback_).Run(result);
 }
 
 void NetworkReaderProxy::OnCompleted(FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // The downloading is completed, so we do not need to cancel the job
   // in the destructor.
   job_canceller_.Reset();
 
   if (error == FILE_ERROR_OK) {
     return;
   }
 
   error_code_ = FileErrorToNetError(error);
   pending_data_.clear();
@@ skipping 14 matching lines @@
 
 // Calls FileSystemInterface::GetFileContent if the file system
 // is available. If not, the |completion_callback| is invoked with
 // FILE_ERROR_FAILED.
 base::Closure GetFileContentOnUIThread(
     const DriveFileStreamReader::FileSystemGetter& file_system_getter,
     const base::FilePath& drive_file_path,
     const GetFileContentInitializedCallback& initialized_callback,
     const google_apis::GetContentCallback& get_content_callback,
     const FileOperationCallback& completion_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   FileSystemInterface* file_system = file_system_getter.Run();
   if (!file_system) {
     completion_callback.Run(FILE_ERROR_FAILED);
     return base::Closure();
   }
 
   return google_apis::CreateRelayCallback(
       file_system->GetFileContent(drive_file_path,
                                   initialized_callback,
                                   get_content_callback,
                                   completion_callback));
 }
 
 // Helper to run FileSystemInterface::GetFileContent on UI thread.
 void GetFileContent(
     const DriveFileStreamReader::FileSystemGetter& file_system_getter,
     const base::FilePath& drive_file_path,
     const GetFileContentInitializedCallback& initialized_callback,
     const google_apis::GetContentCallback& get_content_callback,
     const FileOperationCallback& completion_callback,
     const base::Callback<void(const base::Closure&)>& reply_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GetFileContentOnUIThread,
                  file_system_getter,
                  drive_file_path,
                  google_apis::CreateRelayCallback(initialized_callback),
                  google_apis::CreateRelayCallback(get_content_callback),
                  google_apis::CreateRelayCallback(completion_callback)),
       reply_callback);
 }
 
 }  // namespace
 
 DriveFileStreamReader::DriveFileStreamReader(
     const FileSystemGetter& file_system_getter,
     base::SequencedTaskRunner* file_task_runner)
     : file_system_getter_(file_system_getter),
       file_task_runner_(file_task_runner),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 DriveFileStreamReader::~DriveFileStreamReader() {
 }
 
 bool DriveFileStreamReader::IsInitialized() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return reader_proxy_.get() != NULL;
 }
 
 void DriveFileStreamReader::Initialize(
     const base::FilePath& drive_file_path,
     const net::HttpByteRange& byte_range,
     const InitializeCompletionCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!callback.is_null());
 
   GetFileContent(
       file_system_getter_,
       drive_file_path,
       base::Bind(&DriveFileStreamReader
                      ::InitializeAfterGetFileContentInitialized,
                  weak_ptr_factory_.GetWeakPtr(),
                  byte_range,
                  callback),
       base::Bind(&DriveFileStreamReader::OnGetContent,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&DriveFileStreamReader::OnGetFileContentCompletion,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback),
       base::Bind(&DriveFileStreamReader::StoreCancelDownloadClosure,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 int DriveFileStreamReader::Read(net::IOBuffer* buffer, int buffer_length,
                                 const net::CompletionCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(reader_proxy_);
   DCHECK(buffer);
   DCHECK(!callback.is_null());
   return reader_proxy_->Read(buffer, buffer_length, callback);
 }
 
 void DriveFileStreamReader::StoreCancelDownloadClosure(
     const base::Closure& cancel_download_closure) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   cancel_download_closure_ = cancel_download_closure;
 }
 
 void DriveFileStreamReader::InitializeAfterGetFileContentInitialized(
     const net::HttpByteRange& byte_range,
     const InitializeCompletionCallback& callback,
     FileError error,
     const base::FilePath& local_cache_file_path,
     scoped_ptr<ResourceEntry> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // StoreCancelDownloadClosure() should be called before this function.
   DCHECK(!cancel_download_closure_.is_null());
 
   if (error != FILE_ERROR_OK) {
     callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
     return;
   }
   DCHECK(entry);
 
   int64 range_start = 0, range_length = 0;
@@ skipping 35 matching lines @@
           base::Passed(&entry),
           base::Passed(&file_reader)));
 }
 
 void DriveFileStreamReader::InitializeAfterLocalFileOpen(
     int64 length,
     const InitializeCompletionCallback& callback,
     scoped_ptr<ResourceEntry> entry,
     scoped_ptr<util::LocalFileReader> file_reader,
     int open_result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (open_result != net::OK) {
     callback.Run(net::ERR_FAILED, scoped_ptr<ResourceEntry>());
     return;
   }
 
   reader_proxy_.reset(
       new internal::LocalReaderProxy(file_reader.Pass(), length));
   callback.Run(net::OK, entry.Pass());
 }
 
 void DriveFileStreamReader::OnGetContent(
     google_apis::DriveApiErrorCode error_code,
     scoped_ptr<std::string> data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(reader_proxy_);
   reader_proxy_->OnGetContent(data.Pass());
 }
 
 void DriveFileStreamReader::OnGetFileContentCompletion(
     const InitializeCompletionCallback& callback,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (reader_proxy_) {
     // If the proxy object available, send the error to it.
     reader_proxy_->OnCompleted(error);
   } else {
     // Here the proxy object is not yet available.
     // There are two cases. 1) Some error happens during the initialization.
     // 2) the cache file is found, but the proxy object is not *yet*
     // initialized because the file is being opened.
     // We are interested in 1) only. The callback for 2) will be called
     // after opening the file is completed.
     // Note: due to the same reason, LocalReaderProxy::OnCompleted may
     // or may not be called. This is timing issue, and it is difficult to avoid
     // unfortunately.
     if (error != FILE_ERROR_OK) {
       callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
     }
   }
 }
 
 }  // namespace drive