gdata: Make callback parameter mandatory for GetEntryInfo family

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 603 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (update_timer_.IsRunning())
     update_timer_.Stop();
 }
 
 void GDataFileSystem::GetEntryInfoByResourceId(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback.is_null());
+
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetEntryInfoByResourceIdOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
                  CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::GetEntryInfoByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
   directory_service_->GetEntryByResourceIdAsync(resource_id,
       base::Bind(&GDataFileSystem::GetEntryInfoByEntryOnUIThread,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::GetEntryInfoByEntryOnUIThread(
     const GetEntryInfoWithFilePathCallback& callback,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   if (entry) {
     scoped_ptr<GDataEntryProto> entry_proto(new GDataEntryProto);
     entry->ToProtoFull(entry_proto.get());
     CheckLocalModificationAndRun(
         entry_proto.Pass(),
         base::Bind(&RunGetEntryInfoWithFilePathCallback,
                    callback, entry->GetFilePath()));
   } else {
     callback.Run(GDATA_FILE_ERROR_NOT_FOUND,
                  FilePath(),
                  scoped_ptr<GDataEntryProto>());
   }
 }
 
 void GDataFileSystem::FindEntryByPathAsyncOnUIThread(
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   if (directory_service_->origin() == INITIALIZING) {
     // If root feed is not initialized but the initialization process has
     // already started, add an observer to execute the remaining task after
     // the end of the initialization.
     AddObserver(new InitialLoadObserver(
         this,
         base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
                    ui_weak_ptr_,
                    search_file_path,
@@ skipping 20 matching lines @@
       base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
                  ui_weak_ptr_,
                  search_file_path,
                  callback));
 }
 
 void GDataFileSystem::FindEntryByPathSyncOnUIThread(
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   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());
@@ skipping 1184 matching lines @@
   entry->ToProtoFull(entry_proto.get());
 
   CheckLocalModificationAndRun(entry_proto.Pass(), callback);
 }
 
 void GDataFileSystem::ReadDirectoryByPath(
     const FilePath& file_path,
     const ReadDirectoryWithSettingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!callback.is_null());
+
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::ReadDirectoryByPathAsyncOnUIThread,
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::ReadDirectoryByPathAsyncOnUIThread(
     const FilePath& file_path,
     const ReadDirectoryWithSettingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   FindEntryByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnReadDirectory,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnReadDirectory(
     const ReadDirectoryWithSettingCallback& callback,
@@ skipping 897 matching lines @@
   // Notify the observers that the file system is being unmounted.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnFileSystemBeingUnmounted());
 }
 
 void GDataFileSystem::RunAndNotifyInitialLoadFinished(
     const FindEntryCallback& callback,
     GDataFileError error,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
-  if (!callback.is_null())
-    callback.Run(error, entry);
+  callback.Run(error, entry);
 
   DVLOG(1) << "RunAndNotifyInitialLoadFinished";
 
   // Notify the observers that root directory has been initialized.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnInitialLoadFinished());
 }
 
 GDataFileError GDataFileSystem::AddNewDirectory(
     const FilePath& directory_path, base::Value* entry_value) {
@@ skipping 445 matching lines @@
 
   // Then invokes the user-supplied callback function.
   callback.Run(result);
 }
 
 void GDataFileSystem::CheckLocalModificationAndRun(
     scoped_ptr<GDataEntryProto> entry_proto,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(entry_proto.get());
+  DCHECK(!callback.is_null());
 
   // For entries that will never be cached, use the original entry info as is.
   if (!entry_proto->has_file_specific_info() ||
       entry_proto->file_specific_info().is_hosted_document()) {
-    if (!callback.is_null())
-      callback.Run(GDATA_FILE_OK, entry_proto.Pass());
+    callback.Run(GDATA_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // Checks if the file is cached and modified locally.
   const std::string resource_id = entry_proto->resource_id();
   const std::string md5 = entry_proto->file_specific_info().file_md5();
   cache_->GetCacheEntryOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry,
           ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry(
     scoped_ptr<GDataEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     bool success,
     const GDataCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
 
   // When no dirty cache is found, use the original entry info as is.
   if (!success || !cache_entry.is_dirty()) {
-    if (!callback.is_null())
-      callback.Run(GDATA_FILE_OK, entry_proto.Pass());
+    callback.Run(GDATA_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // Gets the cache file path.
   const std::string& resource_id = entry_proto->resource_id();
   const std::string& md5 = entry_proto->file_specific_info().file_md5();
   cache_->GetFileOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheFile,
           ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheFile(
     scoped_ptr<GDataEntryProto> entry_proto,
     const GetEntryInfoCallback& 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());
 
   // When no dirty cache is found, use the original entry info as is.
   if (error != GDATA_FILE_OK) {
-    if (!callback.is_null())
-      callback.Run(GDATA_FILE_OK, entry_proto.Pass());
+    callback.Run(GDATA_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // If the cache is dirty, obtain the file info from the cache file itself.
   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::CheckLocalModificationAndRunAfterGetFileInfo,
                  ui_weak_ptr_,
                  base::Passed(&entry_proto),
                  callback,
                  base::Owned(file_info),
                  base::Owned(get_file_info_result)));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetFileInfo(
     scoped_ptr<GDataEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     base::PlatformFileInfo* file_info,
     bool* get_file_info_result) {
   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, scoped_ptr<GDataEntryProto>());
+    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, scoped_ptr<GDataEntryProto>());
     return;
   }
 
   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());
+  callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata