fileapi: Pass virtual path to copy validator.

webkit/fileapi/cross_operation_delegate.cc

 // Copyright (c) 2013 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/cross_operation_delegate.h"
 
 #include "base/bind.h"
 #include "webkit/blob/shareable_file_reference.h"
 #include "webkit/fileapi/copy_or_move_file_validator.h"
 #include "webkit/fileapi/file_system_context.h"
@@ skipping 37 matching lines @@
     return;
   }
 
   // It is an error to copy/move an entry into the same path.
   if (same_file_system_ && src_root_.path() == dest_root_.path()) {
     callback_.Run(base::PLATFORM_FILE_ERROR_EXISTS);
     return;
   }
 
   // First try to copy/move it as a file.
-  CopyOrMoveFile(src_root_, dest_root_,
-                 base::Bind(&CrossOperationDelegate::DidTryCopyOrMoveFile,
-                            AsWeakPtr()));
+  Request request(src_root_, dest_root_,
+                  base::Bind(&CrossOperationDelegate::DidTryCopyOrMoveFile,
+                             AsWeakPtr()));
+  CopyOrMoveFile(request);
 }
 
 void CrossOperationDelegate::ProcessFile(const FileSystemURL& src_url,
                                          const StatusCallback& callback) {
-  CopyOrMoveFile(src_url, CreateDestURL(src_url), callback);
+  Request request(src_url, CreateDestURL(src_url), callback);
+  CopyOrMoveFile(request);
 }
 
 void CrossOperationDelegate::ProcessDirectory(const FileSystemURL& src_url,
                                               const StatusCallback& callback) {
   FileSystemURL dest_url = CreateDestURL(src_url);
 
   // If operation_type == Move we may need to record directories and
   // restore directory timestamps in the end, though it may have
   // negative performance impact.
   // See http://crbug.com/171284 for more details.
@@ skipping 26 matching lines @@
   if (error != base::PLATFORM_FILE_OK &&
       error != base::PLATFORM_FILE_ERROR_NOT_FOUND) {
     callback_.Run(error);
     return;
   }
 
   // Start to process the source directory recursively.
   // TODO(kinuko): This could be too expensive for same_file_system_==true
   // and operation==MOVE case, probably we can just rename the root directory.
   // http://crbug.com/172187
+  Request request(src_root_, dest_root_, callback_);
   StartRecursiveOperation(
       src_root_, base::Bind(&CrossOperationDelegate::DidFinishCopy,
-                            AsWeakPtr(), src_root_, callback_));
+                            AsWeakPtr(), request));
 }
 
-void CrossOperationDelegate::CopyOrMoveFile(
-    const FileSystemURL& src,
-    const FileSystemURL& dest,
-    const StatusCallback& callback) {
+void CrossOperationDelegate::CopyOrMoveFile(const Request& request) {
   // Same filesystem case.
   if (same_file_system_) {
-    if (operation_type_ == OPERATION_MOVE)
-      NewSourceOperation()->MoveFileLocal(src, dest, callback);
-    else
-      NewSourceOperation()->CopyFileLocal(src, dest, callback);
+    if (operation_type_ == OPERATION_MOVE) {
+      NewSourceOperation()->MoveFileLocal(request.src, request.dest,
+                                          request.callback);
+    } else {
+      NewSourceOperation()->CopyFileLocal(request.src, request.dest,
+                                          request.callback);
+    }
     return;
   }
 
   // Cross filesystem case.
   // Perform CreateSnapshotFile, CopyInForeignFile and then calls
   // copy_callback which removes the source file if operation_type == MOVE.
   StatusCallback copy_callback =
-      base::Bind(&CrossOperationDelegate::DidFinishCopy, AsWeakPtr(),
-                 src, callback);
+      base::Bind(&CrossOperationDelegate::DidFinishCopy, AsWeakPtr(), request);
+  Request copy_request(request.src, request.dest, copy_callback);
   NewSourceOperation()->CreateSnapshotFile(
-      src, base::Bind(&CrossOperationDelegate::DidCreateSnapshot, AsWeakPtr(),
-                      dest, copy_callback));
+      request.src,
+      base::Bind(&CrossOperationDelegate::DidCreateSnapshot, AsWeakPtr(),
+                 copy_request));
 }
 
 void CrossOperationDelegate::DidCreateSnapshot(
-    const FileSystemURL& dest,
-    const StatusCallback& callback,
+    const Request& request,
     base::PlatformFileError error,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref) {
   if (error != base::PLATFORM_FILE_OK) {
-    callback.Run(error);
+    request.callback.Run(error);
     return;
   }
   current_file_ref_ = file_ref;
 
   // For now we assume CreateSnapshotFile always return a valid local file path.
   // TODO(kinuko): Otherwise create a FileStreamReader to perform a copy/move.
   DCHECK(!platform_path.empty());
 
   CopyOrMoveFileValidatorFactory* factory =
       file_system_context()->GetCopyOrMoveFileValidatorFactory(
           dest_root_.type(), &error);
   if (error != base::PLATFORM_FILE_OK) {
-    callback.Run(error);
+    request.callback.Run(error);
     return;
   }
   if (!factory) {
-    DidValidateFile(dest, callback, file_info, platform_path, error);
+    DidValidateFile(request, file_info, platform_path, error);
     return;
   }
 
-  validator_.reset(factory->CreateCopyOrMoveFileValidator(platform_path));
+  base::FilePath src_path = request.src.virtual_path();
+  validator_.reset(
+      factory->CreateCopyOrMoveFileValidator(src_path, platform_path));
   validator_->StartValidation(
       base::Bind(&CrossOperationDelegate::DidValidateFile, AsWeakPtr(),
-                 dest, callback, file_info, platform_path));
+                 request, file_info, platform_path));
 }
 
 void CrossOperationDelegate::DidValidateFile(
-    const FileSystemURL& dest,
-    const StatusCallback& callback,
+    const Request& request,
     const base::PlatformFileInfo& file_info,
     const base::FilePath& platform_path,
     base::PlatformFileError error) {
   if (error != base::PLATFORM_FILE_OK) {
-    callback.Run(error);
+    request.callback.Run(error);
     return;
   }
 
-  NewDestOperation()->CopyInForeignFile(platform_path, dest, callback);
+  NewDestOperation()->CopyInForeignFile(platform_path, request.dest,
+                                        request.callback);
 }
 
 void CrossOperationDelegate::DidFinishCopy(
-    const FileSystemURL& src,
-    const StatusCallback& callback,
+    const Request& request,
     base::PlatformFileError error) {
   if (error != base::PLATFORM_FILE_OK ||
       operation_type_ == OPERATION_COPY) {
-    callback.Run(error);
+    request.callback.Run(error);
     return;
   }
 
   DCHECK_EQ(OPERATION_MOVE, operation_type_);
 
   // Remove the source for finalizing move operation.
   NewSourceOperation()->Remove(
-      src, true /* recursive */,
+      request.src, true /* recursive */,
       base::Bind(&CrossOperationDelegate::DidRemoveSourceForMove,
-                 AsWeakPtr(), callback));
+                 AsWeakPtr(), request));
 }
 
 void CrossOperationDelegate::DidRemoveSourceForMove(
-    const StatusCallback& callback,
+    const Request& request,
     base::PlatformFileError error) {
   if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
     error = base::PLATFORM_FILE_OK;
-  callback.Run(error);
+  request.callback.Run(error);
 }
 
 FileSystemURL CrossOperationDelegate::CreateDestURL(
     const FileSystemURL& src_url) const {
   DCHECK_EQ(src_root_.type(), src_url.type());
   DCHECK_EQ(src_root_.origin(), src_url.origin());
 
   base::FilePath relative = dest_root_.virtual_path();
   src_root_.virtual_path().AppendRelativePath(src_url.virtual_path(),
                                               &relative);
   return file_system_context()->CreateCrackedFileSystemURL(
       dest_root_.origin(),
       dest_root_.mount_type(),
       relative);
 }
 
 LocalFileSystemOperation* CrossOperationDelegate::NewDestOperation() {
   return NewNestedOperation();
 }
 
 LocalFileSystemOperation* CrossOperationDelegate::NewSourceOperation() {
   if (same_file_system_)
     return NewDestOperation();
   return src_root_operation_->CreateNestedOperation();
 }
 
 }  // namespace fileapi