Cleanup FileSystemOperation for preparing for adding FSO-factory method

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 <string>
 #include <vector>
 
@@ skipping 33 matching lines @@
 // FileSystemOperation implementation for local file systems.
 class FileSystemOperation : public FileSystemOperationInterface {
  public:
   // |dispatcher| will be owned by this class.
   FileSystemOperation(FileSystemCallbackDispatcher* dispatcher,
                       scoped_refptr<base::MessageLoopProxy> proxy,
                       FileSystemContext* file_system_context);
   virtual ~FileSystemOperation();
 
   // FileSystemOperation overrides.
-  virtual void OpenFileSystem(const GURL& origin_url,
-                              fileapi::FileSystemType type,
-                              bool create) OVERRIDE;
   virtual void CreateFile(const GURL& path,
                           bool exclusive) OVERRIDE;
   virtual void CreateDirectory(const GURL& path,
                                bool exclusive,
                                bool recursive) OVERRIDE;
   virtual void Copy(const GURL& src_path,
                     const GURL& dest_path) OVERRIDE;
   virtual void Move(const GURL& src_path,
                     const GURL& dest_path) OVERRIDE;
   virtual void DirectoryExists(const GURL& path) OVERRIDE;
   virtual void FileExists(const GURL& path) OVERRIDE;
   virtual void GetMetadata(const GURL& path) OVERRIDE;
   virtual void ReadDirectory(const GURL& path) OVERRIDE;
   virtual void Remove(const GURL& path, bool recursive) OVERRIDE;
   virtual void Write(const net::URLRequestContext* url_request_context,
                      const GURL& path,
                      const GURL& blob_url,
                      int64 offset) OVERRIDE;
   virtual void Truncate(const GURL& path, int64 length) OVERRIDE;
   virtual void TouchFile(const GURL& path,
                          const base::Time& last_access_time,
                          const base::Time& last_modified_time) OVERRIDE;
   virtual void OpenFile(
       const GURL& path,
       int file_flags,
       base::ProcessHandle peer_handle) OVERRIDE;
+  virtual void Cancel(FileSystemCallbackDispatcher* cancel_dispatcher) OVERRIDE;
 
   // Synchronously gets the platform path for the given |path|.
   void SyncGetPlatformPath(const GURL& path, FilePath* platform_path);
 
-  // Try to cancel the current operation [we support cancelling write or
-  // truncate only].  Report failure for the current operation, then tell the
-  // passed-in operation to report success.
-  void Cancel(FileSystemOperation* cancel_operation);
-
  private:
   class ScopedQuotaUtilHelper;
 
   FileSystemContext* file_system_context() const {
     return operation_context_.file_system_context();
   }
 
   FileSystemOperationContext* file_system_operation_context() {
     return &operation_context_;
   }
@@ skipping 28 matching lines @@
                            int64 usage, int64 quota);
   void DelayedWriteForQuota(quota::QuotaStatusCode status,
                             int64 usage, int64 quota);
   void DelayedTruncateForQuota(int64 length,
                                quota::QuotaStatusCode status,
                                int64 usage, int64 quota);
   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);
 
   // Callback for CreateFile for |exclusive|=false cases.
   void DidEnsureFileExistsNonExclusive(base::PlatformFileError rv,
                                        bool created);
 
   // Generic callback that translates platform errors to WebKit error codes.
   void DidFinishFileOperation(base::PlatformFileError rv);
@@ skipping 73 matching lines @@
   // function and store the results to operation_context_ and
   // *_virtual_path_.
   // Return the result of VerifyFileSystem*().
   bool SetupSrcContextForRead(const GURL& path);
   bool SetupSrcContextForWrite(const GURL& path, bool create);
   bool SetupDestContextForWrite(const GURL& path, bool create);
 
 #ifndef NDEBUG
   enum OperationType {
     kOperationNone,
-    kOperationOpenFileSystem,
     kOperationCreateFile,
     kOperationCreateDirectory,
     kOperationCopy,
     kOperationMove,
     kOperationDirectoryExists,
     kOperationFileExists,
     kOperationGetMetadata,
     kOperationReadDirectory,
     kOperationRemove,
     kOperationWrite,
@@ skipping 15 matching lines @@
   scoped_ptr<FileSystemCallbackDispatcher> dispatcher_;
 
   FileSystemOperationContext operation_context_;
 
   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_;
+  scoped_ptr<FileSystemCallbackDispatcher> cancel_dispatcher_;
 
   // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperation);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_OPERATION_H_