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

webkit/browser/fileapi/async_file_util_adapter.cc

 // Copyright (c) 2013 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 "webkit/browser/fileapi/async_file_util_adapter.h"
 
 #include "base/bind.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
 #include "webkit/browser/fileapi/file_system_context.h"
@@ skipping 18 matching lines @@
  public:
   EnsureFileExistsHelper() : error_(base::PLATFORM_FILE_OK), created_(false) {}
 
   void RunWork(FileSystemFileUtil* file_util,
                FileSystemOperationContext* context,
                const FileSystemURL& url) {
     error_ = file_util->EnsureFileExists(context, url, &created_);
   }
 
   void Reply(const AsyncFileUtil::EnsureFileExistsCallback& callback) {
-    if (!callback.is_null())
-      callback.Run(error_, created_);
+    callback.Run(error_, created_);
   }
 
  private:
   base::PlatformFileError error_;
   bool created_;
   DISALLOW_COPY_AND_ASSIGN(EnsureFileExistsHelper);
 };
 
 class GetFileInfoHelper {
  public:
   GetFileInfoHelper()
       : error_(base::PLATFORM_FILE_OK) {}
 
   void GetFileInfo(FileSystemFileUtil* file_util,
                    FileSystemOperationContext* context,
                    const FileSystemURL& url) {
     error_ = file_util->GetFileInfo(context, url, &file_info_, &platform_path_);
   }
 
   void CreateSnapshotFile(FileSystemFileUtil* file_util,
                           FileSystemOperationContext* context,
                           const FileSystemURL& url) {
     scoped_file_ = file_util->CreateSnapshotFile(
         context, url, &error_, &file_info_, &platform_path_);
   }
 
   void ReplyFileInfo(const AsyncFileUtil::GetFileInfoCallback& callback) {
-    if (!callback.is_null())
-      callback.Run(error_, file_info_);
+    callback.Run(error_, file_info_);
   }
 
   void ReplySnapshotFile(
       const AsyncFileUtil::CreateSnapshotFileCallback& callback) {
-    if (!callback.is_null())
-      callback.Run(error_, file_info_, platform_path_,
-                   ShareableFileReference::GetOrCreate(scoped_file_.Pass()));
+    callback.Run(error_, file_info_, platform_path_,
+                  ShareableFileReference::GetOrCreate(scoped_file_.Pass()));
   }
 
  private:
   base::PlatformFileError error_;
   base::PlatformFileInfo file_info_;
   base::FilePath platform_path_;
   webkit_blob::ScopedFile scoped_file_;
   DISALLOW_COPY_AND_ASSIGN(GetFileInfoHelper);
 };
 
@@ skipping 26 matching lines @@
       entry.is_directory = file_enum->IsDirectory();
       entry.name = VirtualPath::BaseName(current).value();
       entry.size = file_enum->Size();
       entry.last_modified_time = file_enum->LastModifiedTime();
       entries_.push_back(entry);
     }
     error_ = base::PLATFORM_FILE_OK;
   }
 
   void Reply(const AsyncFileUtil::ReadDirectoryCallback& callback) {
-    if (!callback.is_null())
-      callback.Run(error_, entries_, false /* has_more */);
+    callback.Run(error_, entries_, false /* has_more */);
   }
 
  private:
   base::PlatformFileError error_;
   std::vector<DirectoryEntry> entries_;
   DISALLOW_COPY_AND_ASSIGN(ReadDirectoryHelper);
 };
 
 void RunCreateOrOpenCallback(
     const AsyncFileUtil::CreateOrOpenCallback& callback,
     base::PlatformFileError result,
     base::PassPlatformFile file,
     bool created) {
   callback.Run(result, file);
 }
 
 }  // namespace
 
 AsyncFileUtilAdapter::AsyncFileUtilAdapter(
     FileSystemFileUtil* sync_file_util)
     : sync_file_util_(sync_file_util) {
   DCHECK(sync_file_util_.get());
 }
 
 AsyncFileUtilAdapter::~AsyncFileUtilAdapter() {
 }
 
-bool AsyncFileUtilAdapter::CreateOrOpen(
+void AsyncFileUtilAdapter::CreateOrOpen(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     int file_flags,
     const CreateOrOpenCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
-  return base::FileUtilProxy::RelayCreateOrOpen(
+  const bool success = base::FileUtilProxy::RelayCreateOrOpen(
       context_ptr->task_runner(),
       Bind(&FileSystemFileUtil::CreateOrOpen, Unretained(sync_file_util_.get()),
            context_ptr, url, file_flags),
       Bind(&FileSystemFileUtil::Close, Unretained(sync_file_util_.get()),
            base::Owned(context_ptr)),
       Bind(&RunCreateOrOpenCallback, callback));
-}
-
-bool AsyncFileUtilAdapter::EnsureFileExists(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::EnsureFileExists(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const EnsureFileExistsCallback& callback) {
   EnsureFileExistsHelper* helper = new EnsureFileExistsHelper;
   FileSystemOperationContext* context_ptr = context.release();
-  return context_ptr->task_runner()->PostTaskAndReply(
+  const bool success = context_ptr->task_runner()->PostTaskAndReply(
         FROM_HERE,
         Bind(&EnsureFileExistsHelper::RunWork, Unretained(helper),
              sync_file_util_.get(), base::Owned(context_ptr), url),
         Bind(&EnsureFileExistsHelper::Reply, Owned(helper), callback));
-}
-
-bool AsyncFileUtilAdapter::CreateDirectory(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::CreateDirectory(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     bool exclusive,
     bool recursive,
     const StatusCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
-  return base::PostTaskAndReplyWithResult(
+  const bool success = base::PostTaskAndReplyWithResult(
       context_ptr->task_runner(), FROM_HERE,
       Bind(&FileSystemFileUtil::CreateDirectory,
            Unretained(sync_file_util_.get()),
            base::Owned(context_ptr), url, exclusive, recursive),
       callback);
-}
-
-bool AsyncFileUtilAdapter::GetFileInfo(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::GetFileInfo(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const GetFileInfoCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
   GetFileInfoHelper* helper = new GetFileInfoHelper;
-  return context_ptr->task_runner()->PostTaskAndReply(
+  const bool success = context_ptr->task_runner()->PostTaskAndReply(
         FROM_HERE,
         Bind(&GetFileInfoHelper::GetFileInfo, Unretained(helper),
              sync_file_util_.get(), base::Owned(context_ptr), url),
         Bind(&GetFileInfoHelper::ReplyFileInfo, Owned(helper), callback));
-}
-
-bool AsyncFileUtilAdapter::ReadDirectory(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::ReadDirectory(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
   ReadDirectoryHelper* helper = new ReadDirectoryHelper;
-  return context_ptr->task_runner()->PostTaskAndReply(
+  const bool success = context_ptr->task_runner()->PostTaskAndReply(
         FROM_HERE,
         Bind(&ReadDirectoryHelper::RunWork, Unretained(helper),
              sync_file_util_.get(), base::Owned(context_ptr), url),
         Bind(&ReadDirectoryHelper::Reply, Owned(helper), callback));
-}
-
-bool AsyncFileUtilAdapter::Touch(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::Touch(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
-  return base::PostTaskAndReplyWithResult(
+  const bool success = base::PostTaskAndReplyWithResult(
       context_ptr->task_runner(), FROM_HERE,
       Bind(&FileSystemFileUtil::Touch, Unretained(sync_file_util_.get()),
            base::Owned(context_ptr), url,
            last_access_time, last_modified_time),
       callback);
-}
-
-bool AsyncFileUtilAdapter::Truncate(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::Truncate(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     int64 length,
     const StatusCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
-  return base::PostTaskAndReplyWithResult(
+  const bool success = base::PostTaskAndReplyWithResult(
       context_ptr->task_runner(), FROM_HERE,
       Bind(&FileSystemFileUtil::Truncate, Unretained(sync_file_util_.get()),
            base::Owned(context_ptr), url, length),
       callback);
-}
-
-bool AsyncFileUtilAdapter::CopyFileLocal(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::CopyFileLocal(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
-  return base::PostTaskAndReplyWithResult(
+  const bool success = base::PostTaskAndReplyWithResult(
       context_ptr->task_runner(), FROM_HERE,
       Bind(&FileSystemFileUtil::CopyOrMoveFile,
            Unretained(sync_file_util_.get()),
            base::Owned(context_ptr), src_url, dest_url, true /* copy */),
       callback);
-}
-
-bool AsyncFileUtilAdapter::MoveFileLocal(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::MoveFileLocal(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
-  return base::PostTaskAndReplyWithResult(
+  const bool success = base::PostTaskAndReplyWithResult(
       context_ptr->task_runner(), FROM_HERE,
       Bind(&FileSystemFileUtil::CopyOrMoveFile,
            Unretained(sync_file_util_.get()),
            base::Owned(context_ptr), src_url, dest_url, false /* copy */),
       callback);
-}
-
-bool AsyncFileUtilAdapter::CopyInForeignFile(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::CopyInForeignFile(
       scoped_ptr<FileSystemOperationContext> context,
       const base::FilePath& src_file_path,
       const FileSystemURL& dest_url,
       const StatusCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
-  return base::PostTaskAndReplyWithResult(
+  const bool success = base::PostTaskAndReplyWithResult(
       context_ptr->task_runner(), FROM_HERE,
       Bind(&FileSystemFileUtil::CopyInForeignFile,
            Unretained(sync_file_util_.get()),
            base::Owned(context_ptr), src_file_path, dest_url),
       callback);
-}
-
-bool AsyncFileUtilAdapter::DeleteFile(
-    scoped_ptr<FileSystemOperationContext> context,
-    const FileSystemURL& url,
-    const StatusCallback& callback) {
-  FileSystemOperationContext* context_ptr = context.release();
-  return base::PostTaskAndReplyWithResult(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::DeleteFile(
+    scoped_ptr<FileSystemOperationContext> context,
+    const FileSystemURL& url,
+    const StatusCallback& callback) {
+  FileSystemOperationContext* context_ptr = context.release();
+  const bool success = base::PostTaskAndReplyWithResult(
       context_ptr->task_runner(), FROM_HERE,
       Bind(&FileSystemFileUtil::DeleteFile,
            Unretained(sync_file_util_.get()),
            base::Owned(context_ptr), url),
       callback);
-}
-
-bool AsyncFileUtilAdapter::DeleteDirectory(
-    scoped_ptr<FileSystemOperationContext> context,
-    const FileSystemURL& url,
-    const StatusCallback& callback) {
-  FileSystemOperationContext* context_ptr = context.release();
-  return base::PostTaskAndReplyWithResult(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::DeleteDirectory(
+    scoped_ptr<FileSystemOperationContext> context,
+    const FileSystemURL& url,
+    const StatusCallback& callback) {
+  FileSystemOperationContext* context_ptr = context.release();
+  const bool success = base::PostTaskAndReplyWithResult(
       context_ptr->task_runner(), FROM_HERE,
       Bind(&FileSystemFileUtil::DeleteDirectory,
            Unretained(sync_file_util_.get()),
            base::Owned(context_ptr), url),
       callback);
-}
-
-bool AsyncFileUtilAdapter::DeleteRecursively(
-    scoped_ptr<FileSystemOperationContext> context,
-    const FileSystemURL& url,
-    const StatusCallback& callback) {
-  if (!callback.is_null())
-    callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
-  return true;
-}
-
-bool AsyncFileUtilAdapter::CreateSnapshotFile(
+  DCHECK(success);
+}
+
+void AsyncFileUtilAdapter::DeleteRecursively(
+    scoped_ptr<FileSystemOperationContext> context,
+    const FileSystemURL& url,
+    const StatusCallback& callback) {
+  callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+}
+
+void AsyncFileUtilAdapter::CreateSnapshotFile(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const CreateSnapshotFileCallback& callback) {
   FileSystemOperationContext* context_ptr = context.release();
   GetFileInfoHelper* helper = new GetFileInfoHelper;
-  return context_ptr->task_runner()->PostTaskAndReply(
+  const bool success = context_ptr->task_runner()->PostTaskAndReply(
         FROM_HERE,
         Bind(&GetFileInfoHelper::CreateSnapshotFile, Unretained(helper),
              sync_file_util_.get(), base::Owned(context_ptr), url),
         Bind(&GetFileInfoHelper::ReplySnapshotFile, Owned(helper), callback));
+  DCHECK(success);
 }
 
 }  // namespace fileapi