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

webkit/fileapi/sandbox_mount_point_provider.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/sandbox_mount_point_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop.h"
-#include "base/message_loop_proxy.h"
+#include "base/metrics/histogram.h"
 #include "base/rand_util.h"
+#include "base/single_thread_task_runner.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
-#include "base/metrics/histogram.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "webkit/fileapi/file_system_file_reader.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_options.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/obfuscated_file_util.h"
@@ skipping 272 matching lines @@
     FILE_PATH_LITERAL("FileSystem");
 
 const FilePath::CharType SandboxMountPointProvider::kNewFileSystemDirectory[] =
     FILE_PATH_LITERAL("File System");
 
 const FilePath::CharType
     SandboxMountPointProvider::kRenamedOldFileSystemDirectory[] =
         FILE_PATH_LITERAL("FS.old");
 
 SandboxMountPointProvider::SandboxMountPointProvider(
-    scoped_refptr<base::MessageLoopProxy> file_message_loop,
+    base::SingleThreadTaskRunner* file_task_runner,
     const FilePath& profile_path,
     const FileSystemOptions& file_system_options)
-    : FileSystemQuotaUtil(file_message_loop),
-      file_message_loop_(file_message_loop),
+    : FileSystemQuotaUtil(file_task_runner),
+      file_task_runner_(file_task_runner),
       profile_path_(profile_path),
       file_system_options_(file_system_options),
       sandbox_file_util_(
           new ObfuscatedFileUtil(
               profile_path.Append(kNewFileSystemDirectory),
               QuotaFileUtil::CreateDefault())) {
 }
 
 SandboxMountPointProvider::~SandboxMountPointProvider() {
-  if (!file_message_loop_->BelongsToCurrentThread()) {
-    ObfuscatedFileUtil* sandbox_file_util = sandbox_file_util_.release();
-    if (!file_message_loop_->ReleaseSoon(FROM_HERE, sandbox_file_util))
-      sandbox_file_util->Release();
-  }
+  ObfuscatedFileUtil* sandbox_file_util = sandbox_file_util_.release();
+  if (!file_task_runner_->ReleaseSoon(FROM_HERE, sandbox_file_util))
+    sandbox_file_util->Release();
 }
 
 void SandboxMountPointProvider::ValidateFileSystemRoot(
     const GURL& origin_url, fileapi::FileSystemType type, bool create,
     const ValidateFileSystemCallback& callback) {
   if (file_system_options_.is_incognito()) {
     // TODO(kinuko): return an isolated temporary directory.
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kIncognito,
                               kFileSystemErrorMax);
     return;
   }
 
   if (!IsAllowedScheme(origin_url)) {
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     UMA_HISTOGRAM_ENUMERATION(kOpenFileSystemLabel,
                               kInvalidScheme,
                               kFileSystemErrorMax);
     return;
   }
 
   base::PlatformFileError* error_ptr = new base::PlatformFileError;
-  file_message_loop_->PostTaskAndReply(
+  file_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&ValidateRootOnFileThread,
                  sandbox_file_util_,
                  origin_url, type, old_base_path(), create,
                  base::Unretained(error_ptr)),
       base::Bind(base::Bind(&PassPointerErrorByValue, callback),
                  base::Owned(error_ptr)));
 };
 
 FilePath
@@ skipping 60 matching lines @@
   // We simply return the very top directory of the sandbox
   // filesystem regardless of the input path.
   return new_base_path();
 }
 
 FileSystemOperationInterface*
 SandboxMountPointProvider::CreateFileSystemOperation(
     const GURL& origin_url,
     FileSystemType file_system_type,
     const FilePath& virtual_path,
-    base::MessageLoopProxy* file_proxy,
+    base::TaskRunner* file_task_runner,
     FileSystemContext* context) const {
-  return new FileSystemOperation(file_proxy, context);
+  return new FileSystemOperation(file_task_runner, context);
 }
 
 webkit_blob::FileReader* SandboxMountPointProvider::CreateFileReader(
     const GURL& url,
     int64 offset,
-    base::MessageLoopProxy* file_proxy,
+    base::TaskRunner* file_task_runner,
     FileSystemContext* context) const {
-  return new FileSystemFileReader(file_proxy, context, url, offset);
+  return new FileSystemFileReader(file_task_runner, context, url, offset);
 }
 
 FilePath SandboxMountPointProvider::old_base_path() const {
   return profile_path_.Append(kOldFileSystemDirectory);
 }
 
 FilePath SandboxMountPointProvider::new_base_path() const {
   return profile_path_.Append(kNewFileSystemDirectory);
 }
 
@@ skipping 217 matching lines @@
        i < file_system_options_.additional_allowed_schemes().size();
        ++i) {
     if (url.SchemeIs(
             file_system_options_.additional_allowed_schemes()[i].c_str()))
       return true;
   }
   return false;
 }
 
 }  // namespace fileapi