Enable cross-filesystem moves and copies.

webkit/fileapi/file_system_file_util.cc

 // Copyright (c) 2011 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/file_system_file_util.h"
 
 #include <stack>
 
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 
 namespace fileapi {
 
+namespace {
+
+// This assumes that the root exists.
+bool ParentExists(FileSystemOperationContext* context,
+    FileSystemFileUtil* file_util, const FilePath& file_path) {
+  // If file_path is in the root, file_path.DirName() will be ".",
+  // since we use paths with no leading '/'.
+  FilePath parent = file_path.DirName();
+  if (parent != FilePath(FILE_PATH_LITERAL(".")) &&
+      !file_util->DirectoryExists(context, parent))
+    return false;

[michaeln, 2011/05/25 20:30:11]

nit: maybe could be more readable...

FilePath parent = file_path.DirName();
if (parent == FilePath(FILE_PATH_LITERAL("."))
  return true;
return file_util->DirectoryExists(context, parent);

or

FilePath parent = file_path.DirName();
return parent == FilePath(FILE_PATH_LITERAL(".")) ||
       file_util->DirectoryExists(context, parent);

[ericu, 2011/05/25 21:51:58]

Done.

+  return true;
+}
+
+}
+
 // static
 FileSystemFileUtil* FileSystemFileUtil::GetInstance() {
   return Singleton<FileSystemFileUtil>::get();
 }
 
 PlatformFileError FileSystemFileUtil::CreateOrOpen(
     FileSystemOperationContext* unused,
     const FilePath& file_path, int file_flags,
     PlatformFile* file_handle, bool* created) {
   if (!file_util::DirectoryExists(file_path.DirName())) {
@@ skipping 115 matching lines @@
   PlatformFileError error_code;
   error_code =
       PerformCommonCheckAndPreparationForMoveAndCopy(
           context, src_file_path, dest_file_path);
   if (error_code != base::PLATFORM_FILE_OK)
     return error_code;
 
   if (DirectoryExists(context, src_file_path))
     return CopyOrMoveDirectory(context, src_file_path, dest_file_path,
                                true /* copy */);
-  else
-    return CopyOrMoveFile(context, src_file_path, dest_file_path,
-                          true /* copy */);
+  return CopyOrMoveFileHelper(context, src_file_path, dest_file_path,
+                              true /* copy */);
 }
 
 PlatformFileError FileSystemFileUtil::Move(
     FileSystemOperationContext* context,
     const FilePath& src_file_path,
     const FilePath& dest_file_path) {
   PlatformFileError error_code;
   error_code =
       PerformCommonCheckAndPreparationForMoveAndCopy(
           context, src_file_path, dest_file_path);
   if (error_code != base::PLATFORM_FILE_OK)
     return error_code;
 
   // TODO(dmikurube): ReplaceFile if in the same domain and filesystem type.
   if (DirectoryExists(context, src_file_path))
     return CopyOrMoveDirectory(context, src_file_path, dest_file_path,
                                false /* copy */);
-  else
-    return CopyOrMoveFile(context, src_file_path, dest_file_path,
-                          false /* copy */);
+  return CopyOrMoveFileHelper(context, src_file_path, dest_file_path,
+                              false /* copy */);
 }
 
 PlatformFileError FileSystemFileUtil::Delete(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     bool recursive) {
   if (DirectoryExists(context, file_path)) {
     if (!recursive)
       return DeleteSingleDirectory(context, file_path);
     else
@@ skipping 31 matching lines @@
     error_code = base::PLATFORM_FILE_ERROR_FAILED;
   base::ClosePlatformFile(file);
   return error_code;
 }
 
 PlatformFileError
 FileSystemFileUtil::PerformCommonCheckAndPreparationForMoveAndCopy(
     FileSystemOperationContext* context,
     const FilePath& src_file_path,
     const FilePath& dest_file_path) {
+  bool same_file_system =
+     (context->src_origin_url() == context->dest_origin_url()) &&
+     (context->src_type() == context->dest_type());
+  FileSystemFileUtil* dest_util = context->dest_file_system_file_util();
+  DCHECK(dest_util);
+  FileSystemOperationContext local_dest_context(
+      context->file_system_context(), dest_util);
+  FileSystemOperationContext* dest_context;
+  if (same_file_system) {
+    dest_context = context;
+    DCHECK(context->src_file_system_file_util() ==
+         context->dest_file_system_file_util());
+  } else {
+    // All the single-path virtual FSFU methods expect the context information
+    // to be in the src_* variables, not the dest_* variables, so we have to
+    // make a new context if we want to call them on the dest_file_path.
+    dest_context = &local_dest_context;
+    dest_context->set_src_type(context->dest_type());
+    dest_context->set_src_origin_url(context->dest_origin_url());
+    dest_context->set_src_virtual_path(context->dest_virtual_path());
+    dest_context->set_allowed_bytes_growth(context->allowed_bytes_growth());
+  }
+
   // Exits earlier if the source path does not exist.
   if (!PathExists(context, src_file_path))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   // The parent of the |dest_file_path| does not exist.
-  if (!DirectoryExists(context, dest_file_path.DirName()))
+  if (!ParentExists(dest_context, dest_util, dest_file_path))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   // It is an error to try to copy/move an entry into its child.
-  if (src_file_path.IsParent(dest_file_path))
+  if (same_file_system && src_file_path.IsParent(dest_file_path))
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
 
   // Now it is ok to return if the |dest_file_path| does not exist.
-  if (!PathExists(context, dest_file_path))
+  if (!dest_util->PathExists(dest_context, dest_file_path))
     return base::PLATFORM_FILE_OK;
 
   // |src_file_path| exists and is a directory.
   // |dest_file_path| exists and is a file.
   bool src_is_directory = DirectoryExists(context, src_file_path);
-  bool dest_is_directory = DirectoryExists(context, dest_file_path);
+  bool dest_is_directory =
+      dest_util->DirectoryExists(dest_context, dest_file_path);
   if (src_is_directory && !dest_is_directory)
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
 
   // |src_file_path| exists and is a file.
   // |dest_file_path| exists and is a directory.
   if (!src_is_directory && dest_is_directory)
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
 
   // It is an error to copy/move an entry into the same path.
-  if (src_file_path.value() == dest_file_path.value())
+  if (same_file_system && (src_file_path.value() == dest_file_path.value()))
     return base::PLATFORM_FILE_ERROR_EXISTS;
 
   if (dest_is_directory) {
     // It is an error to copy/move an entry to a non-empty directory.
     // Otherwise the copy/move attempt must overwrite the destination, but
     // the file_util's Copy or Move method doesn't perform overwrite
     // on all platforms, so we delete the destination directory here.
     // TODO(kinuko): may be better to change the file_util::{Copy,Move}.
     if (base::PLATFORM_FILE_OK !=
-        Delete(context, dest_file_path, false /* recursive */)) {
-      if (!IsDirectoryEmpty(context, dest_file_path))
+        dest_util->Delete(dest_context, dest_file_path,
+                          false /* recursive */)) {
+      if (!dest_util->IsDirectoryEmpty(dest_context, dest_file_path))
         return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
       return base::PLATFORM_FILE_ERROR_FAILED;
     }
   }
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError FileSystemFileUtil::CopyOrMoveFile(
       FileSystemOperationContext* unused,
       const FilePath& src_file_path,
       const FilePath& dest_file_path,
       bool copy) {
   if (copy) {
     if (file_util::CopyFile(src_file_path, dest_file_path))
       return base::PLATFORM_FILE_OK;
   } else {
     DCHECK(!file_util::DirectoryExists(src_file_path));
     if (file_util::Move(src_file_path, dest_file_path))
       return base::PLATFORM_FILE_OK;
   }
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
+PlatformFileError FileSystemFileUtil::CopyInForeignFile(
+      FileSystemOperationContext* context,
+      const FilePath& src_file_path,
+      const FilePath& dest_file_path) {
+  return CopyOrMoveFile(context, src_file_path, dest_file_path, true);
+}
+
 PlatformFileError FileSystemFileUtil::CopyOrMoveDirectory(
       FileSystemOperationContext* context,
       const FilePath& src_file_path,
       const FilePath& dest_file_path,
       bool copy) {
+  FileSystemFileUtil* dest_util = context->dest_file_system_file_util();
+  FileSystemOperationContext dest_context(
+      context->file_system_context(), dest_util);
+  // All the single-path virtual FSFU methods expect the context information to
+  // be in the src_* variables, not the dest_* variables, so we have to make a
+  // new context if we want to call them on the dest_file_path.
+  dest_context.set_src_type(context->dest_type());
+  dest_context.set_src_origin_url(context->dest_origin_url());
+  dest_context.set_src_virtual_path(context->dest_virtual_path());
+  dest_context.set_allowed_bytes_growth(context->allowed_bytes_growth());
+
   // Re-check PerformCommonCheckAndPreparationForMoveAndCopy() by DCHECK.
   DCHECK(DirectoryExists(context, src_file_path));
-  DCHECK(DirectoryExists(context, dest_file_path.DirName()));
-  DCHECK(!src_file_path.IsParent(dest_file_path));
-  DCHECK(!PathExists(context, dest_file_path));
+  DCHECK(ParentExists(&dest_context, dest_util, dest_file_path));
+  DCHECK(!dest_util->PathExists(&dest_context, dest_file_path));
+  if ((context->src_origin_url() == context->dest_origin_url()) &&
+      (context->src_type() == context->dest_type()))
+    DCHECK(!src_file_path.IsParent(dest_file_path));
 
-  if (!DirectoryExists(context, dest_file_path)) {
-    PlatformFileError error = CreateDirectory(context,
+  if (!dest_util->DirectoryExists(&dest_context, dest_file_path)) {
+    PlatformFileError error = dest_util->CreateDirectory(&dest_context,
         dest_file_path, false, false);
     if (error != base::PLATFORM_FILE_OK)
       return error;
   }
 
   scoped_ptr<AbstractFileEnumerator> file_enum(
       CreateFileEnumerator(context, src_file_path));
   FilePath src_file_path_each;
   while (!(src_file_path_each = file_enum->Next()).empty()) {
     FilePath dest_file_path_each(dest_file_path);
     src_file_path.AppendRelativePath(src_file_path_each, &dest_file_path_each);
 
     if (file_enum->IsDirectory()) {
-      PlatformFileError error = CreateDirectory(context,
+      PlatformFileError error = dest_util->CreateDirectory(&dest_context,
           dest_file_path_each, false, false);
       if (error != base::PLATFORM_FILE_OK)
         return error;
     } else {
-      // CopyOrMoveFile here is the virtual overridden member function.
-      PlatformFileError error = CopyOrMoveFile(
+      PlatformFileError error = CopyOrMoveFileHelper(
           context, src_file_path_each, dest_file_path_each, copy);
       if (error != base::PLATFORM_FILE_OK)
         return error;
     }
   }
 
   if (!copy) {
     PlatformFileError error = Delete(context, src_file_path, true);
     if (error != base::PLATFORM_FILE_OK)
       return error;
   }
   return base::PLATFORM_FILE_OK;
 }
 
+PlatformFileError FileSystemFileUtil::CopyOrMoveFileHelper(
+    FileSystemOperationContext* context,
+    const FilePath& src_file_path,
+    const FilePath& dest_file_path,
+    bool copy) {
+  // CopyOrMoveFile here is the virtual overridden member function.
+  if ((context->src_origin_url() == context->dest_origin_url()) &&
+      (context->src_type() == context->dest_type())) {
+    DCHECK(context->src_file_system_file_util() ==
+           context->dest_file_system_file_util());
+    return CopyOrMoveFile(context, src_file_path, dest_file_path, copy);
+  }
+  base::PlatformFileInfo file_info;
+  FilePath platform_file_path;
+  PlatformFileError error_code;
+  error_code =
+      GetFileInfo(context, src_file_path, &file_info, &platform_file_path);
+  if (error_code != base::PLATFORM_FILE_OK)
+    return error_code;
+
+  DCHECK(context->dest_file_system_file_util());
+  error_code = context->dest_file_system_file_util()->CopyInForeignFile(
+      context, platform_file_path, dest_file_path);
+  if (copy || error_code != base::PLATFORM_FILE_OK)
+    return error_code;
+  return DeleteFile(context, src_file_path);
+}
+
+
 PlatformFileError FileSystemFileUtil::DeleteFile(
     FileSystemOperationContext* unused,
     const FilePath& file_path) {
   if (!file_util::PathExists(file_path))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   if (file_util::DirectoryExists(file_path))
     return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
   if (!file_util::Delete(file_path, false))
     return base::PLATFORM_FILE_ERROR_FAILED;
   return base::PLATFORM_FILE_OK;
@@ skipping 99 matching lines @@
 FileSystemFileUtil::CreateFileEnumerator(
     FileSystemOperationContext* unused,
     const FilePath& root_path) {
   return new FileSystemFileEnumerator(
       root_path, true, static_cast<file_util::FileEnumerator::FILE_TYPE>(
       file_util::FileEnumerator::FILES |
       file_util::FileEnumerator::DIRECTORIES));
 }
 
 }  // namespace fileapi