Make MediaFileUtil run on thread pool.

webkit/fileapi/local_file_system_operation.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/local_file_system_operation.h"
 
 #include "base/bind.h"
-#include "base/sequenced_task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_quota_util.h"
+#include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 #include "webkit/fileapi/sandbox_file_stream_writer.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
 
 using webkit_blob::ShareableFileReference;
 
 namespace fileapi {
 
+namespace {
+
+bool IsMediaFileSystemType(FileSystemType type) {
+  return type == kFileSystemTypeNativeMedia ||
+      type == kFileSystemTypeDeviceMedia;
+}
+
+base::PlatformFileError AllowCrossOperation(FileSystemType src_type,

[kinuko, 2012/08/06 19:00:14]

This function name doesn't sound like a check function.  I vote for
IsCrossOperationAllowed (returns bool) or maybe CheckIfCrossOperationAllowed
(returns error code)?

[tzik, 2012/08/06 20:09:01]

Done.

+                                            FileSystemType dest_type) {
+  // If two types are supposed to run on different task runners we should not
+  // allow cross FileUtil operations at this layer.
+  return IsMediaFileSystemType(src_type) == IsMediaFileSystemType(dest_type) ?
+      base::PLATFORM_FILE_OK :
+      base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+}
+
+}  // namespace
+
 class LocalFileSystemOperation::ScopedQuotaNotifier {
  public:
   ScopedQuotaNotifier(FileSystemContext* context,
                       const GURL& origin_url,
                       FileSystemType type);
   ~ScopedQuotaNotifier();
 
  private:
   // Not owned; owned by the owner of this instance
   // (i.e. LocalFileSystemOperation).
@@ skipping 70 matching lines @@
 }
 
 void LocalFileSystemOperation::Copy(const FileSystemURL& src_url,
                                     const FileSystemURL& dest_url,
                                     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopy));
 
   base::PlatformFileError result = SetUp(src_url, &src_util_, SETUP_FOR_READ);
   if (result == base::PLATFORM_FILE_OK)
     result = SetUp(dest_url, &dest_util_, SETUP_FOR_CREATE);
+  if (result == base::PLATFORM_FILE_OK)
+    result = AllowCrossOperation(src_url.type(), dest_url.type());
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&LocalFileSystemOperation::DoCopy,
                  base::Unretained(this), src_url, dest_url, callback),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::Move(const FileSystemURL& src_url,
                                     const FileSystemURL& dest_url,
                                     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationMove));
   scoped_ptr<LocalFileSystemOperation> deleter(this);
 
   base::PlatformFileError result = SetUp(src_url, &src_util_, SETUP_FOR_WRITE);
   if (result == base::PLATFORM_FILE_OK)
     result = SetUp(dest_url, &dest_util_, SETUP_FOR_CREATE);
+  if (result == base::PLATFORM_FILE_OK)
+    result = AllowCrossOperation(src_url.type(), dest_url.type());
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     return;
   }
 
   // Temporarily disables cross-filesystem move for sandbox filesystems.
   // TODO(kinuko,tzik,kinaba): This special handling must be removed once
   // we support saner cross-filesystem operation.
   // (See http://crbug.com/130055)
   if (src_url.type() != dest_url.type() &&
@@ skipping 524 matching lines @@
     const SnapshotFileCallback& callback,
     base::PlatformFileError result,
     const base::PlatformFileInfo& file_info,
     const FilePath& platform_path,
     FileSystemFileUtil::SnapshotFilePolicy snapshot_policy) {
   scoped_refptr<ShareableFileReference> file_ref;
   if (result == base::PLATFORM_FILE_OK &&
       snapshot_policy == FileSystemFileUtil::kSnapshotFileTemporary) {
     file_ref = ShareableFileReference::GetOrCreate(
         platform_path, ShareableFileReference::DELETE_ON_FINAL_RELEASE,
-        file_system_context()->file_task_runner());
+        file_system_context()->task_runners()->file_task_runner());
   }
   callback.Run(result, file_info, platform_path, file_ref);
 }
 
 base::PlatformFileError LocalFileSystemOperation::SetUp(
     const FileSystemURL& url,
     FileSystemFileUtil** file_util,
     SetUpMode mode) {
   if (!url.is_valid())
     return base::PLATFORM_FILE_ERROR_INVALID_URL;
@@ skipping 43 matching lines @@
 }
 
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi