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

webkit/fileapi/file_system_operation.h

 // 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.
 
 #ifndef WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_
 #define WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_
 
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/process.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/quota/quota_manager.h"
 
 namespace base {
 class Time;
@@ skipping 11 matching lines @@
 class FileSystemCallbackDispatcher;
 class FileSystemContext;
 class FileWriterDelegate;
 class FileSystemOperationTest;
 class FileSystemQuotaUtil;
 
 // This class is designed to serve one-time file system operation per instance.
 // Only one method(CreateFile, CreateDirectory, Copy, Move, DirectoryExists,
 // GetMetadata, ReadDirectory and Remove) may be called during the lifetime of
 // this object and it should be called no more than once.
-// This class is self-destructed and an instance automatically gets deleted
-// when its operation is finished.
+// This class is self-destructed, or get deleted via base::Owned() fater the
+// operation finishes and completion callback is called.
 class FileSystemOperation {
  public:
   // |dispatcher| will be owned by this class.
   FileSystemOperation(FileSystemCallbackDispatcher* dispatcher,
                       scoped_refptr<base::MessageLoopProxy> proxy,
                       FileSystemContext* file_system_context);
   virtual ~FileSystemOperation();
 
   void OpenFileSystem(const GURL& origin_url,
                       fileapi::FileSystemType type,
@@ skipping 53 matching lines @@
   // operation. If it is given it will not be overwritten by the class.
   void set_override_file_util(FileSystemFileUtil* file_util) {
     operation_context_.set_src_file_util(file_util);
     operation_context_.set_dest_file_util(file_util);
   }
 
   void GetUsageAndQuotaThenCallback(
       const GURL& origin_url,
       const quota::QuotaManager::GetUsageAndQuotaCallback& callback);
 
-  void DelayedCreateFileForQuota(quota::QuotaStatusCode status,
+  void DelayedCreateFileForQuota(bool exclusive,
+                                 quota::QuotaStatusCode status,
                                  int64 usage, int64 quota);
-  void DelayedCreateDirectoryForQuota(quota::QuotaStatusCode status,
+  void DelayedCreateDirectoryForQuota(bool exclusive, bool recursive,
+                                      quota::QuotaStatusCode status,
                                       int64 usage, int64 quota);
   void DelayedCopyForQuota(quota::QuotaStatusCode status,
                            int64 usage, int64 quota);
   void DelayedMoveForQuota(quota::QuotaStatusCode status,
                            int64 usage, int64 quota);
   void DelayedWriteForQuota(quota::QuotaStatusCode status,
                             int64 usage, int64 quota);
-  void DelayedTruncateForQuota(quota::QuotaStatusCode status,
+  void DelayedTruncateForQuota(int64 length,
+                               quota::QuotaStatusCode status,
                                int64 usage, int64 quota);
-  void DelayedOpenFileForQuota(quota::QuotaStatusCode status,
+  void DelayedOpenFileForQuota(int file_flags,
+                               quota::QuotaStatusCode status,
                                int64 usage, int64 quota);
 
   // A callback used for OpenFileSystem.
   void DidGetRootPath(bool success,
                       const FilePath& path,
                       const std::string& name);
 
   // Callback for CreateFile for |exclusive|=true cases.
   void DidEnsureFileExistsExclusive(base::PlatformFileError rv,
                                     bool created);
@@ skipping 98 matching lines @@
     kOperationCancel,
   };
 
   // A flag to make sure we call operation only once per instance.
   OperationType pending_operation_;
 #endif
 
   // Proxy for calling file_util_proxy methods.
   scoped_refptr<base::MessageLoopProxy> proxy_;
 
+  // This can be NULL if the operation is cancelled on the way.
   scoped_ptr<FileSystemCallbackDispatcher> dispatcher_;
 
   FileSystemOperationContext operation_context_;
 
-  base::WeakPtrFactory<FileSystemOperation> weak_factory_;
-
   scoped_ptr<ScopedQuotaUtilHelper> quota_util_helper_;
 
   // These are all used only by Write().
   friend class FileWriterDelegate;
   scoped_ptr<FileWriterDelegate> file_writer_delegate_;
   scoped_ptr<net::URLRequest> blob_request_;
   scoped_ptr<FileSystemOperation> cancel_operation_;
 
   // Used only by OpenFile, in order to clone the file handle back to the
   // requesting process.
   base::ProcessHandle peer_handle_;
 
   // Used to keep a virtual path around while we check for quota.
   // If an operation needs only one path, use src_virtual_path_, even if it's a
   // write.
   FilePath src_virtual_path_;
   FilePath dest_virtual_path_;
 
-  // Options for CreateFile and CreateDirectory.
-  bool exclusive_;
-  bool recursive_;
-
-  // Options for OpenFile.
-  int file_flags_;
-
-  // Length to be truncated.
-  int64 length_;
-
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperation);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_