Split recursive Copy/Move into async tasks and support cross operation (in local case)

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/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/cross_operation_delegate.h"
 #include "webkit/fileapi/file_observers.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_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/remove_operation_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;
 }
 
-bool IsCrossOperationAllowed(FileSystemType src_type,
-                             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);
-}
-
 }  // namespace
 
 // LocalFileSystemOperation::ScopedUpdateNotifier -----------------------------
 
 class LocalFileSystemOperation::ScopedUpdateNotifier {
  public:
   ScopedUpdateNotifier(FileSystemOperationContext* operation_context,
                        const FileSystemURL& url);
   ~ScopedUpdateNotifier();
 
@@ skipping 21 matching lines @@
 // LocalFileSystemOperation ---------------------------------------------------
 
 LocalFileSystemOperation::~LocalFileSystemOperation() {
 }
 
 void LocalFileSystemOperation::CreateFile(const FileSystemURL& url,
                                           bool exclusive,
                                           const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateFile));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_CREATE);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_CREATE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoCreateFile,
                  base::Unretained(this), url, callback, exclusive),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::CreateDirectory(const FileSystemURL& url,
                                                bool exclusive,
                                                bool recursive,
                                                const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateDirectory));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_CREATE);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_CREATE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoCreateDirectory,
                  base::Unretained(this), url, callback, exclusive, recursive),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::Copy(const FileSystemURL& src_url,
                                     const FileSystemURL& dest_url,
                                     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopy));
-  is_cross_operation_ = (src_url.type() != dest_url.type());
 
-  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) {
-    if (!IsCrossOperationAllowed(src_url.type(), dest_url.type()))
-      result = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  }
+  base::PlatformFileError result = SetUp(
+      dest_url, &file_util_, SETUP_FOR_WRITE);
   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));
+  DCHECK(!recursive_operation_delegate_);
+  recursive_operation_delegate_.reset(
+      new CrossOperationDelegate(this, src_url, dest_url,
+                                 CrossOperationDelegate::OPERATION_COPY,
+                                 callback));
+  recursive_operation_delegate_->RunRecursively();
 }
 
 void LocalFileSystemOperation::Move(const FileSystemURL& src_url,
                                     const FileSystemURL& dest_url,
                                     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationMove));
-  is_cross_operation_ = (src_url.type() != dest_url.type());
 
-  scoped_ptr<LocalFileSystemOperation> deleter(this);
-
-  // Temporarily disables cross-filesystem move.
-  // TODO(kinuko,tzik,kinaba): This special handling must be removed once
-  // we support saner cross-filesystem operation.
-  // (See http://crbug.com/130055)
-  if (is_cross_operation_) {
-    callback.Run(base::PLATFORM_FILE_ERROR_INVALID_OPERATION);
+  base::PlatformFileError result = SetUp(
+      src_url, &file_util_, SETUP_FOR_WRITE);
+  if (result != base::PLATFORM_FILE_OK) {
+    callback.Run(result);
+    delete this;
     return;
   }
 
-  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) {
-    if (!IsCrossOperationAllowed(src_url.type(), dest_url.type()))
-      result = base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  }
-  if (result != base::PLATFORM_FILE_OK) {
-    callback.Run(result);
-    return;
-  }
-
-  GetUsageAndQuotaThenRunTask(
-      dest_url,
-      base::Bind(&LocalFileSystemOperation::DoMove,
-                 base::Unretained(deleter.release()),
-                 src_url, dest_url, callback),
-      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
+  DCHECK(!recursive_operation_delegate_);
+  recursive_operation_delegate_.reset(
+      new CrossOperationDelegate(this, src_url, dest_url,
+                                 CrossOperationDelegate::OPERATION_MOVE,
+                                 callback));
+  recursive_operation_delegate_->RunRecursively();
 }
 
 void LocalFileSystemOperation::DirectoryExists(const FileSystemURL& url,
                                                const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationDirectoryExists));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
-      operation_context(), src_util_, url,
+      operation_context(), file_util_, url,
       base::Bind(&LocalFileSystemOperation::DidDirectoryExists,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::FileExists(const FileSystemURL& url,
                                           const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationFileExists));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
-      operation_context(), src_util_, url,
+      operation_context(), file_util_, url,
       base::Bind(&LocalFileSystemOperation::DidFileExists,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::GetMetadata(
     const FileSystemURL& url, const GetMetadataCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationGetMetadata));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result, base::PlatformFileInfo(), FilePath());
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::GetFileInfo(
-      operation_context(), src_util_, url,
+      operation_context(), file_util_, url,
       base::Bind(&LocalFileSystemOperation::DidGetMetadata,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::ReadDirectory(
     const FileSystemURL& url, const ReadDirectoryCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationReadDirectory));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result, std::vector<base::FileUtilProxy::Entry>(), false);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::ReadDirectory(
-      operation_context(), src_util_, url,
+      operation_context(), file_util_, url,
       base::Bind(&LocalFileSystemOperation::DidReadDirectory,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::Remove(const FileSystemURL& url,
                                       bool recursive,
                                       const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
-  DCHECK(!remove_operation_delegate_);
-  remove_operation_delegate_.reset(new RemoveOperationDelegate(this, callback));
+  DCHECK(!recursive_operation_delegate_);
+  recursive_operation_delegate_.reset(
+      new RemoveOperationDelegate(this, url, callback));
   if (recursive)
-    remove_operation_delegate_->RunRecursively(url);
+    recursive_operation_delegate_->RunRecursively();
   else
-    remove_operation_delegate_->Run(url);
+    recursive_operation_delegate_->Run();
 }
 
 void LocalFileSystemOperation::Write(
     const net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
     const GURL& blob_url,
     int64 offset,
     const WriteCallback& callback) {
   GetWriteClosure(url_request_context, url, blob_url, offset, callback).Run();
 }
 
 void LocalFileSystemOperation::Truncate(const FileSystemURL& url, int64 length,
                                         const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTruncate));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_WRITE);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoTruncate,
                  base::Unretained(this), url, callback, length),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::TouchFile(const FileSystemURL& url,
                                          const base::Time& last_access_time,
                                          const base::Time& last_modified_time,
                                          const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationTouchFile));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_WRITE);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::Touch(
-      operation_context(), src_util_, url,
+      operation_context(), file_util_, url,
       last_access_time, last_modified_time,
       base::Bind(&LocalFileSystemOperation::DidTouchFile,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::OpenFile(const FileSystemURL& url,
                                         int file_flags,
                                         base::ProcessHandle peer_handle,
                                         const OpenFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationOpenFile));
   scoped_ptr<LocalFileSystemOperation> deleter(this);
 
   peer_handle_ = peer_handle;
 
   if (file_flags & (
       (base::PLATFORM_FILE_ENUMERATE | base::PLATFORM_FILE_TEMPORARY |
        base::PLATFORM_FILE_HIDDEN))) {
     callback.Run(base::PLATFORM_FILE_ERROR_FAILED,
                  base::PlatformFile(), base::ProcessHandle());
     return;
   }
   if (file_flags &
       (base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_OPEN_ALWAYS |
        base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_OPEN_TRUNCATED |
        base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_EXCLUSIVE_WRITE |
        base::PLATFORM_FILE_DELETE_ON_CLOSE |
        base::PLATFORM_FILE_WRITE_ATTRIBUTES)) {
-    base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_CREATE);
+    base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_CREATE);
     if (result != base::PLATFORM_FILE_OK) {
       callback.Run(result, base::PlatformFile(), base::ProcessHandle());
       return;
     }
   } else {
-    base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
+    base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_READ);
     if (result != base::PLATFORM_FILE_OK) {
       callback.Run(result, base::PlatformFile(), base::ProcessHandle());
       return;
     }
   }
   GetUsageAndQuotaThenRunTask(
       url,
       base::Bind(&LocalFileSystemOperation::DoOpenFile,
                  base::Unretained(deleter.release()),
                  url, callback, file_flags),
@@ skipping 43 matching lines @@
 
 LocalFileSystemOperation*
 LocalFileSystemOperation::AsLocalFileSystemOperation() {
   return this;
 }
 
 void LocalFileSystemOperation::SyncGetPlatformPath(const FileSystemURL& url,
                                                    FilePath* platform_path) {
   DCHECK(SetPendingOperationType(kOperationGetLocalPath));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     delete this;
     return;
   }
 
-  src_util_->GetLocalFilePath(operation_context(), url, platform_path);
+  file_util_->GetLocalFilePath(operation_context(), url, platform_path);
 
   delete this;
 }
 
 void LocalFileSystemOperation::CreateSnapshotFile(
     const FileSystemURL& url,
     const SnapshotFileCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCreateSnapshotFile));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_READ);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_READ);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result, base::PlatformFileInfo(), FilePath(), NULL);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::CreateSnapshotFile(
-      operation_context(), src_util_, url,
+      operation_context(), file_util_, url,
       base::Bind(&LocalFileSystemOperation::DidCreateSnapshotFile,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::CopyInForeignFile(
     const FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationCopyInForeignFile));
 
   base::PlatformFileError result = SetUp(
-      dest_url, &dest_util_, SETUP_FOR_CREATE);
+      dest_url, &file_util_, SETUP_FOR_CREATE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   GetUsageAndQuotaThenRunTask(
       dest_url,
       base::Bind(&LocalFileSystemOperation::DoCopyInForeignFile,
                  base::Unretained(this), src_local_disk_file_path, dest_url,
                  callback),
       base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
 }
 
 void LocalFileSystemOperation::RemoveFile(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_WRITE);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::DeleteFile(
-      operation_context(), src_util_, url,
+      operation_context(), file_util_, url,
       base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::RemoveDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationRemove));
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_WRITE);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result);
     delete this;
     return;
   }
 
   FileSystemFileUtilProxy::DeleteDirectory(
-      operation_context(), src_util_, url,
+      operation_context(), file_util_, url,
       base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
+void LocalFileSystemOperation::CopyFileLocal(
+    const FileSystemURL& src_url,
+    const FileSystemURL& dest_url,
+    const StatusCallback& callback) {
+  DCHECK(SetPendingOperationType(kOperationCopy));
+  DCHECK_EQ(src_url.origin(), dest_url.origin());
+  DCHECK_EQ(src_url.type(), dest_url.type());
+
+  base::PlatformFileError result = SetUp(src_url, &file_util_, SETUP_FOR_READ);
+  if (result == base::PLATFORM_FILE_OK)
+    result = SetUp(dest_url, &file_util_, SETUP_FOR_CREATE);
+  if (result != base::PLATFORM_FILE_OK) {
+    callback.Run(result);
+    delete this;
+    return;
+  }
+
+  // Record read access for src_url.
+  operation_context()->access_observers()->Notify(
+      &FileAccessObserver::OnAccess, MakeTuple(src_url));
+  // Record update access for dest_url.
+  scoped_update_notifiers_.push_back(new ScopedUpdateNotifier(
+      operation_context(), dest_url));
+
+  GetUsageAndQuotaThenRunTask(
+      dest_url,
+      base::Bind(&LocalFileSystemOperation::DoCopyFileLocal,
+                 base::Unretained(this), src_url, dest_url, callback),
+      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
+}
+
+void LocalFileSystemOperation::MoveFileLocal(
+    const FileSystemURL& src_url,
+    const FileSystemURL& dest_url,
+    const StatusCallback& callback) {
+  DCHECK(SetPendingOperationType(kOperationMove));
+  DCHECK_EQ(src_url.origin(), dest_url.origin());
+  DCHECK_EQ(src_url.type(), dest_url.type());
+
+  base::PlatformFileError result = SetUp(src_url, &file_util_, SETUP_FOR_WRITE);
+  if (result == base::PLATFORM_FILE_OK)
+    result = SetUp(dest_url, &file_util_, SETUP_FOR_CREATE);
+  if (result != base::PLATFORM_FILE_OK) {
+    callback.Run(result);
+    delete this;
+    return;
+  }
+
+  // Record update access for dest_url.
+  scoped_update_notifiers_.push_back(new ScopedUpdateNotifier(
+      operation_context(), dest_url));
+
+  GetUsageAndQuotaThenRunTask(
+      dest_url,
+      base::Bind(&LocalFileSystemOperation::DoMoveFileLocal,
+                 base::Unretained(this), src_url, dest_url, callback),
+      base::Bind(callback, base::PLATFORM_FILE_ERROR_FAILED));
+}
+
 LocalFileSystemOperation::LocalFileSystemOperation(
     FileSystemContext* file_system_context,
     scoped_ptr<FileSystemOperationContext> operation_context)
     : file_system_context_(file_system_context),
       operation_context_(operation_context.Pass()),
-      src_util_(NULL),
-      dest_util_(NULL),
+      file_util_(NULL),
       overriding_operation_context_(NULL),
-      is_cross_operation_(false),
       peer_handle_(base::kNullProcessHandle),
       pending_operation_(kOperationNone),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(operation_context_.get());
 }
 
 void LocalFileSystemOperation::GetUsageAndQuotaThenRunTask(
     const FileSystemURL& url,
     const base::Closure& task,
     const base::Closure& error_callback) {
@@ skipping 33 matching lines @@
 }
 
 base::Closure LocalFileSystemOperation::GetWriteClosure(
     const net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
     const GURL& blob_url,
     int64 offset,
     const WriteCallback& callback) {
   DCHECK(SetPendingOperationType(kOperationWrite));
 
-  base::PlatformFileError result = SetUp(url, &src_util_, SETUP_FOR_WRITE);
+  base::PlatformFileError result = SetUp(url, &file_util_, SETUP_FOR_WRITE);
   if (result != base::PLATFORM_FILE_OK) {
     return base::Bind(&LocalFileSystemOperation::DidFailWrite,
                       base::Owned(this), callback, result);
   }
 
   FileSystemMountPointProvider* provider = file_system_context()->
       GetMountPointProvider(url.type());
   DCHECK(provider);
   scoped_ptr<FileStreamWriter> writer(provider->CreateFileStreamWriter(
           url, offset, file_system_context()));
@@ skipping 25 matching lines @@
     base::PlatformFileError result) {
   callback.Run(result, 0, false);
 }
 
 void LocalFileSystemOperation::DoCreateFile(
     const FileSystemURL& url,
     const StatusCallback& callback,
     bool exclusive) {
   FileSystemFileUtilProxy::EnsureFileExists(
       operation_context(),
-      src_util_, url,
+      file_util_, url,
       base::Bind(
           exclusive ?
               &LocalFileSystemOperation::DidEnsureFileExistsExclusive :
               &LocalFileSystemOperation::DidEnsureFileExistsNonExclusive,
           base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::DoCreateDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback,
     bool exclusive, bool recursive) {
   FileSystemFileUtilProxy::CreateDirectory(
       operation_context(),
-      src_util_, url, exclusive, recursive,
+      file_util_, url, exclusive, recursive,
       base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
-void LocalFileSystemOperation::DoCopy(const FileSystemURL& src_url,
-                                      const FileSystemURL& dest_url,
-                                      const StatusCallback& callback) {
-  FileSystemFileUtilProxy::Copy(
+void LocalFileSystemOperation::DoCopyFileLocal(
+    const FileSystemURL& src_url,
+    const FileSystemURL& dest_url,
+    const StatusCallback& callback) {
+  FileSystemFileUtilProxy::CopyFileLocal(
       operation_context(),
-      src_util_, dest_util_,
-      src_url, dest_url,
+      file_util_, src_url, dest_url,
+      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
+                 base::Owned(this), callback));
+}
+
+void LocalFileSystemOperation::DoMoveFileLocal(
+    const FileSystemURL& src_url,
+    const FileSystemURL& dest_url,
+    const StatusCallback& callback) {
+  FileSystemFileUtilProxy::MoveFileLocal(
+      operation_context(),
+      file_util_, src_url, dest_url,
       base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::DoCopyInForeignFile(
     const FilePath& src_local_disk_file_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
   FileSystemFileUtilProxy::CopyInForeignFile(
       operation_context(),
-      dest_util_,
-      src_local_disk_file_path, dest_url,
+      file_util_, src_local_disk_file_path, dest_url,
       base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
-
-void LocalFileSystemOperation::DoMove(const FileSystemURL& src_url,
-                                      const FileSystemURL& dest_url,
-                                      const StatusCallback& callback) {
-  FileSystemFileUtilProxy::Move(
-      operation_context(),
-      src_util_, dest_util_,
-      src_url, dest_url,
-      base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
-                 base::Owned(this), callback));
-}
 
 void LocalFileSystemOperation::DoTruncate(const FileSystemURL& url,
                                           const StatusCallback& callback,
                                           int64 length) {
   FileSystemFileUtilProxy::Truncate(
-      operation_context(), src_util_, url, length,
+      operation_context(), file_util_, url, length,
       base::Bind(&LocalFileSystemOperation::DidFinishFileOperation,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::DoOpenFile(const FileSystemURL& url,
                                           const OpenFileCallback& callback,
                                           int file_flags) {
   FileSystemFileUtilProxy::CreateOrOpen(
-      operation_context(), src_util_, url, file_flags,
+      operation_context(), file_util_, url, file_flags,
       base::Bind(&LocalFileSystemOperation::DidOpenFile,
                  base::Owned(this), callback));
 }
 
 void LocalFileSystemOperation::DidEnsureFileExistsExclusive(
     const StatusCallback& callback,
     base::PlatformFileError rv, bool created) {
   if (rv == base::PLATFORM_FILE_OK && !created) {
     callback.Run(base::PLATFORM_FILE_ERROR_EXISTS);
   } else {
@@ skipping 134 matching lines @@
   // operation context is overridden from another operation) we skip
   // some duplicated security checks.
   if (overriding_operation_context_)
     return base::PLATFORM_FILE_OK;
 
   if (!file_system_context()->GetMountPointProvider(
           url.type())->IsAccessAllowed(url))
     return base::PLATFORM_FILE_ERROR_SECURITY;
 
   if (mode == SETUP_FOR_READ) {
-    // TODO(kinuko): This doesn't work well for cross-filesystem operation
-    // in the current architecture since the operation context (thus the
-    // observers) is configured for the destination URL while this method
-    // could be called for both src and dest URL.
-    if (!is_cross_operation_) {
-      operation_context()->access_observers()->Notify(
-          &FileAccessObserver::OnAccess, MakeTuple(url));
-    }
+    operation_context()->access_observers()->Notify(
+        &FileAccessObserver::OnAccess, MakeTuple(url));
     return base::PLATFORM_FILE_OK;
   }
 
   DCHECK(mode == SETUP_FOR_WRITE || mode == SETUP_FOR_CREATE);
 
   scoped_update_notifiers_.push_back(new ScopedUpdateNotifier(
       operation_context(), url));
 
   // Any write access is disallowed on the root path.
   if (url.path().value().length() == 0 ||
@@ skipping 13 matching lines @@
 }
 
 bool LocalFileSystemOperation::SetPendingOperationType(OperationType type) {
   if (pending_operation_ != kOperationNone)
     return false;
   pending_operation_ = type;
   return true;
 }
 
 }  // namespace fileapi