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

webkit/fileapi/file_system_operation.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_operation.h"
 
 #include "base/bind.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
@@ skipping 45 matching lines @@
     quota_util_->proxy()->EndUpdateOrigin(origin_url_, type_);
   }
 }
 
 FileSystemOperation::FileSystemOperation(
     FileSystemCallbackDispatcher* dispatcher,
     scoped_refptr<base::MessageLoopProxy> proxy,
     FileSystemContext* file_system_context)
     : proxy_(proxy),
       dispatcher_(dispatcher),
-      operation_context_(file_system_context, NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+      operation_context_(file_system_context, NULL) {
 #ifndef NDEBUG
   pending_operation_ = kOperationNone;
 #endif
 }
 
 FileSystemOperation::~FileSystemOperation() {
-  if (file_writer_delegate_.get())
-    FileSystemFileUtilProxy::Close(
-        operation_context_, proxy_, file_writer_delegate_->file(),
-        FileSystemFileUtilProxy::StatusCallback());
+  if (file_writer_delegate_.get()) {
+    FileSystemOperationContext* c =
+        new FileSystemOperationContext(operation_context_);
+    base::FileUtilProxy::RelayClose(
+        proxy_,
+        base::Bind(&FileSystemFileUtil::Close,
+                   base::Unretained(c->src_file_util()),
+                   base::Owned(c)),
+        file_writer_delegate_->file(),
+        base::FileUtilProxy::StatusCallback());
+  }
 }
 
 void FileSystemOperation::OpenFileSystem(
     const GURL& origin_url, fileapi::FileSystemType type, bool create) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = static_cast<FileSystemOperation::OperationType>(
       kOperationOpenFileSystem);
 #endif
 
   DCHECK(file_system_context());
   operation_context_.set_src_origin_url(origin_url);
   operation_context_.set_src_type(type);
   // TODO(ericu): We don't really need to make this call if !create.
   // Also, in the future we won't need it either way, as long as we do all
   // permission+quota checks beforehand.  We only need it now because we have to
   // create an unpredictable directory name.  Without that, we could lazily
   // create the root later on the first filesystem write operation, and just
   // return GetFileSystemRootURI() here.
   file_system_context()->path_manager()->ValidateFileSystemRootAndGetURL(
       origin_url, type, create,
       base::Bind(&FileSystemOperation::DidGetRootPath,
-                 weak_factory_.GetWeakPtr()));
+                 base::Owned(this)));
 }
 
 void FileSystemOperation::CreateFile(const GURL& path,
                                      bool exclusive) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateFile;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
-  exclusive_ = exclusive;
-
   GetUsageAndQuotaThenCallback(
       operation_context_.src_origin_url(),
       base::Bind(&FileSystemOperation::DelayedCreateFileForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 base::Unretained(this), exclusive));
 }
 
 void FileSystemOperation::DelayedCreateFileForQuota(
+    bool exclusive,
     quota::QuotaStatusCode status, int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.src_origin_url(),
       operation_context_.src_type()));
 
   FileSystemFileUtilProxy::EnsureFileExists(
       operation_context_,
       proxy_,
       src_virtual_path_,
       base::Bind(
-          exclusive_ ? &FileSystemOperation::DidEnsureFileExistsExclusive
-                     : &FileSystemOperation::DidEnsureFileExistsNonExclusive,
-          weak_factory_.GetWeakPtr()));
+          exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive
+                    : &FileSystemOperation::DidEnsureFileExistsNonExclusive,
+          base::Owned(this)));
 }
 
 void FileSystemOperation::CreateDirectory(const GURL& path,
                                           bool exclusive,
                                           bool recursive) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateDirectory;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
-  exclusive_ = exclusive;
-  recursive_ = recursive;
-
   GetUsageAndQuotaThenCallback(
       operation_context_.src_origin_url(),
       base::Bind(&FileSystemOperation::DelayedCreateDirectoryForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 base::Unretained(this), exclusive, recursive));
 }
 
 void FileSystemOperation::DelayedCreateDirectoryForQuota(
+    bool exclusive, bool recursive,
     quota::QuotaStatusCode status, int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.src_origin_url(),
       operation_context_.src_type()));
 
-  FileSystemFileUtilProxy::CreateDirectory(
-      operation_context_, proxy_, src_virtual_path_, exclusive_,
-      recursive_,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::CreateDirectory,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_,
+                 src_virtual_path_, exclusive, recursive),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
-                 weak_factory_.GetWeakPtr()));
+                 base::Owned(this)));
 }
 
 void FileSystemOperation::Copy(const GURL& src_path,
                                const GURL& dest_path) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCopy;
 #endif
   if (!SetupSrcContextForRead(src_path) ||
       !SetupDestContextForWrite(dest_path, true)) {
     delete this;
     return;
   }
 
   GetUsageAndQuotaThenCallback(
       operation_context_.dest_origin_url(),
       base::Bind(&FileSystemOperation::DelayedCopyForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 base::Unretained(this)));
 }
 
 void FileSystemOperation::DelayedCopyForQuota(quota::QuotaStatusCode status,
                                               int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.dest_origin_url(),
       operation_context_.dest_type()));
 
-  FileSystemFileUtilProxy::Copy(
-      operation_context_, proxy_, src_virtual_path_,
-      dest_virtual_path_,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Copy,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_,
+                 src_virtual_path_, dest_virtual_path_),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
-                 weak_factory_.GetWeakPtr()));
+                 base::Owned(this)));
 }
 
 void FileSystemOperation::Move(const GURL& src_path,
                                const GURL& dest_path) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationMove;
 #endif
   if (!SetupSrcContextForWrite(src_path, false) ||
       !SetupDestContextForWrite(dest_path, true)) {
     delete this;
     return;
   }
 
   GetUsageAndQuotaThenCallback(
       operation_context_.dest_origin_url(),
       base::Bind(&FileSystemOperation::DelayedMoveForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 base::Unretained(this)));
 }
 
 void FileSystemOperation::DelayedMoveForQuota(quota::QuotaStatusCode status,
                                               int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.dest_origin_url(),
       operation_context_.dest_type()));
 
-  FileSystemFileUtilProxy::Move(
-      operation_context_, proxy_, src_virtual_path_,
-      dest_virtual_path_,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Move,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_,
+                 src_virtual_path_, dest_virtual_path_),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
-                 weak_factory_.GetWeakPtr()));
+                 base::Owned(this)));
 }
 
 void FileSystemOperation::DirectoryExists(const GURL& path) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationDirectoryExists;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
       operation_context_, proxy_, src_virtual_path_,
-      base::Bind(&FileSystemOperation::DidDirectoryExists,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&FileSystemOperation::DidDirectoryExists, base::Owned(this)));
 }
 
 void FileSystemOperation::FileExists(const GURL& path) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationFileExists;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
       operation_context_, proxy_, src_virtual_path_,
-      base::Bind(&FileSystemOperation::DidFileExists,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&FileSystemOperation::DidFileExists, base::Owned(this)));
 }
 
 void FileSystemOperation::GetMetadata(const GURL& path) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationGetMetadata;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
       operation_context_, proxy_, src_virtual_path_,
-      base::Bind(&FileSystemOperation::DidGetMetadata,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&FileSystemOperation::DidGetMetadata, base::Owned(this)));
 }
 
 void FileSystemOperation::ReadDirectory(const GURL& path) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationReadDirectory;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::ReadDirectory(
       operation_context_, proxy_, src_virtual_path_,
-      base::Bind(&FileSystemOperation::DidReadDirectory,
-                 weak_factory_.GetWeakPtr()));
+      base::Bind(&FileSystemOperation::DidReadDirectory, base::Owned(this)));
 }
 
 void FileSystemOperation::Remove(const GURL& path, bool recursive) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationRemove;
 #endif
   if (!SetupSrcContextForWrite(path, false)) {
     delete this;
     return;
   }
 
-  FileSystemFileUtilProxy::Delete(
-      operation_context_, proxy_, src_virtual_path_, recursive,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Delete,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_,
+                 src_virtual_path_, recursive),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
-                 weak_factory_.GetWeakPtr()));
+                 base::Owned(this)));
 }
 
 void FileSystemOperation::Write(
     scoped_refptr<net::URLRequestContext> url_request_context,
     const GURL& path,
     const GURL& blob_url,
     int64 offset) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationWrite;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
   DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(this, offset, proxy_));
   blob_request_.reset(
       new net::URLRequest(blob_url, file_writer_delegate_.get()));
   blob_request_->set_context(url_request_context);
 
   GetUsageAndQuotaThenCallback(
       operation_context_.src_origin_url(),
       base::Bind(&FileSystemOperation::DelayedWriteForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 base::Unretained(this)));
 }
 
 void FileSystemOperation::DelayedWriteForQuota(quota::QuotaStatusCode status,
                                                int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.src_origin_url(),
       operation_context_.src_type()));
 
-  FileSystemFileUtilProxy::CreateOrOpen(
-      operation_context_,
+  int file_flags = base::PLATFORM_FILE_OPEN |
+                   base::PLATFORM_FILE_WRITE |
+                   base::PLATFORM_FILE_ASYNC;
+
+  base::FileUtilProxy::RelayCreateOrOpen(
       proxy_,
-      src_virtual_path_,
-      base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
-          base::PLATFORM_FILE_ASYNC,
+      base::Bind(&FileSystemFileUtil::CreateOrOpen,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_,
+                 src_virtual_path_, file_flags),
+      base::Bind(&FileSystemFileUtil::Close,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_),
       base::Bind(&FileSystemOperation::OnFileOpenedForWrite,
-                 weak_factory_.GetWeakPtr()));
+                 base::Unretained(this)));
 }
 
 void FileSystemOperation::Truncate(const GURL& path, int64 length) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTruncate;
 #endif
   if (!SetupSrcContextForWrite(path, false)) {
     delete this;
     return;
   }
-  length_ = length;
-
   GetUsageAndQuotaThenCallback(
       operation_context_.src_origin_url(),
       base::Bind(&FileSystemOperation::DelayedTruncateForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 base::Unretained(this), length));
 }
 
-void FileSystemOperation::DelayedTruncateForQuota(quota::QuotaStatusCode status,
+void FileSystemOperation::DelayedTruncateForQuota(int64 length,
+                                                  quota::QuotaStatusCode status,
                                                   int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.src_origin_url(),
       operation_context_.src_type()));
 
-  FileSystemFileUtilProxy::Truncate(
-      operation_context_, proxy_, src_virtual_path_, length_,
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Truncate,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_,
+                 src_virtual_path_, length),
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
-                 weak_factory_.GetWeakPtr()));
+                 base::Owned(this)));
 }
 
 void FileSystemOperation::TouchFile(const GURL& path,
                                     const base::Time& last_access_time,
                                     const base::Time& last_modified_time) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationTouchFile;
 #endif
   if (!SetupSrcContextForWrite(path, true)) {
     delete this;
     return;
   }
 
-  FileSystemFileUtilProxy::Touch(
-      operation_context_, proxy_, src_virtual_path_,
-      last_access_time, last_modified_time,
-      base::Bind(&FileSystemOperation::DidTouchFile,
-                 weak_factory_.GetWeakPtr()));
+  base::FileUtilProxy::RelayFileTask(
+      proxy_, FROM_HERE,
+      base::Bind(&FileSystemFileUtil::Touch,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_,
+                 src_virtual_path_, last_access_time, last_modified_time),
+      base::Bind(&FileSystemOperation::DidTouchFile, base::Owned(this)));
 }
 
 void FileSystemOperation::OpenFile(const GURL& path,
                                    int file_flags,
                                    base::ProcessHandle peer_handle) {
 #ifndef NDEBUG
-  DCHECK(dispatcher_.get());
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationOpenFile;
 #endif
   peer_handle_ = peer_handle;
 
   if (file_flags & (
       (base::PLATFORM_FILE_ENUMERATE | base::PLATFORM_FILE_TEMPORARY |
        base::PLATFORM_FILE_HIDDEN))) {
     delete this;
     return;
   }
   if (file_flags &
       (base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_OPEN_ALWAYS |
        base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_OPEN_TRUNCATED |
        base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_WRITE |
        base::PLATFORM_FILE_DELETE_ON_CLOSE |
        base::PLATFORM_FILE_WRITE_ATTRIBUTES)) {
     if (!SetupSrcContextForWrite(path, true)) {
       delete this;
       return;
     }
   } else {
     if (!SetupSrcContextForRead(path)) {
       delete this;
       return;
     }
   }
-  file_flags_ = file_flags;
-
   GetUsageAndQuotaThenCallback(
       operation_context_.src_origin_url(),
       base::Bind(&FileSystemOperation::DelayedOpenFileForQuota,
-                 weak_factory_.GetWeakPtr()));
+                 base::Unretained(this), file_flags));
 }
 
-void FileSystemOperation::DelayedOpenFileForQuota(quota::QuotaStatusCode status,
+void FileSystemOperation::DelayedOpenFileForQuota(int file_flags,
+                                                  quota::QuotaStatusCode status,
                                                   int64 usage, int64 quota) {
   operation_context_.set_allowed_bytes_growth(quota - usage);
 
   quota_util_helper_.reset(new ScopedQuotaUtilHelper(
       file_system_context(),
       operation_context_.src_origin_url(),
       operation_context_.src_type()));
 
-  FileSystemFileUtilProxy::CreateOrOpen(
-      operation_context_, proxy_, src_virtual_path_, file_flags_,
-      base::Bind(&FileSystemOperation::DidOpenFile,
-                 weak_factory_.GetWeakPtr()));
+  base::FileUtilProxy::RelayCreateOrOpen(
+      proxy_,
+      base::Bind(&FileSystemFileUtil::CreateOrOpen,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_,
+                 src_virtual_path_, file_flags),
+      base::Bind(&FileSystemFileUtil::Close,
+                 base::Unretained(operation_context_.src_file_util()),
+                 &operation_context_),
+      base::Bind(&FileSystemOperation::DidOpenFile, base::Owned(this)));
 }
 
 void FileSystemOperation::SyncGetPlatformPath(const GURL& path,
                                               FilePath* platform_path) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationGetLocalPath;
 #endif
   if (!SetupSrcContextForRead(path)) {
     delete this;
@@ skipping 16 matching lines @@
 #endif
     // Writes are done without proxying through FileUtilProxy after the initial
     // opening of the PlatformFile.  All state changes are done on this thread,
     // so we're guaranteed to be able to shut down atomically.  We do need to
     // check that the file has been opened [which means the blob_request_ has
     // been created], so we know how much we need to do.
     if (blob_request_.get())
       // This halts any calls to file_writer_delegate_ from blob_request_.
       blob_request_->Cancel();
 
-    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
+    if (dispatcher_.get())
+      dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
     cancel_operation->dispatcher_->DidSucceed();
-    delete this;
+    dispatcher_.reset();
   } else {
 #ifndef NDEBUG
     DCHECK(kOperationTruncate == pending_operation_);
 #endif
     // We're cancelling a truncate operation, but we can't actually stop it
     // since it's been proxied to another thread.  We need to save the
     // cancel_operation so that when the truncate returns, it can see that it's
     // been cancelled, report it, and report that the cancel has succeeded.
     DCHECK(!cancel_operation_.get());
     cancel_operation_.swap(cancel_operation);
@@ skipping 20 matching lines @@
       FileSystemTypeToQuotaStorageType(
           operation_context_.src_type()),
       callback);
 }
 
 void FileSystemOperation::DidGetRootPath(
     bool success,
     const FilePath& path, const std::string& name) {
   DCHECK(success || path.empty());
   GURL result;
+  if (!dispatcher_.get())
+    return;
   // We ignore the path, and return a URL instead.  The point was just to verify
   // that we could create/find the path.
   if (success) {
     result = GetFileSystemRootURI(
         operation_context_.src_origin_url(),
         operation_context_.src_type());
   }
   dispatcher_->DidOpenFileSystem(name, result);
-  delete this;
 }
 
 void FileSystemOperation::DidEnsureFileExistsExclusive(
     base::PlatformFileError rv, bool created) {
   if (rv == base::PLATFORM_FILE_OK && !created) {
-    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_EXISTS);
-    delete this;
+    if (dispatcher_.get())
+      dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_EXISTS);
   } else {
     DidFinishFileOperation(rv);
   }
 }
 
 void FileSystemOperation::DidEnsureFileExistsNonExclusive(
     base::PlatformFileError rv, bool /* created */) {
   DidFinishFileOperation(rv);
 }
 
 void FileSystemOperation::DidFinishFileOperation(
     base::PlatformFileError rv) {
   if (cancel_operation_.get()) {
 #ifndef NDEBUG
     DCHECK(kOperationTruncate == pending_operation_);
 #endif
 
-    dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
+    if (dispatcher_.get())
+      dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_ABORT);
     cancel_operation_->dispatcher_->DidSucceed();
-  } else if (rv == base::PLATFORM_FILE_OK) {
-    dispatcher_->DidSucceed();
-  } else {
-    dispatcher_->DidFail(rv);
+  } else if (dispatcher_.get()) {
+    if (rv == base::PLATFORM_FILE_OK)
+      dispatcher_->DidSucceed();
+    else
+      dispatcher_->DidFail(rv);
   }
-  delete this;
 }
 
 void FileSystemOperation::DidDirectoryExists(
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
     const FilePath& unused) {
+  if (!dispatcher_.get())
+    return;
   if (rv == base::PLATFORM_FILE_OK) {
     if (file_info.is_directory)
       dispatcher_->DidSucceed();
     else
       dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY);
   } else {
     dispatcher_->DidFail(rv);
   }
-  delete this;
 }
 
 void FileSystemOperation::DidFileExists(
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
     const FilePath& unused) {
+  if (!dispatcher_.get())
+    return;
   if (rv == base::PLATFORM_FILE_OK) {
     if (file_info.is_directory)
       dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_NOT_A_FILE);
     else
       dispatcher_->DidSucceed();
   } else {
     dispatcher_->DidFail(rv);
   }
-  delete this;
 }
 
 void FileSystemOperation::DidGetMetadata(
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
     const FilePath& platform_path) {
+  if (!dispatcher_.get())
+    return;
   if (rv == base::PLATFORM_FILE_OK)
     dispatcher_->DidReadMetadata(file_info, platform_path);
   else
     dispatcher_->DidFail(rv);
-  delete this;
 }
 
 void FileSystemOperation::DidReadDirectory(
     base::PlatformFileError rv,
     const std::vector<base::FileUtilProxy::Entry>& entries) {
+  if (!dispatcher_.get())
+    return;
 
   if (rv == base::PLATFORM_FILE_OK)
     dispatcher_->DidReadDirectory(entries, false /* has_more */);
   else
     dispatcher_->DidFail(rv);
-  delete this;
 }
 
 void FileSystemOperation::DidWrite(
     base::PlatformFileError rv,
     int64 bytes,
     bool complete) {
+  if (!dispatcher_.get()) {
+    delete this;
+    return;
+  }
   if (rv == base::PLATFORM_FILE_OK)
     dispatcher_->DidWrite(bytes, complete);
   else
     dispatcher_->DidFail(rv);
   if (complete || rv != base::PLATFORM_FILE_OK)
     delete this;
 }
 
 void FileSystemOperation::DidTouchFile(base::PlatformFileError rv) {
+  if (!dispatcher_.get())
+    return;
   if (rv == base::PLATFORM_FILE_OK)
     dispatcher_->DidSucceed();
   else
     dispatcher_->DidFail(rv);
-  delete this;
 }
 
 void FileSystemOperation::DidOpenFile(
     base::PlatformFileError rv,
     base::PassPlatformFile file,
     bool unused) {
+  if (!dispatcher_.get())
+    return;
   if (rv == base::PLATFORM_FILE_OK)
     dispatcher_->DidOpenFile(file.ReleaseValue(), peer_handle_);
   else
     dispatcher_->DidFail(rv);
-  delete this;
 }
 
 void FileSystemOperation::OnFileOpenedForWrite(
     base::PlatformFileError rv,
     base::PassPlatformFile file,
     bool created) {
-  if (base::PLATFORM_FILE_OK != rv) {
-    dispatcher_->DidFail(rv);
+  if (base::PLATFORM_FILE_OK != rv || !dispatcher_.get()) {
+    if (dispatcher_.get())
+      dispatcher_->DidFail(rv);
     delete this;
     return;
   }
   file_writer_delegate_->Start(file.ReleaseValue(), blob_request_.get());
 }
 
 bool FileSystemOperation::VerifyFileSystemPathForRead(
     const GURL& path, GURL* origin_url, FileSystemType* type,
     FilePath* virtual_path, FileSystemFileUtil** file_util) {
 
@@ skipping 135 matching lines @@
   bool result = VerifyFileSystemPathForWrite(
       path, create, &origin_url, &type, &dest_virtual_path_, &file_util);
   operation_context_.set_dest_origin_url(origin_url);
   operation_context_.set_dest_type(type);
   if (!operation_context_.dest_file_util())
     operation_context_.set_dest_file_util(file_util);
   return result;
 }
 
 }  // namespace fileapi