Change webkit/{fileapi,quota} code to use TaskRunner.

webkit/fileapi/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/fileapi/file_system_operation.h"
 
 #include "base/bind.h"
+#include "base/sequenced_task_runner.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_quota_util.h"
@@ skipping 57 matching lines @@
     : type(kFileSystemTypeUnknown) {
 }
 
 FileSystemOperation::TaskParamsForDidGetQuota::~TaskParamsForDidGetQuota() {}
 
 FileSystemOperation::~FileSystemOperation() {
   if (file_writer_delegate_.get()) {
     FileSystemOperationContext* c =
         new FileSystemOperationContext(operation_context_);
     base::FileUtilProxy::RelayClose(
-        proxy_,
+        file_system_context()->file_task_runner(),
         base::Bind(&FileSystemFileUtil::Close,
                    base::Unretained(src_util_),
                    base::Owned(c)),
         file_writer_delegate_->file(),
         base::FileUtilProxy::StatusCallback());
   }
 }
 
 void FileSystemOperation::CreateFile(const GURL& path_url,
                                      bool exclusive,
@@ skipping 87 matching lines @@
 
   base::PlatformFileError result = SetUpFileSystemPath(
       path_url, &src_path_, &src_util_, PATH_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
-      proxy_, &operation_context_, src_util_, src_path_,
+      &operation_context_, src_util_, src_path_,
       base::Bind(&FileSystemOperation::DidDirectoryExists,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::FileExists(const GURL& path_url,
                                      const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationFileExists));
 
   base::PlatformFileError result = SetUpFileSystemPath(
       path_url, &src_path_, &src_util_, PATH_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
-      proxy_, &operation_context_, src_util_, src_path_,
+      &operation_context_, src_util_, src_path_,
       base::Bind(&FileSystemOperation::DidFileExists,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::GetMetadata(const GURL& path_url,
                                       const GetMetadataCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationGetMetadata));
 
   base::PlatformFileError result = SetUpFileSystemPath(
       path_url, &src_path_, &src_util_, PATH_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result, base::PlatformFileInfo(), FilePath());
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
-      proxy_, &operation_context_, src_util_, src_path_,
+      &operation_context_, src_util_, src_path_,
       base::Bind(&FileSystemOperation::DidGetMetadata,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::ReadDirectory(const GURL& path_url,
                                         const ReadDirectoryCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationReadDirectory));
 
   base::PlatformFileError result = SetUpFileSystemPath(
       path_url, &src_path_, &src_util_, PATH_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result, std::vector<base::FileUtilProxy::Entry>(), false);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::ReadDirectory(
-      proxy_, &operation_context_, src_util_, src_path_,
+      &operation_context_, src_util_, src_path_,
       base::Bind(&FileSystemOperation::DidReadDirectory,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::Remove(const GURL& path_url, bool recursive,
                                  const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
 
   base::PlatformFileError result = SetUpFileSystemPath(
       path_url, &src_path_, &src_util_, PATH_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   scoped_quota_notifier_.reset(new ScopedQuotaNotifier(
       file_system_context(), src_path_.origin(), src_path_.type()));
 
   FileSystemFileUtilProxy::Delete(
-      proxy_, &operation_context_, src_util_, src_path_, recursive,
+      &operation_context_, src_util_, src_path_, recursive,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::Write(
     const net::URLRequestContext* url_request_context,
     const GURL& path_url,
     const GURL& blob_url,
     int64 offset,
     const WriteCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationWrite));
 
   base::PlatformFileError result = SetUpFileSystemPath(
       path_url, &src_path_, &src_util_, PATH_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result, 0, false);
     delete this;
     return;
   }
   DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(
-          this, src_path_, offset, proxy_));
+          this, src_path_, offset));
   set_write_callback(callback);
   blob_request_.reset(
       new net::URLRequest(blob_url, file_writer_delegate_.get()));
   blob_request_->set_context(url_request_context);
 
   GetUsageAndQuotaThenRunTask(
       src_path_.origin(), src_path_.type(),
       base::Bind(&FileSystemOperation::DoWrite, base::Unretained(this)),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED, 0, true));
 }
@@ skipping 24 matching lines @@
 
   base::PlatformFileError result = SetUpFileSystemPath(
       path_url, &src_path_, &src_util_, PATH_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::Touch(
-      proxy_, &operation_context_, src_util_, src_path_,
+      &operation_context_, src_util_, src_path_,
       last_access_time, last_modified_time,
       base::Bind(&FileSystemOperation::DidTouchFile,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::OpenFile(const GURL& path_url,
                                    int file_flags,
                                    base::ProcessHandle peer_handle,
                                    const OpenFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationOpenFile));
@@ skipping 91 matching lines @@
   delete this;
 }
 
 void FileSystemOperation::CreateSnapshotFile(
     const GURL& path_url,
     const SnapshotFileCallback& callback) {
   GetMetadata(path_url, base::Bind(&GetMetadataForSnapshot, callback));
 }
 
 FileSystemOperation::FileSystemOperation(
-    scoped_refptr<base::MessageLoopProxy> proxy,
     FileSystemContext* file_system_context)
-    : proxy_(proxy),
-      operation_context_(file_system_context),
+    : operation_context_(file_system_context),
       src_util_(NULL),
       dest_util_(NULL),
       peer_handle_(base::kNullProcessHandle),
       pending_operation_(kOperationNone) {
 }
 
 void FileSystemOperation::GetUsageAndQuotaThenRunTask(
     const GURL& origin, FileSystemType type,
     const base::Closure& task,
     const base::Closure& error_callback) {
@@ skipping 37 matching lines @@
   scoped_quota_notifier_.reset(new ScopedQuotaNotifier(
       file_system_context(), params.origin, params.type));
 
   params.task.Run();
 }
 
 void FileSystemOperation::DoCreateFile(
     const StatusCallback& callback,
     bool exclusive) {
   FileSystemFileUtilProxy::EnsureFileExists(
-      proxy_, &operation_context_, src_util_, src_path_,
+      &operation_context_,
+      src_util_, src_path_,
       base::Bind(
           exclusive ? &FileSystemOperation::DidEnsureFileExistsExclusive
                     : &FileSystemOperation::DidEnsureFileExistsNonExclusive,
           base::Owned(this), callback));
 }
 
 void FileSystemOperation::DoCreateDirectory(
     const StatusCallback& callback,
     bool exclusive, bool recursive) {
   FileSystemFileUtilProxy::CreateDirectory(
-      proxy_, &operation_context_, src_util_, src_path_, exclusive, recursive,
+      &operation_context_,
+      src_util_, src_path_, exclusive, recursive,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::DoCopy(const StatusCallback& callback) {
   FileSystemFileUtilProxy::Copy(
-      proxy_, &operation_context_,
+      &operation_context_,
       src_util_, dest_util_,
       src_path_, dest_path_,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::DoMove(const StatusCallback& callback) {
   FileSystemFileUtilProxy::Move(
-      proxy_, &operation_context_,
+      &operation_context_,
       src_util_, dest_util_,
       src_path_, dest_path_,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::DoWrite() {
   int file_flags = base::PLATFORM_FILE_OPEN |
                    base::PLATFORM_FILE_WRITE |
                    base::PLATFORM_FILE_ASYNC;
 
   FileSystemFileUtilProxy::CreateOrOpen(
-      proxy_, &operation_context_, src_util_, src_path_, file_flags,
+      &operation_context_, src_util_, src_path_, file_flags,
       base::Bind(&FileSystemOperation::OnFileOpenedForWrite,
                  base::Unretained(this)));
 }
 
 void FileSystemOperation::DoTruncate(const StatusCallback& callback,
                                      int64 length) {
   FileSystemFileUtilProxy::Truncate(
-      proxy_, &operation_context_, src_util_, src_path_, length,
+      &operation_context_, src_util_, src_path_, length,
       base::Bind(&FileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::DoOpenFile(const OpenFileCallback& callback,
                                      int file_flags) {
   FileSystemFileUtilProxy::CreateOrOpen(
-      proxy_, &operation_context_, src_util_, src_path_, file_flags,
+      &operation_context_, src_util_, src_path_, file_flags,
       base::Bind(&FileSystemOperation::DidOpenFile,
                  base::Owned(this), callback));
 }
 
 void FileSystemOperation::DidEnsureFileExistsExclusive(
     const StatusCallback& callback,
     base::PlatformFileError rv, bool created) {
   if (rv == base::PLATFORM_FILE_OK && !created) {
     callback.Run(base::PLATFORM_FILE_ERROR_EXISTS);
   } else {
@@ skipping 160 matching lines @@
 }
 
 bool FileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi