Retry: Bind: Merge FileUtilProxy and FileSystemFileUtilProxy: Delete/Touch/Truncate/Copy/Move

base/file_util_proxy.cc

 // Copyright (c) 2011 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 "base/file_util_proxy.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
@@ skipping 158 matching lines @@
   }
 
  private:
   scoped_refptr<MessageLoopProxy> message_loop_proxy_;
   PlatformFile file_handle_;
   FilePath file_path_;
   PlatformFileError error_;
   DISALLOW_COPY_AND_ASSIGN(CreateTemporaryHelper);
 };
 
-PlatformFileError DeleteHelper(const FilePath& file_path, bool recursive) {
-  if (!file_util::PathExists(file_path)) {
-    return PLATFORM_FILE_ERROR_NOT_FOUND;
-  }
-  if (!file_util::Delete(file_path, recursive)) {
-    if (!recursive && !file_util::IsDirectoryEmpty(file_path)) {
-      return PLATFORM_FILE_ERROR_NOT_EMPTY;
-    }
-    return PLATFORM_FILE_ERROR_FAILED;
-  }
-  return PLATFORM_FILE_OK;
-}
-
 class GetFileInfoHelper {
  public:
   GetFileInfoHelper()
       : error_(PLATFORM_FILE_OK) {}
 
   void RunWorkForFilePath(const FilePath& file_path) {
     if (!file_util::PathExists(file_path)) {
       error_ = PLATFORM_FILE_ERROR_NOT_FOUND;
       return;
     }
@@ skipping 88 matching lines @@
   return error;
 }
 
 PlatformFileError CloseAdapter(PlatformFile file_handle) {
   if (!ClosePlatformFile(file_handle)) {
     return PLATFORM_FILE_ERROR_FAILED;
   }
   return PLATFORM_FILE_OK;
 }
 
+PlatformFileError DeleteAdapter(const FilePath& file_path, bool recursive) {
+  if (!file_util::PathExists(file_path)) {
+    return PLATFORM_FILE_ERROR_NOT_FOUND;
+  }
+  if (!file_util::Delete(file_path, recursive)) {
+    if (!recursive && !file_util::IsDirectoryEmpty(file_path)) {
+      return PLATFORM_FILE_ERROR_NOT_EMPTY;
+    }
+    return PLATFORM_FILE_ERROR_FAILED;
+  }
+  return PLATFORM_FILE_OK;
+}
+
 }  // namespace
 
 // static
 bool FileUtilProxy::CreateOrOpen(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path, int file_flags,
     const CreateOrOpenCallback& callback) {
   return RelayCreateOrOpen(
       message_loop_proxy,
       base::Bind(&CreateOrOpenAdapter, file_path, file_flags),
@@ skipping 50 matching lines @@
         Bind(&GetFileInfoHelper::RunWorkForPlatformFile,
              Unretained(helper), file),
         Bind(&GetFileInfoHelper::Reply, Owned(helper), callback));
 }
 
 // static
 bool FileUtilProxy::Delete(scoped_refptr<MessageLoopProxy> message_loop_proxy,
                            const FilePath& file_path,
                            bool recursive,
                            const StatusCallback& callback) {
-  return PostTaskAndReplyWithStatus<PlatformFileError>(
+  return RelayFileTask(
       message_loop_proxy, FROM_HERE,
-      Bind(&DeleteHelper, file_path, recursive), callback,
-      new PlatformFileError);
+      Bind(&DeleteAdapter, file_path, recursive),
+      callback);
 }
 
 // static
 bool FileUtilProxy::RecursiveDelete(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path,
     const StatusCallback& callback) {
-  return PostTaskAndReplyWithStatus<PlatformFileError>(
+  return RelayFileTask(
       message_loop_proxy, FROM_HERE,
-      Bind(&DeleteHelper, file_path, true /* recursive */), callback,
-      new PlatformFileError);
+      Bind(&DeleteAdapter, file_path, true /* recursive */),
+      callback);
 }
 
 // static
 bool FileUtilProxy::Read(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     PlatformFile file,
     int64 offset,
     int bytes_to_read,
     const ReadCallback& callback) {
   if (bytes_to_read < 0) {
@@ skipping 70 matching lines @@
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     PlatformFile file,
     const StatusCallback& callback) {
   return PostTaskAndReplyWithStatus<bool>(
       message_loop_proxy, FROM_HERE,
       Bind(&FlushPlatformFile, file), callback,
       new PlatformFileError);
 }
 
 // static
+bool FileUtilProxy::RelayFileTask(
+    scoped_refptr<MessageLoopProxy> message_loop_proxy,
+    const tracked_objects::Location& from_here,
+    const FileTask& file_task,
+    const StatusCallback& callback) {
+  PlatformFileError* result = new PlatformFileError;
+  return message_loop_proxy->PostTaskAndReply(
+      from_here,
+      ReturnAsParam(file_task, result),
+      ReplyHelper(callback, Owned(result)));
+}
+
+// static
 bool FileUtilProxy::RelayCreateOrOpen(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const CreateOrOpenTask& open_task,
     const CloseTask& close_task,
     const CreateOrOpenCallback& callback) {
   CreateOrOpenHelper* helper = new CreateOrOpenHelper(
       message_loop_proxy, close_task);
   return message_loop_proxy->PostTaskAndReply(
         FROM_HERE,
         Bind(&CreateOrOpenHelper::RunWork, Unretained(helper), open_task),
         Bind(&CreateOrOpenHelper::Reply, Owned(helper), callback));
 }
 
 // static
 bool FileUtilProxy::RelayClose(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const CloseTask& close_task,
     PlatformFile file_handle,
     const StatusCallback& callback) {
   PlatformFileError* result = new PlatformFileError;
   return message_loop_proxy->PostTaskAndReply(
       FROM_HERE,
       ReturnAsParam(close_task, file_handle, result),
       ReplyHelper(callback, Owned(result)));
 }
 
 }  // namespace base