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

chrome/browser/chromeos/drive/file_system/copy_operation.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/chromeos/drive/file_system/copy_operation.h"
 
 #include <string>
 
 #include "base/task_runner_util.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
@@ skipping 270 matching lines @@
                              internal::FileCache* cache)
   : blocking_task_runner_(blocking_task_runner),
     delegate_(delegate),
     scheduler_(scheduler),
     metadata_(metadata),
     cache_(cache),
     create_file_operation_(new CreateFileOperation(blocking_task_runner,
                                                    delegate,
                                                    metadata)),
     weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 CopyOperation::~CopyOperation() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 void CopyOperation::Copy(const base::FilePath& src_file_path,
                          const base::FilePath& dest_file_path,
                          bool preserve_last_modified,
                          const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   CopyParams* params = new CopyParams;
   params->src_file_path = src_file_path;
   params->dest_file_path = dest_file_path;
   params->preserve_last_modified = preserve_last_modified;
   params->callback = callback;
 
   std::vector<std::string>* updated_local_ids = new std::vector<std::string>;
   bool* directory_changed = new bool(false);
   bool* should_copy_on_server = new bool(false);
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&TryToCopyLocally, metadata_, cache_, params,
                  updated_local_ids, directory_changed, should_copy_on_server),
       base::Bind(&CopyOperation::CopyAfterTryToCopyLocally,
                  weak_ptr_factory_.GetWeakPtr(), base::Owned(params),
                  base::Owned(updated_local_ids), base::Owned(directory_changed),
                  base::Owned(should_copy_on_server)));
 }
 
 void CopyOperation::CopyAfterTryToCopyLocally(
     const CopyParams* params,
     const std::vector<std::string>* updated_local_ids,
     const bool* directory_changed,
     const bool* should_copy_on_server,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!params->callback.is_null());
 
   for (const auto& id : *updated_local_ids) {
     // Syncing for copy should be done in background, so pass the BACKGROUND
     // context. See: crbug.com/420278.
     delegate_->OnEntryUpdatedByOperation(ClientContext(BACKGROUND), id);
   }
 
   if (*directory_changed) {
     FileChange changed_file;
@@ skipping 17 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(), *params));
     if (!waiting)
       params->callback.Run(FILE_ERROR_NOT_FOUND);
   } else {
     CopyAfterGetParentResourceId(*params, &params->parent_entry, FILE_ERROR_OK);
   }
 }
 
 void CopyOperation::CopyAfterParentSync(const CopyParams& params,
                                         FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!params.callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     params.callback.Run(error);
     return;
   }
 
   ResourceEntry* parent = new ResourceEntry;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&internal::ResourceMetadata::GetResourceEntryById,
                  base::Unretained(metadata_),
                  params.parent_entry.local_id(),
                  parent),
       base::Bind(&CopyOperation::CopyAfterGetParentResourceId,
                  weak_ptr_factory_.GetWeakPtr(),
                  params,
                  base::Owned(parent)));
 }
 
 void CopyOperation::CopyAfterGetParentResourceId(const CopyParams& params,
                                                  const ResourceEntry* parent,
                                                  FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!params.callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     params.callback.Run(error);
     return;
   }
 
   base::FilePath new_title = params.dest_file_path.BaseName();
   if (params.src_entry.file_specific_info().is_hosted_document()) {
     // Drop the document extension, which should not be in the title.
     // TODO(yoshiki): Remove this code with crbug.com/223304.
     new_title = new_title.RemoveExtension();
   }
 
   base::Time last_modified =
       params.preserve_last_modified ?
       base::Time::FromInternalValue(
           params.src_entry.file_info().last_modified()) : base::Time();
 
   CopyResourceOnServer(
       params.src_entry.resource_id(), parent->resource_id(),
       new_title.AsUTF8Unsafe(), last_modified, params.callback);
 }
 
 void CopyOperation::TransferFileFromLocalToRemote(
     const base::FilePath& local_src_path,
     const base::FilePath& remote_dest_path,
     const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   std::string* gdoc_resource_id = new std::string;
   ResourceEntry* parent_entry = new ResourceEntry;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(
           &PrepareTransferFileFromLocalToRemote,
           metadata_, local_src_path, remote_dest_path,
           gdoc_resource_id, parent_entry),
       base::Bind(
           &CopyOperation::TransferFileFromLocalToRemoteAfterPrepare,
           weak_ptr_factory_.GetWeakPtr(),
           local_src_path, remote_dest_path, callback,
           base::Owned(gdoc_resource_id), base::Owned(parent_entry)));
 }
 
 void CopyOperation::TransferFileFromLocalToRemoteAfterPrepare(
     const base::FilePath& local_src_path,
     const base::FilePath& remote_dest_path,
     const FileOperationCallback& callback,
     std::string* gdoc_resource_id,
     ResourceEntry* parent_entry,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
   }
 
   // For regular files, schedule the transfer.
   if (gdoc_resource_id->empty()) {
     ScheduleTransferRegularFile(local_src_path, remote_dest_path, callback);
@@ skipping 16 matching lines @@
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&LocalWorkForTransferJsonGdocFile, metadata_, params),
       base::Bind(&CopyOperation::TransferJsonGdocFileAfterLocalWork,
                  weak_ptr_factory_.GetWeakPtr(), base::Owned(params)));
 }
 
 void CopyOperation::TransferJsonGdocFileAfterLocalWork(
     TransferJsonGdocParams* params,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (error != FILE_ERROR_OK) {
     params->callback.Run(error);
     return;
   }
 
   switch (params->location_type) {
     // When |resource_id| is found in the local metadata and it has a specific
     // parent folder, we assume the user's intention is to copy the document and
     // thus perform the server-side copy operation.
@@ skipping 37 matching lines @@
       break;
   }
 }
 
 void CopyOperation::CopyResourceOnServer(
     const std::string& resource_id,
     const std::string& parent_resource_id,
     const std::string& new_title,
     const base::Time& last_modified,
     const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   scheduler_->CopyResource(
       resource_id, parent_resource_id, new_title, last_modified,
       base::Bind(&CopyOperation::UpdateAfterServerSideOperation,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void CopyOperation::UpdateAfterServerSideOperation(
     const FileOperationCallback& callback,
     google_apis::DriveApiErrorCode status,
     scoped_ptr<google_apis::FileResource> entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   FileError error = GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
   }
 
   ResourceEntry* resource_entry = new ResourceEntry;
 
@@ skipping 13 matching lines @@
                  callback,
                  base::Owned(file_path),
                  base::Owned(resource_entry)));
 }
 
 void CopyOperation::UpdateAfterLocalStateUpdate(
     const FileOperationCallback& callback,
     base::FilePath* file_path,
     const ResourceEntry* entry,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (error == FILE_ERROR_OK) {
     FileChange changed_file;
     changed_file.Update(*file_path, *entry, FileChange::ADD_OR_UPDATE);
     delegate_->OnFileChangedByOperation(changed_file);
   }
   callback.Run(error);
 }
 
 void CopyOperation::ScheduleTransferRegularFile(
     const base::FilePath& local_src_path,
     const base::FilePath& remote_dest_path,
     const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   create_file_operation_->CreateFile(
       remote_dest_path,
       false,  // Not exclusive (OK even if a file already exists).
       std::string(),  // no specific mime type; CreateFile should guess it.
       base::Bind(&CopyOperation::ScheduleTransferRegularFileAfterCreate,
                  weak_ptr_factory_.GetWeakPtr(),
                  local_src_path, remote_dest_path, callback));
 }
 
 void CopyOperation::ScheduleTransferRegularFileAfterCreate(
     const base::FilePath& local_src_path,
     const base::FilePath& remote_dest_path,
     const FileOperationCallback& callback,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
   }
 
   std::string* local_id = new std::string;
   ResourceEntry* entry = new ResourceEntry;
   base::PostTaskAndReplyWithResult(
@@ skipping 14 matching lines @@
           base::Owned(entry),
           base::Owned(local_id)));
 }
 
 void CopyOperation::ScheduleTransferRegularFileAfterUpdateLocalState(
     const FileOperationCallback& callback,
     const base::FilePath& remote_dest_path,
     const ResourceEntry* entry,
     std::string* local_id,
     FileError error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!callback.is_null());
 
   if (error == FILE_ERROR_OK) {
     FileChange changed_file;
     changed_file.Update(remote_dest_path, *entry, FileChange::ADD_OR_UPDATE);
     delegate_->OnFileChangedByOperation(changed_file);
     // Syncing for copy should be done in background, so pass the BACKGROUND
     // context. See: crbug.com/420278.
     delegate_->OnEntryUpdatedByOperation(ClientContext(BACKGROUND), *local_id);
   }
   callback.Run(error);
 }
 
 }  // namespace file_system
 }  // namespace drive