Make MediaFileUtil run on thread pool.

webkit/fileapi/isolated_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/isolated_mount_point_provider.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "webkit/blob/local_file_stream_reader.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_stream_reader.h"
+#include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/isolated_file_util.h"
 #include "webkit/fileapi/local_file_stream_writer.h"
 #include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/media/media_file_system_config.h"
 #include "webkit/fileapi/media/media_path_filter.h"
 #include "webkit/fileapi/media/native_media_file_util.h"
 #include "webkit/fileapi/native_file_util.h"
 
 #if defined(SUPPORT_MEDIA_FILESYSTEM)
 #include "webkit/fileapi/media/device_media_file_util.h"
 #include "webkit/fileapi/media/media_device_map_service.h"
 #endif
 
 namespace fileapi {
 
 namespace {
 
 IsolatedContext* isolated_context() {
   return IsolatedContext::GetInstance();
 }
 
 #if defined(SUPPORT_MEDIA_FILESYSTEM)
 MediaDeviceInterfaceImpl* GetDeviceForUrl(const FileSystemURL& url,
                                           FileSystemContext* context) {
   return MediaDeviceMapService::GetInstance()->CreateOrGetMediaDevice(
-      url.filesystem_id(), context->file_task_runner());
+      url.filesystem_id(), context->task_runners()->media_task_runner());
 }
 #endif
 
 }  // namespace
 
 IsolatedMountPointProvider::IsolatedMountPointProvider(
     const FilePath& profile_path)
     : profile_path_(profile_path),
       media_path_filter_(new MediaPathFilter()),
       isolated_file_util_(new IsolatedFileUtil()),
@@ skipping 72 matching lines @@
   return virtual_path;
 }
 
 FileSystemOperationInterface*
 IsolatedMountPointProvider::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context) const {
   scoped_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(context));
   if (url.type() == kFileSystemTypeNativeMedia ||
-      url.type() == kFileSystemTypeDeviceMedia)
+      url.type() == kFileSystemTypeDeviceMedia) {
     operation_context->set_media_path_filter(media_path_filter_.get());
+    operation_context->SetTaskRunner(
+        context->task_runners()->media_task_runner());
+  }
 
 #if defined(SUPPORT_MEDIA_FILESYSTEM)
   if (url.type() == kFileSystemTypeDeviceMedia) {
     // GetDeviceForUrl can return NULL. We will handle in DeviceMediaFileUtil.
     operation_context->set_media_device(GetDeviceForUrl(url, context));
   }
 #endif
 
   return new LocalFileSystemOperation(context, operation_context.Pass());
 }
 
 webkit_blob::FileStreamReader*
 IsolatedMountPointProvider::CreateFileStreamReader(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   return new webkit_blob::LocalFileStreamReader(
-      context->file_task_runner(), url.path(), offset, base::Time());
+      context->task_runners()->file_task_runner(),
+      url.path(), offset, base::Time());
 }
 
 FileStreamWriter* IsolatedMountPointProvider::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64 offset,
     FileSystemContext* context) const {
   return new LocalFileStreamWriter(url.path(), offset);
 }
 
 FileSystemQuotaUtil* IsolatedMountPointProvider::GetQuotaUtil() {
   // No quota support.
   return NULL;
 }
 
 void IsolatedMountPointProvider::DeleteFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     FileSystemContext* context,
     const DeleteFileSystemCallback& callback) {
   NOTREACHED();
   callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
 }
 
 }  // namespace fileapi