Enable cross-filesystem moves and copies.

webkit/fileapi/obfuscated_file_system_file_util_unittest.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 <algorithm>
 #include <set>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 18 matching lines @@
 #elif defined(OS_WIN)
   result = base::SysUTF8ToWide(str);
 #endif
   return FilePath(result);
 }
 
 bool FileExists(const FilePath& path) {
   return file_util::PathExists(path) && !file_util::DirectoryExists(path);
 }
 
+int64 GetSize(const FilePath& path) {
+  int64 size;
+  EXPECT_TRUE(file_util::GetFileSize(path, &size));
+  return size;
+}
+
 // After a move, the dest exists and the source doesn't.
 // After a copy, both source and dest exist.
 struct CopyMoveTestCaseRecord {
   bool is_copy_not_move;
   const char source_path[64];
   const char dest_path[64];
   bool cause_overwrite;
 };
 
 const CopyMoveTestCaseRecord kCopyMoveTestCases[] = {
@@ skipping 101 matching lines @@
   }
 
   const GURL& origin_url() const {
     return origin_;
   }
 
   fileapi::FileSystemType type() const {
     return type_;
   }
 
-  int64 GetSize(const FilePath& path) {
-    int64 size;
-    EXPECT_TRUE(file_util::GetFileSize(path, &size));
-    return size;
-  }
-
   void CheckFileAndCloseHandle(
       const FilePath& virtual_path, PlatformFile file_handle) {
     scoped_ptr<FileSystemOperationContext> context(NewContext());
     FilePath local_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetLocalFilePath(
         context.get(), virtual_path, &local_path));
 
     base::PlatformFileInfo file_info0;
     FilePath data_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
         context.get(), virtual_path, &file_info0, &data_path));
     EXPECT_EQ(data_path, local_path);
     EXPECT_TRUE(FileExists(data_path));
     EXPECT_EQ(0, GetSize(data_path));
 
     const char data[] = "test data";
     const int length = arraysize(data) - 1;
 
     if (base::kInvalidPlatformFileValue == file_handle) {
       bool created = true;
       PlatformFileError error;
       file_handle = base::CreatePlatformFile(
           data_path,
           base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE,
           &created,
           &error);
+      ASSERT_NE(base::kInvalidPlatformFileValue, file_handle);
       ASSERT_EQ(base::PLATFORM_FILE_OK, error);
       EXPECT_FALSE(created);
     }
     ASSERT_EQ(length, base::WritePlatformFile(file_handle, 0, data, length));
     EXPECT_TRUE(base::ClosePlatformFile(file_handle));
 
     base::PlatformFileInfo file_info1;
     EXPECT_EQ(length, GetSize(data_path));
     context.reset(NewContext());
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
@@ skipping 131 matching lines @@
     last_modified_time += base::TimeDelta::FromHours(1);
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofsfu()->Touch(
                   context.get(), path, last_access_time, last_modified_time));
     context.reset(NewContext());
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
         context.get(), path, &file_info, &local_path));
     EXPECT_EQ(file_info.last_modified.ToTimeT(), last_modified_time.ToTimeT());
   }
 
+  void TestCopyInForeignFileHelper(bool overwrite) {
+    ScopedTempDir source_dir;
+    ASSERT_TRUE(source_dir.CreateUniqueTempDir());
+    FilePath root_path = source_dir.path();
+    FilePath src_path = root_path.AppendASCII("file_name");
+    FilePath dest_path(FILE_PATH_LITERAL("new file"));
+    int64 src_file_length = 87;
+
+    base::PlatformFileError error_code;
+    bool created = false;
+    int file_flags = base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE;
+    base::PlatformFile file_handle =
+        base::CreatePlatformFile(
+            src_path, file_flags, &created, &error_code);
+    EXPECT_TRUE(created);
+    ASSERT_EQ(base::PLATFORM_FILE_OK, error_code);
+    ASSERT_NE(base::kInvalidPlatformFileValue, file_handle);
+    ASSERT_TRUE(base::TruncatePlatformFile(file_handle, src_file_length));
+    EXPECT_TRUE(base::ClosePlatformFile(file_handle));
+
+    scoped_ptr<FileSystemOperationContext> context;
+
+    if (overwrite) {
+      context.reset(NewContext());
+      EXPECT_EQ(base::PLATFORM_FILE_OK,
+          ofsfu()->EnsureFileExists(context.get(), dest_path, &created));
+      EXPECT_TRUE(created);
+    }
+
+    context.reset(NewContext());
+    EXPECT_EQ(base::PLATFORM_FILE_OK,
+        ofsfu()->CopyInForeignFile(context.get(), src_path, dest_path));
+    context.reset(NewContext());
+    EXPECT_TRUE(ofsfu()->PathExists(context.get(), dest_path));
+    context.reset(NewContext());
+    EXPECT_FALSE(ofsfu()->DirectoryExists(context.get(), dest_path));
+    context.reset(NewContext());
+    base::PlatformFileInfo file_info;
+    FilePath data_path;
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
+        context.get(), dest_path, &file_info, &data_path));
+    EXPECT_NE(data_path, src_path);
+    EXPECT_TRUE(FileExists(data_path));
+    EXPECT_EQ(src_file_length, GetSize(data_path));
+
+    EXPECT_EQ(base::PLATFORM_FILE_OK,
+        ofsfu()->DeleteFile(context.get(), dest_path));
+  }
+
  private:
   ScopedTempDir data_dir_;
   scoped_refptr<ObfuscatedFileSystemFileUtil> obfuscated_file_system_file_util_;
   GURL origin_;
   fileapi::FileSystemType type_;
   FileSystemTestOriginHelper test_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileSystemFileUtilTest);
 };
 
@@ skipping 421 matching lines @@
     FilePath local_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
         context.get(), dest_path, &file_info, &local_path));
     EXPECT_EQ(kSourceLength, file_info.size);
 
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofsfu()->DeleteFile(context.get(), dest_path));
   }
 }
 
+TEST_F(ObfuscatedFileSystemFileUtilTest, TestCopyInForeignFile) {
+  TestCopyInForeignFileHelper(false /* overwrite */);
+  TestCopyInForeignFileHelper(true /* overwrite */);
+}
+
 TEST_F(ObfuscatedFileSystemFileUtilTest, TestEnumerator) {
   scoped_ptr<FileSystemOperationContext> context(NewContext());
   FilePath src_path = UTF8ToFilePath("source dir");
   bool exclusive = true;
   bool recursive = false;
   ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
       context.get(), src_path, exclusive, recursive));
 
   std::set<FilePath::StringType> files;
   std::set<FilePath::StringType> directories;
@@ skipping 34 matching lines @@
       ASSERT_TRUE(
           file_util::CreateDirectory(local_src_path));
     } else {
       base::PlatformFileError error_code;
       bool created = false;
       int file_flags = base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE;
       base::PlatformFile file_handle =
           base::CreatePlatformFile(
               local_src_path, file_flags, &created, &error_code);
       EXPECT_TRUE(created);
+      ASSERT_NE(base::kInvalidPlatformFileValue, file_handle);
       ASSERT_EQ(base::PLATFORM_FILE_OK, error_code);
       ASSERT_TRUE(
           base::TruncatePlatformFile(file_handle, test_case.data_file_size));
       EXPECT_TRUE(base::ClosePlatformFile(file_handle));
     }
   }
 
   EXPECT_TRUE(ofsfu()->MigrateFromOldSandbox(origin_url(), type(), root_path));
 
   FilePath new_root =
@@ skipping 91 matching lines @@
     }
     EXPECT_TRUE(found);
   }
 
   std::set<GURL> diff;
   std::set_symmetric_difference(origins_expected.begin(),
       origins_expected.end(), origins_found.begin(), origins_found.end(),
       inserter(diff, diff.begin()));
   EXPECT_TRUE(diff.empty());
 }