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"
 
 namespace base {
 
 namespace {
 
 // Helper templates to call file_util or base::PlatformFile methods
 // and reply with the returned value.
 //
 // Typically when you have these methods:
 //   R DoWorkAndReturn();
 //   void Callback(R& result);
 //
 // You can pass the result of DoWorkAndReturn to the Callback by:
 //
 //  R* result = new R;
 //  message_loop_proxy->PostTaskAndReply(
 //      from_here,
 //      ReturnAsParam<R>(Bind(&DoWorkAndReturn), result),
-//      CallbackWithReturn(Bind(&Callback), Owned(result)));
+//      RelayHelper(Bind(&Callback), Owned(result)));
 //
 // Or just use PostTaskAndReplyWithStatus helper template (see the code below).
 template <typename R1, typename R2>
 struct ReturnValueTranslator {
   static R2 Value(const R1& value);
 };
 
 template <typename R>
 struct ReturnValueTranslator<R, R> {
   static R Value(const R& value) { return value; }
@@ skipping 13 matching lines @@
   if (!func.is_null())
     *result = ReturnValueTranslator<R1, R2>::Value(func.Run());
 }
 
 template <typename R1, typename R2>
 Closure ReturnAsParam(const Callback<R1(void)>& func, R2* result) {
   DCHECK(result);
   return Bind(&ReturnAsParamAdapter<R1, R2>, func, result);
 }
 
+template <typename R, typename A1>
+void ReturnAsParamAdapter1(const Callback<R(A1)>& func, A1 a1, R* result) {
+  if (!func.is_null())
+    *result = func.Run(a1);
+}
+
+template <typename R, typename A1>
+Closure ReturnAsParam(const Callback<R(A1)>& func, A1 a1, R* result) {
+  DCHECK(result);
+  return Bind(&ReturnAsParamAdapter1<R, A1>, func, a1, result);
+}
+
 template <typename R>
 void ReplyAdapter(const Callback<void(R)>& callback, R* result) {
   DCHECK(result);
   if (!callback.is_null())
     callback.Run(*result);
 }
 
 template <typename R, typename OWNED>
 Closure ReplyHelper(const Callback<void(R)>& callback, OWNED result) {
   return Bind(&ReplyAdapter<R>, callback, result);
 }
 
 // Putting everything together.
 template <typename R1, typename R2>
 bool PostTaskAndReplyWithStatus(
     const scoped_refptr<MessageLoopProxy>& message_loop_proxy,
     const tracked_objects::Location& from_here,
     const Callback<R1(void)>& file_util_work,
     const Callback<void(R2)>& callback,
     R2* result) {
   return message_loop_proxy->PostTaskAndReply(
       from_here,
       ReturnAsParam<R1>(file_util_work, result),
       ReplyHelper(callback, Owned(result)));
 }
 
 // Helper classes or routines for individual methods.
 class CreateOrOpenHelper {
  public:
-  CreateOrOpenHelper(MessageLoopProxy* message_loop_proxy)
+  CreateOrOpenHelper(MessageLoopProxy* message_loop_proxy,
+                     const FileUtilProxy::CloseTask& close_task)
       : message_loop_proxy_(message_loop_proxy),
+        close_task_(close_task),
         file_handle_(kInvalidPlatformFileValue),
         created_(false),
         error_(PLATFORM_FILE_OK) {}
 
   ~CreateOrOpenHelper() {
     if (file_handle_ != kInvalidPlatformFileValue) {
-      FileUtilProxy::Close(message_loop_proxy_, file_handle_,
-                           FileUtilProxy::StatusCallback());
+      message_loop_proxy_->PostTask(
+          FROM_HERE, base::Bind(close_task_, file_handle_));
     }
   }
 
-  void RunWork(const FilePath& file_path, int file_flags) {
-    if (!file_util::DirectoryExists(file_path.DirName())) {
-      // If its parent does not exist, should return NOT_FOUND error.
-      error_ = PLATFORM_FILE_ERROR_NOT_FOUND;
-      return;
-    }
-    error_ = PLATFORM_FILE_OK;
-    file_handle_ = CreatePlatformFile(file_path, file_flags,
-                                      &created_, &error_);
+  void RunWork(const FileUtilProxy::CreateOrOpenTask& task) {
+    error_ = task.Run(&file_handle_, &created_);
   }
 
   void Reply(const FileUtilProxy::CreateOrOpenCallback& callback) {
     DCHECK(!callback.is_null());
     callback.Run(error_, PassPlatformFile(&file_handle_), created_);
   }
 
  private:
   scoped_refptr<MessageLoopProxy> message_loop_proxy_;
+  FileUtilProxy::CloseTask close_task_;
   PlatformFile file_handle_;
   bool created_;
   PlatformFileError error_;
   DISALLOW_COPY_AND_ASSIGN(CreateOrOpenHelper);
 };
 
 class CreateTemporaryHelper {
  public:
   CreateTemporaryHelper(MessageLoopProxy* message_loop_proxy)
       : message_loop_proxy_(message_loop_proxy),
@@ skipping 28 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 66 matching lines @@
     }
   }
 
  private:
   scoped_array<char> buffer_;
   int bytes_to_write_;
   int bytes_written_;
   DISALLOW_COPY_AND_ASSIGN(WriteHelper);
 };
 
+
+PlatformFileError CreateOrOpenAdapter(
+    const FilePath& file_path, int file_flags,
+    PlatformFile* file_handle, bool* created) {
+  DCHECK(file_handle);
+  DCHECK(created);
+  if (!file_util::DirectoryExists(file_path.DirName())) {
+    // If its parent does not exist, should return NOT_FOUND error.
+    return PLATFORM_FILE_ERROR_NOT_FOUND;
+  }
+  PlatformFileError error = PLATFORM_FILE_OK;
+  *file_handle = CreatePlatformFile(file_path, file_flags, created, &error);
+  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) {
-  CreateOrOpenHelper* helper = new CreateOrOpenHelper(message_loop_proxy);
-  return message_loop_proxy->PostTaskAndReply(
-        FROM_HERE,
-        Bind(&CreateOrOpenHelper::RunWork, Unretained(helper),
-             file_path, file_flags),
-        Bind(&CreateOrOpenHelper::Reply, Owned(helper), callback));
+  return RelayCreateOrOpen(
+      message_loop_proxy,
+      base::Bind(&CreateOrOpenAdapter, file_path, file_flags),
+      base::Bind(&CloseAdapter),
+      callback);
 }
 
 // static
 bool FileUtilProxy::CreateTemporary(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     int additional_file_flags,
     const CreateTemporaryCallback& callback) {
   CreateTemporaryHelper* helper = new CreateTemporaryHelper(message_loop_proxy);
   return message_loop_proxy->PostTaskAndReply(
         FROM_HERE,
         Bind(&CreateTemporaryHelper::RunWork, Unretained(helper),
              additional_file_flags),
         Bind(&CreateTemporaryHelper::Reply, Owned(helper), callback));
 }
 
 // static
-bool FileUtilProxy::Close(scoped_refptr<MessageLoopProxy> message_loop_proxy,
-                          PlatformFile file_handle,
-                          const StatusCallback& callback) {
-  return PostTaskAndReplyWithStatus<bool>(
-      message_loop_proxy, FROM_HERE,
-      Bind(&ClosePlatformFile, file_handle), callback,
-      new PlatformFileError);
+bool FileUtilProxy::Close(
+    scoped_refptr<MessageLoopProxy> message_loop_proxy,
+    base::PlatformFile file_handle,
+    const StatusCallback& callback) {
+  return RelayClose(
+      message_loop_proxy,
+      base::Bind(&CloseAdapter),
+      file_handle, callback);
 }
 
 // Retrieves the information about a file. It is invalid to pass NULL for the
 // callback.
 bool FileUtilProxy::GetFileInfo(
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path,
     const GetFileInfoCallback& callback) {
   GetFileInfoHelper* helper = new GetFileInfoHelper;
   return message_loop_proxy->PostTaskAndReply(
@@ skipping 14 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 69 matching lines @@
 bool FileUtilProxy::Flush(
     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