Make FileSystemOperation NOT self-destruct

webkit/browser/fileapi/local_file_system_operation.cc

 // 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.
 
 #include "webkit/browser/fileapi/local_file_system_operation.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time.h"
@@ skipping 27 matching lines @@
 }
 
 LocalFileSystemOperation::LocalFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* file_system_context,
     scoped_ptr<FileSystemOperationContext> operation_context)
     : file_system_context_(file_system_context),
       operation_context_(operation_context.Pass()),
       async_file_util_(NULL),
       peer_handle_(base::kNullProcessHandle),
-      pending_operation_(kOperationNone),
-      weak_factory_(this) {
+      pending_operation_(kOperationNone) {
   DCHECK(operation_context_.get());
   operation_context_->DetachUserDataThread();
   async_file_util_ = file_system_context_->GetAsyncFileUtil(url.type());
   DCHECK(async_file_util_);
 }
 
 LocalFileSystemOperation::~LocalFileSystemOperation() {
 }
 
 void LocalFileSystemOperation::CreateFile(const FileSystemURL& url,
                                           bool exclusive,
                                           const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateFile));
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoCreateFile,
-                 base::Unretained(this), url, callback, exclusive),
+                 AsWeakPtr(), url, callback, exclusive),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::CreateDirectory(const FileSystemURL& url,
                                                bool exclusive,
                                                bool recursive,
                                                const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateDirectory));
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoCreateDirectory,
-                 base::Unretained(this), url, callback, exclusive, recursive),
+                 AsWeakPtr(), url, callback, exclusive, recursive),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::Copy(const FileSystemURL& src_url,
                                     const FileSystemURL& dest_url,
                                     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopy));
   DCHECK(!recursive_operation_delegate_);
   recursive_operation_delegate_.reset(
       new CopyOrMoveOperationDelegate(
           file_system_context(),
           src_url, dest_url,
           CopyOrMoveOperationDelegate::OPERATION_COPY,
-          base::Bind(&LocalFileSystemOperation::DidFinishDelegatedOperation,
-                     base::Unretained(this), callback)));
+          base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                     AsWeakPtr(), callback)));
   recursive_operation_delegate_->RunRecursively();
 }
 
 void LocalFileSystemOperation::Move(const FileSystemURL& src_url,
                                     const FileSystemURL& dest_url,
                                     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationMove));
   DCHECK(!recursive_operation_delegate_);
   recursive_operation_delegate_.reset(
       new CopyOrMoveOperationDelegate(
           file_system_context(),
           src_url, dest_url,
           CopyOrMoveOperationDelegate::OPERATION_MOVE,
-          base::Bind(&LocalFileSystemOperation::DidFinishDelegatedOperation,
-                     base::Unretained(this), callback)));
+          base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                     AsWeakPtr(), callback)));
   recursive_operation_delegate_->RunRecursively();
 }
 
 void LocalFileSystemOperation::DirectoryExists(const FileSystemURL& url,
                                                const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationDirectoryExists));
   async_file_util_->GetFileInfo(
-      operation_context(), url,
+      operation_context_.Pass(), url,
       base::Bind(&LocalFileSystemOperation::DidDirectoryExists,
-                 base::Owned(this), callback));
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::FileExists(const FileSystemURL& url,
                                           const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationFileExists));
   async_file_util_->GetFileInfo(
-      operation_context(), url,
+      operation_context_.Pass(), url,
       base::Bind(&LocalFileSystemOperation::DidFileExists,
-                 base::Owned(this), callback));
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::GetMetadata(
     const FileSystemURL& url, const GetMetadataCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationGetMetadata));
-  async_file_util_->GetFileInfo(
-      operation_context(), url,
-      base::Bind(&LocalFileSystemOperation::DidGetMetadata,
-                 base::Owned(this), callback));
+  async_file_util_->GetFileInfo(operation_context_.Pass(), url, callback);
 }
 
 void LocalFileSystemOperation::ReadDirectory(
     const FileSystemURL& url, const ReadDirectoryCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationReadDirectory));
   async_file_util_->ReadDirectory(
-      operation_context(), url,
-      base::Bind(&LocalFileSystemOperation::DidReadDirectory,
-                 base::Owned(this), callback));
+      operation_context_.Pass(), url, callback);
 }
 
 void LocalFileSystemOperation::Remove(const FileSystemURL& url,
                                       bool recursive,
                                       const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
   DCHECK(!recursive_operation_delegate_);
   recursive_operation_delegate_.reset(
       new RemoveOperationDelegate(
           file_system_context(), url,
-          base::Bind(&LocalFileSystemOperation::DidFinishDelegatedOperation,
-                     base::Unretained(this), callback)));
+          base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                     AsWeakPtr(), callback)));
   if (recursive)
     recursive_operation_delegate_->RunRecursively();
   else
     recursive_operation_delegate_->Run();
 }
 
 void LocalFileSystemOperation::Write(
     const net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
     const GURL& blob_url,
     int64 offset,
     const WriteCallback& callback) {
   GetWriteClosure(url_request_context, url, blob_url, offset, callback).Run();
 }
 
 void LocalFileSystemOperation::Truncate(const FileSystemURL& url, int64 length,
                                         const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTruncate));
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoTruncate,
-                 base::Unretained(this), url, callback, length),
+                 AsWeakPtr(), url, callback, length),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::TouchFile(const FileSystemURL& url,
                                          const base::Time& last_access_time,
                                          const base::Time& last_modified_time,
                                          const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTouchFile));
   async_file_util_->Touch(
-      operation_context(), url,
+      operation_context_.Pass(), url,
       last_access_time, last_modified_time,
-      base::Bind(&LocalFileSystemOperation::DidTouchFile,
-                 base::Owned(this), callback));
+      base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::OpenFile(const FileSystemURL& url,
                                         int file_flags,
                                         base::ProcessHandle peer_handle,
                                         const OpenFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationOpenFile));
-  scoped_ptr<LocalFileSystemOperation> deleter(this);
-
   peer_handle_ = peer_handle;
 
   if (file_flags & (
       (base::PLATFORM_FILE_ENUMERATE | base::PLATFORM_FILE_TEMPORARY |
        base::PLATFORM_FILE_HIDDEN))) {
     callback.Run(base::PLATFORM_FILE_ERROR_FAILED,
                  base::kInvalidPlatformFileValue,
                  base::Closure(),
                  base::kNullProcessHandle);
     return;
   }
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoOpenFile,
-                 base::Unretained(deleter.release()),
+                 AsWeakPtr(),
                  url, callback, file_flags),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED,
                  base::kInvalidPlatformFileValue,
                  base::Closure(),
                  base::kNullProcessHandle));
 }
 
 // We can only get here on a write or truncate that's not yet completed.
 // We don't support cancelling any other operation at this time.
 void LocalFileSystemOperation::Cancel(const StatusCallback& cancel_callback) {
-  if (file_writer_delegate_) {
+  DCHECK(cancel_callback_.is_null());
+  cancel_callback_ = cancel_callback;
+
+  if (file_writer_delegate_.get()) {
     DCHECK_EQ(kOperationWrite, pending_operation_);
-
-    // 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.
-    const bool delete_now = file_writer_delegate_->Cancel();
-
-    if (!write_callback_.is_null()) {
-      // Notify the failure status to the ongoing operation's callback.
-      write_callback_.Run(base::PLATFORM_FILE_ERROR_ABORT, 0, false);
-    }
-    cancel_callback.Run(base::PLATFORM_FILE_OK);
-    write_callback_.Reset();
-
-    if (delete_now) {
-      delete this;
-      return;
-    }
+    // This will call DidWrite() with ABORT status code.
+    file_writer_delegate_->Cancel();
   } else {
+    // For truncate we have no way to cancel the inflight operation (for now).
+    // Let it just run and dispatch cancel callback later.
     DCHECK_EQ(kOperationTruncate, pending_operation_);
-    // 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_callback 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_callback_.is_null());
-    cancel_callback_ = cancel_callback;
   }
 }
 
 LocalFileSystemOperation*
 LocalFileSystemOperation::AsLocalFileSystemOperation() {
   return this;
 }
 
-void LocalFileSystemOperation::SyncGetPlatformPath(const FileSystemURL& url,
-                                                   base::FilePath* platform_path) {
+void LocalFileSystemOperation::SyncGetPlatformPath(
+    const FileSystemURL& url,
+    base::FilePath* platform_path) {
   DCHECK(SetPendingOperationType(kOperationGetLocalPath));
   FileSystemFileUtil* file_util = file_system_context()->GetFileUtil(
       url.type());
   DCHECK(file_util);
-  file_util->GetLocalFilePath(operation_context(), url, platform_path);
-
-  delete this;
+  file_util->GetLocalFilePath(operation_context_.get(), url, platform_path);
 }
 
 void LocalFileSystemOperation::CreateSnapshotFile(
     const FileSystemURL& url,
     const SnapshotFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateSnapshotFile));
   async_file_util_->CreateSnapshotFile(
-      operation_context(), url,
-      base::Bind(&LocalFileSystemOperation::DidCreateSnapshotFile,
-                 base::Owned(this), callback));
+      operation_context_.Pass(), url, callback);
 }
 
 void LocalFileSystemOperation::CopyInForeignFile(
     const base::FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopyInForeignFile));
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&LocalFileSystemOperation::DoCopyInForeignFile,
-                 base::Unretained(this), src_local_disk_file_path, dest_url,
+                 AsWeakPtr(), src_local_disk_file_path, dest_url,
                  callback),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::RemoveFile(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
   async_file_util_->DeleteFile(
-      operation_context(), url,
-      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
-                 base::Owned(this), callback));
+      operation_context_.Pass(), url,
+      base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::RemoveDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
   async_file_util_->DeleteDirectory(
-      operation_context(), url,
-      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
-                 base::Owned(this), callback));
+      operation_context_.Pass(), url,
+      base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::CopyFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopy));
   DCHECK(src_url.IsInSameFileSystem(dest_url));
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&LocalFileSystemOperation::DoCopyFileLocal,
-                 base::Unretained(this), src_url, dest_url, callback),
+                 AsWeakPtr(), src_url, dest_url, callback),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::MoveFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationMove));
   DCHECK(src_url.IsInSameFileSystem(dest_url));
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&LocalFileSystemOperation::DoMoveFileLocal,
-                 base::Unretained(this), src_url, dest_url, callback),
+                 AsWeakPtr(), src_url, dest_url, callback),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::GetUsageAndQuotaThenRunTask(
     const FileSystemURL& url,
     const base::Closure& task,
     const base::Closure& error_callback) {
   quota::QuotaManagerProxy* quota_manager_proxy =
       file_system_context()->quota_manager_proxy();
   if (!quota_manager_proxy ||
       !file_system_context()->GetQuotaUtil(url.type())) {
     // If we don't have the quota manager or the requested filesystem type
     // does not support quota, we should be able to let it go.
-    operation_context()->set_allowed_bytes_growth(kint64max);
+    operation_context_->set_allowed_bytes_growth(kint64max);
     task.Run();
     return;
   }
 
   DCHECK(quota_manager_proxy);
   DCHECK(quota_manager_proxy->quota_manager());
   quota_manager_proxy->quota_manager()->GetUsageAndQuota(
       url.origin(),
       FileSystemTypeToQuotaStorageType(url.type()),
       base::Bind(&LocalFileSystemOperation::DidGetUsageAndQuotaAndRunTask,
-                 weak_factory_.GetWeakPtr(), task, error_callback));
+                 AsWeakPtr(), task, error_callback));
 }
 
 void LocalFileSystemOperation::DidGetUsageAndQuotaAndRunTask(
     const base::Closure& task,
     const base::Closure& error_callback,
     quota::QuotaStatusCode status,
     int64 usage, int64 quota) {
   if (status != quota::kQuotaStatusOk) {
     LOG(WARNING) << "Got unexpected quota error : " << status;
     error_callback.Run();
     return;
   }
 
-  operation_context()->set_allowed_bytes_growth(quota - usage);
+  operation_context_->set_allowed_bytes_growth(quota - usage);
   task.Run();
 }
 
 base::Closure LocalFileSystemOperation::GetWriteClosure(
     const net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
     const GURL& blob_url,
     int64 offset,
     const WriteCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationWrite));
   scoped_ptr<FileStreamWriter> writer(
       file_system_context()->CreateFileStreamWriter(url, offset));
 
   if (!writer) {
     // Write is not supported.
     return base::Bind(&LocalFileSystemOperation::DidFailWrite,
-                      base::Owned(this), callback,
+                      AsWeakPtr(), callback,
                       base::PLATFORM_FILE_ERROR_SECURITY);
   }
 
   DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(
-      base::Bind(&LocalFileSystemOperation::DidWrite,
-                 weak_factory_.GetWeakPtr(), url),
+      base::Bind(&LocalFileSystemOperation::DidWrite, AsWeakPtr(),
+                 url, callback),
       writer.Pass()));
 
-  write_callback_ = callback;
   scoped_ptr<net::URLRequest> blob_request(url_request_context->CreateRequest(
       blob_url, file_writer_delegate_.get()));
 
   return base::Bind(&FileWriterDelegate::Start,
                     base::Unretained(file_writer_delegate_.get()),
                     base::Passed(&blob_request));
 }
 
 void LocalFileSystemOperation::DidFailWrite(
     const WriteCallback& callback,
     base::PlatformFileError result) {
   callback.Run(result, 0, false);
 }
 
 void LocalFileSystemOperation::DoCreateFile(
     const FileSystemURL& url,
     const StatusCallback& callback,
     bool exclusive) {
   async_file_util_->EnsureFileExists(
-      operation_context(), url,
+      operation_context_.Pass(), url,
       base::Bind(
           exclusive ?
               &LocalFileSystemOperation::DidEnsureFileExistsExclusive :
               &LocalFileSystemOperation::DidEnsureFileExistsNonExclusive,
-          base::Owned(this), callback));
+          AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::DoCreateDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback,
     bool exclusive, bool recursive) {
   async_file_util_->CreateDirectory(
-      operation_context(),
+      operation_context_.Pass(),
       url, exclusive, recursive,
-      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
-                 base::Owned(this), callback));
+      base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::DoCopyFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   async_file_util_->CopyFileLocal(
-      operation_context(), src_url, dest_url,
-      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
-                 base::Owned(this), callback));
+      operation_context_.Pass(), src_url, dest_url,
+      base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::DoMoveFileLocal(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   async_file_util_->MoveFileLocal(
-      operation_context(), src_url, dest_url,
-      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
-                 base::Owned(this), callback));
+      operation_context_.Pass(), src_url, dest_url,
+      base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::DoCopyInForeignFile(
     const base::FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   async_file_util_->CopyInForeignFile(
-      operation_context(),
+      operation_context_.Pass(),
       src_local_disk_file_path, dest_url,
-      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
-                 base::Owned(this), callback));
+      base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::DoTruncate(const FileSystemURL& url,
                                           const StatusCallback& callback,
                                           int64 length) {
   async_file_util_->Truncate(
-      operation_context(), url, length,
-      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
-                 base::Owned(this), callback));
+      operation_context_.Pass(), url, length,
+      base::Bind(&LocalFileSystemOperation::DidFinishOperation,
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::DoOpenFile(const FileSystemURL& url,
                                           const OpenFileCallback& callback,
                                           int file_flags) {
   async_file_util_->CreateOrOpen(
-      operation_context(), url, file_flags,
+      operation_context_.Pass(), url, file_flags,
       base::Bind(&LocalFileSystemOperation::DidOpenFile,
-                 base::Owned(this), callback));
+                 AsWeakPtr(), callback));
 }
 
 void LocalFileSystemOperation::DidEnsureFileExistsExclusive(
     const StatusCallback& callback,
     base::PlatformFileError rv, bool created) {
   if (rv == base::PLATFORM_FILE_OK && !created) {
     callback.Run(base::PLATFORM_FILE_ERROR_EXISTS);
   } else {
-    DidFinishFileOperation(callback, rv);
+    DidFinishOperation(callback, rv);
   }
 }
 
 void LocalFileSystemOperation::DidEnsureFileExistsNonExclusive(
     const StatusCallback& callback,
     base::PlatformFileError rv, bool /* created */) {
-  DidFinishFileOperation(callback, rv);
+  DidFinishOperation(callback, rv);
 }
 
-void LocalFileSystemOperation::DidFinishFileOperation(
+void LocalFileSystemOperation::DidFinishOperation(
     const StatusCallback& callback,
     base::PlatformFileError rv) {
   if (!cancel_callback_.is_null()) {
     DCHECK_EQ(kOperationTruncate, pending_operation_);
 
+    StatusCallback cancel_callback = cancel_callback_;
     callback.Run(base::PLATFORM_FILE_ERROR_ABORT);
-    cancel_callback_.Run(base::PLATFORM_FILE_OK);
-    cancel_callback_.Reset();
+    cancel_callback.Run(base::PLATFORM_FILE_OK);
   } else {
     callback.Run(rv);
   }
 }
 
-void LocalFileSystemOperation::DidFinishDelegatedOperation(
-    const StatusCallback& callback,
-    base::PlatformFileError rv) {
-  // The callback might be held by the delegate and Owned() may not work,
-  // so just explicitly delete this now.
-  callback.Run(rv);
-  delete this;
-}
-
 void LocalFileSystemOperation::DidDirectoryExists(
     const StatusCallback& callback,
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& unused) {
   if (rv == base::PLATFORM_FILE_OK && !file_info.is_directory)
     rv = base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
   callback.Run(rv);
 }
 
 void LocalFileSystemOperation::DidFileExists(
     const StatusCallback& callback,
     base::PlatformFileError rv,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& unused) {
   if (rv == base::PLATFORM_FILE_OK && file_info.is_directory)
     rv = base::PLATFORM_FILE_ERROR_NOT_A_FILE;
   callback.Run(rv);
 }
 
-void LocalFileSystemOperation::DidGetMetadata(
-    const GetMetadataCallback& callback,
-    base::PlatformFileError rv,
-    const base::PlatformFileInfo& file_info,
-    const base::FilePath& platform_path) {
-  callback.Run(rv, file_info, platform_path);
-}
-
-void LocalFileSystemOperation::DidReadDirectory(
-    const ReadDirectoryCallback& callback,
-    base::PlatformFileError rv,
-    const std::vector<DirectoryEntry>& entries,
-    bool has_more) {
-  callback.Run(rv, entries, has_more);
-}
-
 void LocalFileSystemOperation::DidWrite(
     const FileSystemURL& url,
+    const WriteCallback& write_callback,
     base::PlatformFileError rv,
     int64 bytes,
     FileWriterDelegate::WriteProgressStatus write_status) {
-  if (write_callback_.is_null()) {
-    // If cancelled, callback is already invoked and set to null in Cancel().
-    // We must not call it twice. Just shut down this operation object.
-    delete this;
-    return;
-  }
-
   const bool complete = (
       write_status != FileWriterDelegate::SUCCESS_IO_PENDING);
   if (complete && write_status != FileWriterDelegate::ERROR_WRITE_NOT_STARTED) {
-    operation_context()->change_observers()->Notify(
+    DCHECK(operation_context_);
+    operation_context_->change_observers()->Notify(
         &FileChangeObserver::OnModifyFile, MakeTuple(url));
   }
 
-  write_callback_.Run(rv, bytes, complete);
-  if (complete || rv != base::PLATFORM_FILE_OK)
-    delete this;
-}
-
-void LocalFileSystemOperation::DidTouchFile(const StatusCallback& callback,
-                                            base::PlatformFileError rv) {
-  callback.Run(rv);
+  StatusCallback cancel_callback = cancel_callback_;
+  write_callback.Run(rv, bytes, complete);
+  if (!cancel_callback.is_null())
+    cancel_callback.Run(base::PLATFORM_FILE_OK);
 }
 
 void LocalFileSystemOperation::DidOpenFile(
     const OpenFileCallback& callback,
     base::PlatformFileError rv,
     base::PassPlatformFile file,
     bool unused) {
   if (rv == base::PLATFORM_FILE_OK)
     CHECK_NE(base::kNullProcessHandle, peer_handle_);
   callback.Run(rv, file.ReleaseValue(),
                base::Bind(&NopCloseFileCallback),
                peer_handle_);
 }
 
-void LocalFileSystemOperation::DidCreateSnapshotFile(
-    const SnapshotFileCallback& callback,
-    base::PlatformFileError result,
-    const base::PlatformFileInfo& file_info,
-    const base::FilePath& platform_path,
-    const scoped_refptr<ShareableFileReference>& file_ref) {
-  callback.Run(result, file_info, platform_path, file_ref);
-}
-
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi