Retry: Merge FileUtilProxy and FileSystemFileUtilProxy using PostTaskAndReply: CreateOrOpen/Close

webkit/fileapi/file_system_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 "webkit/fileapi/file_system_file_util_proxy.h"
 
 #include "base/bind.h"
 #include "base/message_loop_proxy.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
@@ skipping 53 matching lines @@
     origin_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&MessageLoopRelay::RunCallback, this));
   }
 
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   base::PlatformFileError error_code_;
   fileapi::FileSystemOperationContext context_;
   fileapi::FileSystemFileUtil* file_util_;
 };
 
-class RelayCreateOrOpen : public MessageLoopRelay {
- public:
-  RelayCreateOrOpen(
-      const fileapi::FileSystemOperationContext& context,
-      scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
-      const FilePath& file_path,
-      int file_flags,
-      const fileapi::FileSystemFileUtilProxy::CreateOrOpenCallback& callback)
-      : MessageLoopRelay(context),
-        message_loop_proxy_(message_loop_proxy),
-        file_path_(file_path),
-        file_flags_(file_flags),
-        callback_(callback),
-        file_handle_(base::kInvalidPlatformFileValue),
-        created_(false) {
-    DCHECK_EQ(false, callback.is_null());
-  }
-
- protected:
-  virtual ~RelayCreateOrOpen() {
-    if (file_handle_ != base::kInvalidPlatformFileValue)
-      fileapi::FileSystemFileUtilProxy::Close(
-          *context(), message_loop_proxy_, file_handle_,
-          fileapi::FileSystemFileUtilProxy::StatusCallback());
-  }
-
-  virtual void RunWork() {
-    set_error_code(file_util()->CreateOrOpen(
-        context(), file_path_, file_flags_, &file_handle_, &created_));
-  }
-
-  virtual void RunCallback() {
-    callback_.Run(error_code(), base::PassPlatformFile(&file_handle_),
-                  created_);
-  }
-
- private:
-  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
-  FilePath file_path_;
-  int file_flags_;
-  fileapi::FileSystemFileUtilProxy::CreateOrOpenCallback callback_;
-  base::PlatformFile file_handle_;
-  bool created_;
-};
-
 class RelayWithStatusCallback : public MessageLoopRelay {
  public:
   RelayWithStatusCallback(
       const fileapi::FileSystemOperationContext& context,
       const fileapi::FileSystemFileUtilProxy::StatusCallback& callback)
       : MessageLoopRelay(context),
         callback_(callback) {
     // It is OK for callback to be NULL.
   }
 
  protected:
   virtual void RunCallback() {
     // The caller may not have been interested in the result.
     if (!callback_.is_null())
       callback_.Run(error_code());
   }
 
  private:
   fileapi::FileSystemFileUtilProxy::StatusCallback callback_;
 };
 
-class RelayClose : public RelayWithStatusCallback {
- public:
-  RelayClose(const fileapi::FileSystemOperationContext& context,
-             base::PlatformFile file_handle,
-             const fileapi::FileSystemFileUtilProxy::StatusCallback& callback)
-      : RelayWithStatusCallback(context, callback),
-        file_handle_(file_handle) {
-  }
-
- protected:
-  virtual void RunWork() {
-    set_error_code(file_util()->Close(context(), file_handle_));
-  }
-
- private:
-  base::PlatformFile file_handle_;
-};
-
 class RelayEnsureFileExists : public MessageLoopRelay {
  public:
   RelayEnsureFileExists(
       const fileapi::FileSystemOperationContext& context,
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       const FilePath& file_path,
       const fileapi::FileSystemFileUtilProxy::EnsureFileExistsCallback&
           callback)
       : MessageLoopRelay(context),
         message_loop_proxy_(message_loop_proxy),
@@ skipping 250 matching lines @@
            scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
            scoped_refptr<MessageLoopRelay> relay) {
   return relay->Start(message_loop_proxy, from_here);
 }
 
 }  // namespace
 
 namespace fileapi {
 
 // static
-bool FileSystemFileUtilProxy::CreateOrOpen(
-    const FileSystemOperationContext& context,
-    scoped_refptr<MessageLoopProxy> message_loop_proxy,
-    const FilePath& file_path, int file_flags,
-    const CreateOrOpenCallback& callback) {
-  return Start(FROM_HERE, message_loop_proxy, new RelayCreateOrOpen(context,
-      message_loop_proxy, file_path, file_flags, callback));
-}
-
-// static
-bool FileSystemFileUtilProxy::Close(
-    const FileSystemOperationContext& context,
-    scoped_refptr<MessageLoopProxy> message_loop_proxy,
-    base::PlatformFile file_handle,
-    const StatusCallback& callback) {
-  return Start(FROM_HERE, message_loop_proxy,
-               new RelayClose(context, file_handle, callback));
-}
-
-// static
 bool FileSystemFileUtilProxy::EnsureFileExists(
     const FileSystemOperationContext& context,
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& file_path,
     const EnsureFileExistsCallback& callback) {
   return Start(FROM_HERE, message_loop_proxy, new RelayEnsureFileExists(
       context, message_loop_proxy, file_path, callback));
 }
 
 // static
@@ skipping 91 matching lines @@
     const FileSystemOperationContext& context,
     scoped_refptr<MessageLoopProxy> message_loop_proxy,
     const FilePath& path,
     int64 length,
     const StatusCallback& callback) {
   return Start(FROM_HERE, message_loop_proxy,
                new RelayTruncate(context, path, length, callback));
 }
 
 }  // namespace fileapi