Deprecate FileSystemTaskRunners

webkit/browser/fileapi/file_system_context.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/file_system_context.h"
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "url/gurl.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/copy_or_move_file_validator.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_permission_policy.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
 #include "webkit/browser/fileapi/file_system_file_util.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_options.h"
 #include "webkit/browser/fileapi/file_system_quota_client.h"
-#include "webkit/browser/fileapi/file_system_task_runners.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/isolated_context.h"
 #include "webkit/browser/fileapi/isolated_file_system_backend.h"
 #include "webkit/browser/fileapi/mount_points.h"
 #include "webkit/browser/fileapi/sandbox_file_system_backend.h"
 #include "webkit/browser/fileapi/test_file_system_backend.h"
 #include "webkit/browser/quota/quota_manager.h"
 #include "webkit/browser/quota/special_storage_policy.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
@@ skipping 58 matching lines @@
     case kFileSystemInternalTypeEnumEnd:
     case kFileSystemInternalTypeEnumStart:
     case kFileSystemTypeUnknown:
       return FILE_PERMISSION_ALWAYS_DENY;
   }
   NOTREACHED();
   return FILE_PERMISSION_ALWAYS_DENY;
 }
 
 FileSystemContext::FileSystemContext(
-    scoped_ptr<FileSystemTaskRunners> task_runners,
+    base::SingleThreadTaskRunner* io_task_runner,
+    base::SequencedTaskRunner* file_task_runner,
     ExternalMountPoints* external_mount_points,
     quota::SpecialStoragePolicy* special_storage_policy,
     quota::QuotaManagerProxy* quota_manager_proxy,
     ScopedVector<FileSystemBackend> additional_backends,
     const base::FilePath& partition_path,
     const FileSystemOptions& options)
-    : task_runners_(task_runners.Pass()),
+    : io_task_runner_(io_task_runner),
+      default_file_task_runner_(file_task_runner),
       quota_manager_proxy_(quota_manager_proxy),
       sandbox_context_(new SandboxContext(
           quota_manager_proxy,
-          task_runners_->file_task_runner(),
+          file_task_runner,
           partition_path,
           special_storage_policy,
           options)),
       sandbox_backend_(new SandboxFileSystemBackend(
           sandbox_context_.get())),
       isolated_backend_(new IsolatedFileSystemBackend()),
       additional_backends_(additional_backends.Pass()),
       external_mount_points_(external_mount_points),
       partition_path_(partition_path),
       operation_runner_(new FileSystemOperationRunner(this)) {
-  DCHECK(task_runners_.get());
-
   if (quota_manager_proxy) {
     quota_manager_proxy->RegisterClient(CreateQuotaClient(
             this, options.is_incognito()));
   }
 
   RegisterBackend(sandbox_backend_.get());
   RegisterBackend(isolated_backend_.get());
 
   for (ScopedVector<FileSystemBackend>::const_iterator iter =
           additional_backends_.begin();
@@ skipping 12 matching lines @@
   // Additional mount points must be added before regular system-wide
   // mount points.
   if (external_mount_points)
     url_crackers_.push_back(external_mount_points);
   url_crackers_.push_back(ExternalMountPoints::GetSystemInstance());
   url_crackers_.push_back(IsolatedContext::GetInstance());
 }
 
 bool FileSystemContext::DeleteDataForOriginOnFileThread(
     const GURL& origin_url) {
-  DCHECK(task_runners_->file_task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(default_file_task_runner()->RunsTasksOnCurrentThread());
   DCHECK(origin_url == origin_url.GetOrigin());
 
   bool success = true;
   for (FileSystemBackendMap::iterator iter = backend_map_.begin();
        iter != backend_map_.end();
        ++iter) {
     FileSystemBackend* backend = iter->second;
     if (!backend->GetQuotaUtil())
       continue;
     if (backend->GetQuotaUtil()->DeleteOriginDataOnFileThread(
@@ skipping 112 matching lines @@
   if (!backend) {
     callback.Run(base::PLATFORM_FILE_ERROR_SECURITY);
     return;
   }
   if (!backend->GetQuotaUtil()) {
     callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
-      task_runners()->file_task_runner(),
+      default_file_task_runner(),
       FROM_HERE,
       // It is safe to pass Unretained(quota_util) since context owns it.
       base::Bind(&FileSystemQuotaUtil::DeleteOriginDataOnFileThread,
                  base::Unretained(backend->GetQuotaUtil()),
                  make_scoped_refptr(this),
                  base::Unretained(quota_manager_proxy()),
                  origin_url,
                  type),
       callback);
 }
@@ skipping 42 matching lines @@
 #if defined(OS_CHROMEOS) && defined(GOOGLE_CHROME_BUILD)
 void FileSystemContext::EnableTemporaryFileSystemInIncognito() {
   sandbox_backend_->set_enable_temporary_file_system_in_incognito(true);
 }
 #endif
 
 FileSystemContext::~FileSystemContext() {
 }
 
 void FileSystemContext::DeleteOnCorrectThread() const {
-  if (!task_runners_->io_task_runner()->RunsTasksOnCurrentThread() &&
-      task_runners_->io_task_runner()->DeleteSoon(FROM_HERE, this)) {
+  if (!io_task_runner_->RunsTasksOnCurrentThread() &&
+      io_task_runner_->DeleteSoon(FROM_HERE, this)) {
     return;
   }
   delete this;
 }
 
 FileSystemOperation* FileSystemContext::CreateFileSystemOperation(
     const FileSystemURL& url, base::PlatformFileError* error_code) {
   if (!url.is_valid()) {
     if (error_code)
       *error_code = base::PLATFORM_FILE_ERROR_INVALID_URL;
@@ skipping 65 matching lines @@
     FileSystemType type = static_cast<FileSystemType>(t);
     if (backend->CanHandleType(type)) {
       const bool inserted = backend_map_.insert(
           std::make_pair(type, backend)).second;
       DCHECK(inserted);
     }
   }
 }
 
 }  // namespace fileapi