Make MediaFileUtil run on thread pool.

webkit/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_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 #define WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_
 
 #include <map>
 #include <string>
 
 #include "base/callback.h"
+#include "base/sequenced_task_runner_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
-#include "base/sequenced_task_runner_helpers.h"
 #include "webkit/fileapi/fileapi_export.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/quota/special_storage_policy.h"
 
 class FilePath;
 
-namespace base {
-class SequencedTaskRunner;
-class SingleThreadTaskRunner;
-}
-
 namespace quota {
 class QuotaManagerProxy;
 }
 
 namespace webkit_blob {
 class FileStreamReader;
 }
 
 namespace fileapi {
 
 class ExternalFileSystemMountPointProvider;
 class FileSystemFileUtil;
 class FileSystemMountPointProvider;
 class FileSystemOperationInterface;
 class FileSystemOptions;
 class FileSystemQuotaUtil;
+class FileSystemTaskRunners;
 class FileSystemURL;
 class IsolatedMountPointProvider;
 class SandboxMountPointProvider;
 
 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 FILEAPI_EXPORT FileSystemContext
     : public base::RefCountedThreadSafe<FileSystemContext,
                                         DefaultContextDeleter> {
  public:
-  // |file_task_runner| is used for all file operations and file related
-  // meta operations.
-  // The code assumes that file_task_runner->RunsTasksOnCurrentThread() returns
-  // false if the current task is not running on the thread that allows
+  // task_runners->file_task_runner() is used as default TaskRunner.
+  // Unless a MountPointProvired is override in CreateFileSystemOperation,
+  // it is used for all file operations and file related meta operations.
+  // The code assumes that
+  // task_runners->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).
   FileSystemContext(
-      base::SequencedTaskRunner* file_task_runner,
-      base::SingleThreadTaskRunner* io_task_runner,
+      scoped_ptr<FileSystemTaskRunners> task_runners,
       quota::SpecialStoragePolicy* special_storage_policy,
       quota::QuotaManagerProxy* quota_manager_proxy,
       const FilePath& profile_path,
       const FileSystemOptions& options);
 
   bool DeleteDataForOriginOnFileThread(const GURL& origin_url);
 
   quota::QuotaManagerProxy* quota_manager_proxy() const {
     return quota_manager_proxy_.get();
   }
 
-  base::SequencedTaskRunner* file_task_runner() const {
-    return file_task_runner_.get();
-  }
-
   // Returns a quota util for a given filesystem type.  This may
   // return NULL if the type does not support the usage tracking or
   // it is not a quota-managed storage.
   FileSystemQuotaUtil* GetQuotaUtil(FileSystemType type) const;
 
   // Returns the appropriate FileUtil instance for the given |type|.
   // This may return NULL if it is given an invalid or unsupported filesystem
   // type.
   FileSystemFileUtil* GetFileUtil(FileSystemType type) const;
 
@@ skipping 55 matching lines @@
   // depending on the filesystem type pointed by the |url|.
   webkit_blob::FileStreamReader* CreateFileStreamReader(
       const FileSystemURL& url,
       int64 offset);
 
   // Register a filesystem provider. The ownership of |provider| is
   // transferred to this instance.
   void RegisterMountPointProvider(FileSystemType type,
                                   FileSystemMountPointProvider* provider);
 
+  FileSystemTaskRunners* task_runners() { return task_runners_.get(); }
+
  private:
   friend struct DefaultContextDeleter;
   friend class base::DeleteHelper<FileSystemContext>;
   friend class base::RefCountedThreadSafe<FileSystemContext,
                                           DefaultContextDeleter>;
   ~FileSystemContext();
 
   void DeleteOnCorrectThread() const;
 
-  scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
-  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+  scoped_ptr<FileSystemTaskRunners> task_runners_;
 
   scoped_refptr<quota::QuotaManagerProxy> quota_manager_proxy_;
 
   // Regular mount point providers.
   scoped_ptr<SandboxMountPointProvider> sandbox_provider_;
   scoped_ptr<IsolatedMountPointProvider> isolated_provider_;
   scoped_ptr<ExternalFileSystemMountPointProvider> external_provider_;
 
   // Registered mount point providers.
   std::map<FileSystemType, FileSystemMountPointProvider*> provider_map_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(FileSystemContext);
 };
 
 struct DefaultContextDeleter {
   static void Destruct(const FileSystemContext* context) {
     context->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_FILE_SYSTEM_CONTEXT_H_