gdata: Make callback parameters mandatory for CloseFile 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 3162 matching lines @@
     open_files_.erase(file_path);
 
   if (!callback.is_null())
     callback.Run(result, cache_file_path);
 }
 
 void GDataFileSystem::CloseFile(const FilePath& file_path,
                                 const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback.is_null());
+
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::CloseFileOnUIThread,
                                ui_weak_ptr_,
                                file_path,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::CloseFileOnUIThread(
     const FilePath& file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   if (open_files_.find(file_path) == open_files_.end()) {
     // The file is not being opened.
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_FILE_ERROR_NOT_FOUND));
     return;
   }
 
   // Step 1 of CloseFile: Get resource_id and md5 for |file_path|.
   GetEntryInfoByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForCloseFile,
                  ui_weak_ptr_,
                  file_path,
                  base::Bind(&GDataFileSystem::OnCloseFileFinished,
                             ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForCloseFile(
     const FilePath& file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
     error = GDATA_FILE_ERROR_NOT_FOUND;
 
   if (error != GDATA_FILE_OK) {
-    if (!callback.is_null())
-      callback.Run(error);
+    callback.Run(error);
     return;
   }
 
   // Step 2 of CloseFile: Get the local path of the cache. Since CloseFile must
   // always be called on paths opened by OpenFile, the file must be cached,
   cache_->GetFileOnUIThread(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
       base::Bind(&GDataFileSystem::OnGetCacheFilePathCompleteForCloseFile,
                  ui_weak_ptr_,
                  file_path,
                  callback));
 }
 
 void GDataFileSystem::OnGetCacheFilePathCompleteForCloseFile(
     const FilePath& file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     const std::string& resource_id,
     const std::string& md5,
     const FilePath& local_cache_path) {
   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;
   }
 
   // Step 3 of CloseFile: Retrieves the (possibly modified) PlatformFileInfo of
   // the cache file.
   base::PlatformFileInfo* file_info = new base::PlatformFileInfo;
   bool* get_file_info_result = new bool(false);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetFileInfoOnBlockingPool,
                  local_cache_path,
                  base::Unretained(file_info),
                  base::Unretained(get_file_info_result)),
       base::Bind(&GDataFileSystem::OnGetModifiedFileInfoCompleteForCloseFile,
                  ui_weak_ptr_,
                  file_path,
                  base::Owned(file_info),
                  base::Owned(get_file_info_result),
                  callback));
 }
 
 void GDataFileSystem::OnGetModifiedFileInfoCompleteForCloseFile(
     const FilePath& file_path,
     base::PlatformFileInfo* file_info,
     bool* get_file_info_result,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   if (!*get_file_info_result) {
-    if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_NOT_FOUND);
+    callback.Run(GDATA_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   // Step 4 of CloseFile: Find GDataEntry corresponding to |file_path|, for
   // modifying the entry's metadata.
   FindEntryByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryCompleteForCloseFile,
                  ui_weak_ptr_,
-                 file_path,
                  *file_info,
                  callback));
 }
 
 void GDataFileSystem::OnGetEntryCompleteForCloseFile(
-    const FilePath& file_path,
     const base::PlatformFileInfo& file_info,
     const FileOperationCallback& callback,
     GDataFileError error,
     GDataEntry* entry) {
   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;
   }
 
   DCHECK(entry);
   GDataFile* file = entry->AsGDataFile();
   if (!file || file->file_md5().empty() || file->is_hosted_document()) {
     // No support for opening a directory or hosted document.
-    if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_INVALID_OPERATION);
+    callback.Run(GDATA_FILE_ERROR_INVALID_OPERATION);
     return;
   }
   DCHECK(!file->resource_id().empty());
 
   // Step 5 of CloseFile:
   // Update the in-memory meta data. Until the committed cache is uploaded in
   // background to the server and the change is propagated back, this in-memory
   // meta data is referred by subsequent file operations. So it needs to reflect
   // the modification made before committing.
   file->set_file_info(file_info);
 
   // Step 6 of CloseFile: Commit the modification in cache. This will trigger
   // background upload.
   // TODO(benchan,kinaba): Call ClearDirtyInCache instead of CommitDirtyInCache
   // if the file has not been modified. Come up with a way to detect the
   // intactness effectively, or provide a method for user to declare it when
   // calling CloseFile().
   cache_->CommitDirtyOnUIThread(
       file->resource_id(),
       file->file_md5(),
       base::Bind(&GDataFileSystem::OnCommitDirtyInCacheCompleteForCloseFile,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnCommitDirtyInCacheCompleteForCloseFile(
     const FileOperationCallback& callback,
     GDataFileError error,
-    const std::string& resource_id,
-    const std::string& md5) {
+    const std::string& /* resource_id */,
+    const std::string& /* md5 */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
-  if (!callback.is_null())
-    callback.Run(error);
+  callback.Run(error);
 }
 
 void GDataFileSystem::OnCloseFileFinished(
     const FilePath& file_path,
     const FileOperationCallback& callback,
     GDataFileError result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   // Step 7 of CloseFile.
   // All the invocation of |callback| from operations initiated from CloseFile
   // must go through here. Removes the |file_path| from the remembered set so
   // that subsequent operations can open the file again.
   open_files_.erase(file_path);
 
   // Then invokes the user-supplied callback function.
-  if (!callback.is_null())
-    callback.Run(result);
+  callback.Run(result);
 }
 
 void GDataFileSystem::CheckLocalModificationAndRun(
     scoped_ptr<GDataEntryProto> entry_proto,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(entry_proto.get());
 
   // For entries that will never be cached, use the original entry info as is.
   if (!entry_proto->has_file_specific_info() ||
@@ skipping 87 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