Deprecate FileSystemTaskRunners

webkit/browser/fileapi/file_system_context.h

 // 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.
 
 #ifndef WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 #define WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/platform_file.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/browser/fileapi/open_file_system_mode.h"
 #include "webkit/browser/fileapi/sandbox_context.h"
 #include "webkit/browser/fileapi/task_runner_bound_observer_list.h"
 #include "webkit/browser/webkit_storage_browser_export.h"
 #include "webkit/common/fileapi/file_system_types.h"
 
 namespace base {
 class FilePath;
+class SequencedTaskRunner;
+class SingleThreadTaskRunner;
 }
 
 namespace chrome {
 class NativeMediaFileUtilTest;
 }
 
 namespace quota {
 class QuotaManagerProxy;
 class SpecialStoragePolicy;
 }
 
 namespace webkit_blob {
 class BlobURLRequestJobTest;
 class FileStreamReader;
 }
 
 namespace fileapi {
 
 class AsyncFileUtil;
 class CopyOrMoveFileValidatorFactory;
 class ExternalFileSystemBackend;
 class ExternalMountPoints;
 class FileStreamWriter;
 class FileSystemFileUtil;
 class FileSystemBackend;
 class FileSystemOperation;
 class FileSystemOperationRunner;
 class FileSystemOptions;
 class FileSystemQuotaUtil;
-class FileSystemTaskRunners;
 class FileSystemURL;
 class IsolatedFileSystemBackend;
 class MountPoints;
 class SandboxFileSystemBackend;
 
 struct DefaultContextDeleter;
 
 // This class keeps and provides a file system context for FileSystem API.
 // An instance of this class is created and owned by profile.
 class WEBKIT_STORAGE_BROWSER_EXPORT FileSystemContext
     : public base::RefCountedThreadSafe<FileSystemContext,
                                         DefaultContextDeleter> {
  public:
   // Returns file permission policy we should apply for the given |type|.
   // The return value must be bitwise-or'd of FilePermissionPolicy.
   //
   // Note: if a part of a filesystem is returned via 'Isolated' mount point,
   // its per-filesystem permission overrides the underlying filesystem's
   // permission policy.
   static int GetPermissionPolicy(FileSystemType type);
 
-  // task_runners->file_task_runner() is used as default TaskRunner.
+  // file_task_runner is used as default TaskRunner.
   // Unless a FileSystemBackend is overridden in CreateFileSystemOperation,
   // it is used for all file operations and file related meta operations.
-  // The code assumes that
-  // task_runners->file_task_runner()->RunsTasksOnCurrentThread()
+  // The code assumes that file_task_runner->RunsTasksOnCurrentThread()
   // returns false if the current task is not running on the thread that allows
   // blocking file operations (like SequencedWorkerPool implementation does).
   //
   // |external_mount_points| contains non-system external mount points available
   // in the context. If not NULL, it will be used during URL cracking.
   // |external_mount_points| may be NULL only on platforms different from
   // ChromeOS (i.e. platforms that don't use external_mount_point_provider).
   //
   // |additional_backends| are added to the internal backend map
   // to serve filesystem requests for non-regular types.
   // If none is given, this context only handles HTML5 Sandbox FileSystem
   // and Drag-and-drop Isolated FileSystem requests.
   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);
 
   bool DeleteDataForOriginOnFileThread(const GURL& origin_url);
 
   quota::QuotaManagerProxy* quota_manager_proxy() const {
@@ skipping 87 matching lines @@
 
   // Creates new FileStreamWriter instance to write into a file pointed by
   // |url| from |offset|.
   scoped_ptr<FileStreamWriter> CreateFileStreamWriter(
       const FileSystemURL& url,
       int64 offset);
 
   // Creates a new FileSystemOperationRunner.
   scoped_ptr<FileSystemOperationRunner> CreateFileSystemOperationRunner();
 
-  FileSystemTaskRunners* task_runners() { return task_runners_.get(); }
+  base::SequencedTaskRunner* default_file_task_runner() {
+    return default_file_task_runner_.get();
+  }
 
   FileSystemOperationRunner* operation_runner() {
     return operation_runner_.get();
   }
 
   const base::FilePath& partition_path() const { return partition_path_; }
 
   // Same as |CrackFileSystemURL|, but cracks FileSystemURL created from |url|.
   FileSystemURL CrackURL(const GURL& url) const;
   // Same as |CrackFileSystemURL|, but cracks FileSystemURL created from method
@@ skipping 50 matching lines @@
 
   // For initial backend_map construction. This must be called only from
   // the constructor.
   void RegisterBackend(FileSystemBackend* backend);
 
   // Returns a FileSystemBackend, used only by test code.
   SandboxFileSystemBackend* sandbox_backend() const {
     return sandbox_backend_.get();
   }
 
-  scoped_ptr<FileSystemTaskRunners> task_runners_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> default_file_task_runner_;
 
   scoped_refptr<quota::QuotaManagerProxy> quota_manager_proxy_;
 
   scoped_ptr<SandboxContext> sandbox_context_;
 
   // Regular file system backends.
   scoped_ptr<SandboxFileSystemBackend> sandbox_backend_;
   scoped_ptr<IsolatedFileSystemBackend> isolated_backend_;
 
   // Additional file system backends.
@@ skipping 25 matching lines @@
 
 struct DefaultContextDeleter {
   static void Destruct(const FileSystemContext* context) {
     context->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_BROWSER_FILEAPI_FILE_SYSTEM_CONTEXT_H_