gdata: Make callback parameters mandatory for TransferFile functions

chrome/browser/chromeos/gdata/gdata_file_system.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/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 692 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   directory_service_->FindEntryByPathAndRunSync(search_file_path, callback);
 }
 
 void GDataFileSystem::TransferFileFromRemoteToLocal(
     const FilePath& remote_src_file_path,
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   GetFileByPath(remote_src_file_path,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForTransferFile,
                  ui_weak_ptr_,
                  local_dest_file_path,
                  callback),
       GetDownloadDataCallback());
 }
 
 void GDataFileSystem::TransferFileFromLocalToRemote(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   // Make sure the destination directory exists.
   directory_service_->GetEntryInfoByPath(
       remote_dest_file_path.DirName(),
       base::Bind(
           &GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo,
           ui_weak_ptr_,
           local_src_file_path,
           remote_dest_file_path,
           callback));
 }
 
 void GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   if (error != GDATA_FILE_OK) {
-    if (!callback.is_null()) {
-      base::MessageLoopProxy::current()->PostTask(
-          FROM_HERE, base::Bind(callback, error));
-    }
+    callback.Run(error);
     return;
   }
 
   DCHECK(entry_proto.get());
   if (!entry_proto->file_info().is_directory()) {
     // The parent of |remote_dest_file_path| is not a directory.
-    if (!callback.is_null()) {
-      base::MessageLoopProxy::current()->PostTask(
-          FROM_HERE, base::Bind(callback, GDATA_FILE_ERROR_NOT_A_DIRECTORY));
-    }
+    callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   std::string* resource_id = new std::string;
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetDocumentResourceIdOnBlockingPool,
                  local_src_file_path,
                  resource_id),
       base::Bind(&GDataFileSystem::TransferFileForResourceId,
                  ui_weak_ptr_,
                  local_src_file_path,
                  remote_dest_file_path,
                  callback,
                  base::Owned(resource_id)));
 }
 
 void GDataFileSystem::TransferFileForResourceId(
     const FilePath& local_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     std::string* resource_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(resource_id);
+  DCHECK(!callback.is_null());
 
   if (resource_id->empty()) {
     // If |resource_id| is empty, upload the local file as a regular file.
     TransferRegularFile(local_file_path, remote_dest_file_path, callback);
     return;
   }
 
   // Otherwise, copy the document on the server side and add the new copy
   // to the destination directory (collection).
   CopyDocumentToDirectory(
@@ skipping 234 matching lines @@
 }
 
 void GDataFileSystem::OnGetFileCompleteForTransferFile(
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     const FilePath& local_file_path,
     const std::string& unused_mime_type,
     GDataFileType file_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   if (error != GDATA_FILE_OK) {
-    if (!callback.is_null())
-      callback.Run(error);
-
+    callback.Run(error);
     return;
   }
 
   // GetFileByPath downloads the file from gdata to a local cache, which is then
   // copied to the actual destination path on the local file system using
   // CopyLocalFileOnBlockingPool.
   GDataFileError* copy_file_error =
       new GDataFileError(GDATA_FILE_OK);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&CopyLocalFileOnBlockingPool,
                  local_file_path,
                  local_dest_file_path,
                  copy_file_error),
       base::Bind(&RunFileOperationCallbackHelper,
                  callback,
                  base::Owned(copy_file_error)));
 }
 
 void GDataFileSystem::CopyDocumentToDirectory(
     const FilePath& dir_path,
     const std::string& resource_id,
     const FilePath::StringType& new_name,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   documents_service_->CopyDocument(resource_id, new_name,
       base::Bind(&GDataFileSystem::OnCopyDocumentCompleted,
                  ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
 void GDataFileSystem::Rename(const FilePath& file_path,
                              const FilePath::StringType& new_name,
@@ skipping 1366 matching lines @@
   if (!callback.is_null())
     callback.Run(error);
 }
 
 void GDataFileSystem::OnCopyDocumentCompleted(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   GDataFileError error = util::GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
-    if (!callback.is_null())
-      callback.Run(error);
-
+    callback.Run(error);
     return;
   }
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
   if (!doc_entry.get()) {
-    if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_FAILED);
-
+    callback.Run(GDATA_FILE_ERROR_FAILED);
     return;
   }
 
   GDataEntry* entry = GDataEntry::FromDocumentEntry(
       NULL, doc_entry.get(), directory_service_.get());
   if (!entry) {
-    if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_FAILED);
-
+    callback.Run(GDATA_FILE_ERROR_FAILED);
     return;
   }
 
   // |entry| was added in the root directory on the server, so we should
   // first add it to |root_| to mirror the state and then move it to the
   // destination directory by AddEntryToDirectory().
   directory_service_->root()->AddEntry(entry);
   AddEntryToDirectory(dir_path, callback, GDATA_FILE_OK, entry->GetFilePath());
 }
 
@@ skipping 948 matching lines @@
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata