Make FileSystemOperation NOT self-destruct

webkit/browser/fileapi/local_file_system_operation.h

 // Copyright (c) 2012 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_BROWSER_FILEAPI_LOCAL_FILE_SYSTEM_OPERATION_H_
 #define WEBKIT_BROWSER_FILEAPI_LOCAL_FILE_SYSTEM_OPERATION_H_
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
+#include "webkit/browser/fileapi/file_system_operation_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/file_writer_delegate.h"
 #include "webkit/common/blob/scoped_file.h"
 #include "webkit/common/quota/quota_types.h"
 #include "webkit/storage/webkit_storage_export.h"
 
 namespace chromeos {
 class CrosMountPointProvider;
 }
 
 namespace sync_file_system {
 class SyncableFileSystemOperation;
 }
 
 namespace fileapi {
 
 class AsyncFileUtil;
 class FileSystemContext;
 class RecursiveOperationDelegate;
 
 // FileSystemOperation implementation for local file systems.
 class WEBKIT_STORAGE_EXPORT LocalFileSystemOperation
-    : public NON_EXPORTED_BASE(FileSystemOperation) {
+    : public NON_EXPORTED_BASE(FileSystemOperation),
+      public base::SupportsWeakPtr<LocalFileSystemOperation> {
  public:
   // NOTE: This constructor should not be called outside MountPointProviders;
   // instead please consider using
   // file_system_context->CreateFileSystemOperation() to instantiate
   // an appropriate FileSystemOperation.
   LocalFileSystemOperation(
       const FileSystemURL& url,
       FileSystemContext* file_system_context,
       scoped_ptr<FileSystemOperationContext> operation_context);
 
@@ skipping 112 matching lines @@
                      const StatusCallback& callback);
 
   // Synchronously gets the platform path for the given |url|.
   void SyncGetPlatformPath(const FileSystemURL& url,
                            base::FilePath* platform_path);
 
   FileSystemContext* file_system_context() const {
     return file_system_context_.get();
   }
 
-  FileSystemOperationContext* operation_context() const {
-    return operation_context_.get();
-  }
-
  private:
   friend class sync_file_system::SyncableFileSystemOperation;
 
   // Queries the quota and usage and then runs the given |task|.
   // If an error occurs during the quota query it runs |error_callback| instead.
   void GetUsageAndQuotaThenRunTask(
       const FileSystemURL& url,
       const base::Closure& task,
       const base::Closure& error_callback);
 
@@ skipping 44 matching lines @@
   // Callback for CreateFile for |exclusive|=true cases.
   void DidEnsureFileExistsExclusive(const StatusCallback& callback,
                                     base::PlatformFileError rv,
                                     bool created);
 
   // Callback for CreateFile for |exclusive|=false cases.
   void DidEnsureFileExistsNonExclusive(const StatusCallback& callback,
                                        base::PlatformFileError rv,
                                        bool created);
 
-  // Generic callback that translates platform errors to WebKit error codes.
-  void DidFinishFileOperation(const StatusCallback& callback,
-                              base::PlatformFileError rv);
-
-  // Generic callback when we delegated the operation.
-  void DidFinishDelegatedOperation(const StatusCallback& callback,
-                                   base::PlatformFileError rv);
-
+  void DidFinishOperation(const StatusCallback& callback,
+                          base::PlatformFileError rv);
   void DidDirectoryExists(const StatusCallback& callback,
                           base::PlatformFileError rv,
                           const base::PlatformFileInfo& file_info,
                           const base::FilePath& unused);
   void DidFileExists(const StatusCallback& callback,
                      base::PlatformFileError rv,
                      const base::PlatformFileInfo& file_info,
                      const base::FilePath& unused);
-  void DidGetMetadata(const GetMetadataCallback& callback,
-                      base::PlatformFileError rv,
-                      const base::PlatformFileInfo& file_info,
-                      const base::FilePath& platform_path);
-  void DidReadDirectory(const ReadDirectoryCallback& callback,
-                        base::PlatformFileError rv,
-                        const std::vector<DirectoryEntry>& entries,
-                        bool has_more);
   void DidWrite(const FileSystemURL& url,
+                const WriteCallback& callback,
                 base::PlatformFileError rv,
                 int64 bytes,
                 FileWriterDelegate::WriteProgressStatus write_status);
-  void DidTouchFile(const StatusCallback& callback,
-                    base::PlatformFileError rv);
   void DidOpenFile(const OpenFileCallback& callback,
                    base::PlatformFileError rv,
                    base::PassPlatformFile file,
                    bool created);
-  void DidCreateSnapshotFile(
-      const SnapshotFileCallback& callback,
-      base::PlatformFileError result,
-      const base::PlatformFileInfo& file_info,
-      const base::FilePath& platform_path,
-      const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref);
 
   // Used only for internal assertions.
   // Returns false if there's another inflight pending operation.
   bool SetPendingOperationType(OperationType type);
 
   scoped_refptr<FileSystemContext> file_system_context_;
 
   scoped_ptr<FileSystemOperationContext> operation_context_;
   AsyncFileUtil* async_file_util_;  // Not owned.
 
-  // These are all used only by Write().
-  friend class FileWriterDelegate;
   scoped_ptr<FileWriterDelegate> file_writer_delegate_;
-
   scoped_ptr<RecursiveOperationDelegate> recursive_operation_delegate_;
 
-  // write_callback is kept in this class for so that we can dispatch it when
-  // the operation is cancelled. calcel_callback is kept for canceling a
-  // Truncate() operation. We can't actually stop Truncate in another thread;
-  // after it resumed from the working thread, cancellation takes place.
-  WriteCallback write_callback_;
   StatusCallback cancel_callback_;
 
   // Used only by OpenFile, in order to clone the file handle back to the
   // requesting process.
   base::ProcessHandle peer_handle_;
 
   // A flag to make sure we call operation only once per instance.
   OperationType pending_operation_;
 
-  // LocalFileSystemOperation instance is usually deleted upon completion but
-  // could be deleted while it has inflight callbacks when Cancel is called.
-  base::WeakPtrFactory<LocalFileSystemOperation> weak_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(LocalFileSystemOperation);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_BROWSER_FILEAPI_LOCAL_FILE_SYSTEM_OPERATION_H_