Cleanup: return value and null-callback fixups on AsyncFileUtil interface

chrome/browser/media_galleries/fileapi/native_media_file_util.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/media_galleries/fileapi/native_media_file_util.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 117 matching lines @@
 
   if (StartsWithASCII(mime_type, "image/", true) ||
       StartsWithASCII(mime_type, "audio/", true) ||
       StartsWithASCII(mime_type, "video/", true) ||
       mime_type == "application/x-shockwave-flash") {
     return base::PLATFORM_FILE_OK;
   }
   return base::PLATFORM_FILE_ERROR_SECURITY;
 }
 
-bool NativeMediaFileUtil::CreateOrOpen(
+void NativeMediaFileUtil::CreateOrOpen(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     int file_flags,
     const CreateOrOpenCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   // Only called by NaCl, which should not have access to media file systems.
   base::PlatformFile invalid_file(base::kInvalidPlatformFileValue);
-  if (!callback.is_null()) {
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY,
-                 base::PassPlatformFile(&invalid_file));
-  }
-  return true;
+  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY,
+                base::PassPlatformFile(&invalid_file));
 }
 
-bool NativeMediaFileUtil::EnsureFileExists(
+void NativeMediaFileUtil::EnsureFileExists(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const EnsureFileExistsCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  if (!callback.is_null())
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY, false);
-  return true;
+  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY, false);
 }
 
-bool NativeMediaFileUtil::CreateDirectory(
+void NativeMediaFileUtil::CreateDirectory(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     bool exclusive,
     bool recursive,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   fileapi::FileSystemOperationContext* context_ptr = context.get();
-  return context_ptr->task_runner()->PostTask(
+  const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&NativeMediaFileUtil::CreateDirectoryOnTaskRunnerThread,
                  weak_factory_.GetWeakPtr(), base::Passed(&context),
                  url, exclusive, recursive, callback));
+  DCHECK(success);
 }
 
-bool NativeMediaFileUtil::GetFileInfo(
+void NativeMediaFileUtil::GetFileInfo(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const GetFileInfoCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   fileapi::FileSystemOperationContext* context_ptr = context.get();
-  return context_ptr->task_runner()->PostTask(
+  const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread,
                  weak_factory_.GetWeakPtr(), base::Passed(&context),
                  url, callback));
+  DCHECK(success);
 }
 
-bool NativeMediaFileUtil::ReadDirectory(
+void NativeMediaFileUtil::ReadDirectory(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   fileapi::FileSystemOperationContext* context_ptr = context.get();
-  return context_ptr->task_runner()->PostTask(
+  const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&NativeMediaFileUtil::ReadDirectoryOnTaskRunnerThread,
                  weak_factory_.GetWeakPtr(), base::Passed(&context),
                  url, callback));
+  DCHECK(success);
 }
 
-bool NativeMediaFileUtil::Touch(
+void NativeMediaFileUtil::Touch(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  if (!callback.is_null())
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
-  return true;
+  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
 }
 
-bool NativeMediaFileUtil::Truncate(
+void NativeMediaFileUtil::Truncate(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     int64 length,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  if (!callback.is_null())
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
-  return true;
+  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
 }
 
-bool NativeMediaFileUtil::CopyFileLocal(
+void NativeMediaFileUtil::CopyFileLocal(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& src_url,
     const fileapi::FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   fileapi::FileSystemOperationContext* context_ptr = context.get();
-  return context_ptr->task_runner()->PostTask(
+  const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread,
                  weak_factory_.GetWeakPtr(), base::Passed(&context),
                  src_url, dest_url, true /* copy */, callback));
+  DCHECK(success);
 }
 
-bool NativeMediaFileUtil::MoveFileLocal(
+void NativeMediaFileUtil::MoveFileLocal(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& src_url,
     const fileapi::FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   fileapi::FileSystemOperationContext* context_ptr = context.get();
-  return context_ptr->task_runner()->PostTask(
+  const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread,
                  weak_factory_.GetWeakPtr(), base::Passed(&context),
                  src_url, dest_url, false /* copy */, callback));
+  DCHECK(success);
 }
 
-bool NativeMediaFileUtil::CopyInForeignFile(
+void NativeMediaFileUtil::CopyInForeignFile(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const base::FilePath& src_file_path,
     const fileapi::FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   fileapi::FileSystemOperationContext* context_ptr = context.get();
-  return context_ptr->task_runner()->PostTask(
+  const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&NativeMediaFileUtil::CopyInForeignFileOnTaskRunnerThread,
                  weak_factory_.GetWeakPtr(), base::Passed(&context),
                  src_file_path, dest_url, callback));
+  DCHECK(success);
 }
 
-bool NativeMediaFileUtil::DeleteFile(
+void NativeMediaFileUtil::DeleteFile(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  if (!callback.is_null())
-    callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
-  return true;
+  callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
 }
 
 // This is needed to support Copy and Move.
-bool NativeMediaFileUtil::DeleteDirectory(
+void NativeMediaFileUtil::DeleteDirectory(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   fileapi::FileSystemOperationContext* context_ptr = context.get();
-  return context_ptr->task_runner()->PostTask(
+  const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&NativeMediaFileUtil::DeleteDirectoryOnTaskRunnerThread,
                  weak_factory_.GetWeakPtr(), base::Passed(&context),
                  url, callback));
+  DCHECK(success);
 }
 
-bool NativeMediaFileUtil::DeleteRecursively(
+void NativeMediaFileUtil::DeleteRecursively(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  if (!callback.is_null())
-    callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
-  return true;
+  callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
 }
 
-bool NativeMediaFileUtil::CreateSnapshotFile(
+void NativeMediaFileUtil::CreateSnapshotFile(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const CreateSnapshotFileCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   fileapi::FileSystemOperationContext* context_ptr = context.get();
-  return context_ptr->task_runner()->PostTask(
+  const bool success = context_ptr->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread,
                  weak_factory_.GetWeakPtr(), base::Passed(&context),
                  url, callback));
+  DCHECK(success);
 }
 
 void NativeMediaFileUtil::CreateDirectoryOnTaskRunnerThread(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     bool exclusive,
     bool recursive,
     const StatusCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::PlatformFileError error =
       CreateDirectorySync(context.get(), url, exclusive, recursive);
-  if (callback.is_null())
-    return;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, error));
 }
 
 void NativeMediaFileUtil::GetFileInfoOnTaskRunnerThread(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const GetFileInfoCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::PlatformFileInfo file_info;
   // TODO(thestig): remove this.
   base::FilePath platform_path;
   base::PlatformFileError error =
       GetFileInfoSync(context.get(), url, &file_info, &platform_path);
-  if (callback.is_null())
-    return;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, error, file_info));
 }
 
 void NativeMediaFileUtil::ReadDirectoryOnTaskRunnerThread(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   EntryList entry_list;
   base::PlatformFileError error =
       ReadDirectorySync(context.get(), url, &entry_list);
-  if (callback.is_null())
-    return;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, error, entry_list, false /* has_more */));
 }
 
 void NativeMediaFileUtil::CopyOrMoveFileLocalOnTaskRunnerThread(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& src_url,
     const fileapi::FileSystemURL& dest_url,
     bool copy,
     const StatusCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::PlatformFileError error =
       CopyOrMoveFileSync(context.get(), src_url, dest_url, copy);
-  if (callback.is_null())
-    return;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, error));
 }
 
 void NativeMediaFileUtil::CopyInForeignFileOnTaskRunnerThread(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const base::FilePath& src_file_path,
     const fileapi::FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::PlatformFileError error =
       CopyInForeignFileSync(context.get(), src_file_path, dest_url);
-  if (callback.is_null())
-    return;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, error));
 }
 
 void NativeMediaFileUtil::DeleteDirectoryOnTaskRunnerThread(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::PlatformFileError error = DeleteDirectorySync(context.get(), url);
-  if (callback.is_null())
-    return;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, error));
 }
 
 void NativeMediaFileUtil::CreateSnapshotFileOnTaskRunnerThread(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const CreateSnapshotFileCallback& callback) {
   DCHECK(IsOnTaskRunnerThread(context.get()));
   base::PlatformFileInfo file_info;
   base::FilePath platform_path;
   scoped_refptr<webkit_blob::ShareableFileReference> file_ref;
   base::PlatformFileError error =
       CreateSnapshotFileSync(context.get(), url, &file_info, &platform_path,
                              &file_ref);
-  if (callback.is_null())
-    return;
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, error, file_info, platform_path, file_ref));
 }
 
 base::PlatformFileError NativeMediaFileUtil::CreateDirectorySync(
     fileapi::FileSystemOperationContext* context,
     const fileapi::FileSystemURL& url,
     bool exclusive,
@@ skipping 220 matching lines @@
   if (!file_info.is_directory &&
       !GetMediaPathFilter(context)->Match(file_path)) {
     return failure_error;
   }
 
   *local_file_path = file_path;
   return base::PLATFORM_FILE_OK;
 }
 
 }  // namespace chrome