Enables internal filesystem types via Isolated filesystems

webkit/fileapi/isolated_file_util_unittest.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 <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 32 matching lines @@
 };
 
 FilePath GetTopLevelPath(const FilePath& path) {
   std::vector<FilePath::StringType> components;
   path.GetComponents(&components);
   return FilePath(components[0]);
 }
 
 }  // namespace
 
+// TODO(kinuko): we should have separate tests for DraggedFileUtil and
+// IsolatedFileUtil.
 class IsolatedFileUtilTest : public testing::Test {
  public:
   IsolatedFileUtilTest() {}
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
-    file_util_.reset(new IsolatedFileUtil());
+    file_util_.reset(new DraggedFileUtil());
 
     // Register the files/directories of RegularTestCases (with random
     // root paths) as dropped files.
     SimulateDropFiles();
 
     file_system_context_ = new FileSystemContext(
         base::MessageLoopProxy::current(),
         base::MessageLoopProxy::current(),
         make_scoped_refptr(new quota::MockSpecialStoragePolicy()),
         NULL /* quota_manager */,
@@ skipping 22 matching lines @@
   }
   FileSystemFileUtil* file_util() const { return file_util_.get(); }
   FileSystemFileUtil* other_file_util() const { return other_file_util_.get(); }
   std::string filesystem_id() const { return filesystem_id_; }
 
   FilePath GetTestCasePlatformPath(const FilePath::StringType& path) {
     return toplevel_root_map_[GetTopLevelPath(FilePath(path))].Append(path).
         NormalizePathSeparators();
   }
 
+  FilePath GetTestCaseLocalPath(const FilePath& path) {
+    FilePath relative;
+    if (data_dir_.path().AppendRelativePath(path, &relative))
+      return relative;
+    return path;
+  }
+
   FileSystemURL GetFileSystemURL(const FilePath& path) const {
     FilePath virtual_path = isolated_context()->CreateVirtualRootPath(
         filesystem_id()).Append(path);
     return FileSystemURL(GURL("http://example.com"),
                          kFileSystemTypeIsolated,
                          virtual_path);
   }
 
   FileSystemURL GetOtherFileSystemURL(const FilePath& path) {
-    return other_file_util_helper_.CreateURL(path);
+    return other_file_util_helper_.CreateURL(GetTestCaseLocalPath(path));
   }
 
   void VerifyFilesHaveSameContent(FileSystemFileUtil* file_util1,
                                   FileSystemFileUtil* file_util2,
                                   const FileSystemURL& url1,
                                   const FileSystemURL& url2) {
     scoped_ptr<FileSystemOperationContext> context;
 
     // Get the file info for url1.
     base::PlatformFileInfo info1;
@@ skipping 21 matching lines @@
     EXPECT_TRUE(file_util::ReadFileToString(platform_path1, &content1));
     EXPECT_TRUE(file_util::ReadFileToString(platform_path2, &content2));
     EXPECT_EQ(content1, content2);
   }
 
   void VerifyDirectoriesHaveSameContent(FileSystemFileUtil* file_util1,
                                         FileSystemFileUtil* file_util2,
                                         const FileSystemURL& root1,
                                         const FileSystemURL& root2) {
     scoped_ptr<FileSystemOperationContext> context;
+    FilePath root_path1 = root1.path();
+    FilePath root_path2 = root2.path();
 
     scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum1;
     context.reset(new FileSystemOperationContext(file_system_context()));
     file_enum1.reset(file_util1->CreateFileEnumerator(
         context.get(), root1, true /* recursive */));
 
     FilePath current;
     std::set<FilePath> file_set1;
     while (!(current = file_enum1->Next()).empty()) {
       if (file_enum1->IsDirectory())
         continue;
-      file_set1.insert(current);
+      FilePath relative;
+      root_path1.AppendRelativePath(current, &relative);
+      file_set1.insert(relative);
     }
 
     scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum2;
     context.reset(new FileSystemOperationContext(file_system_context()));
     file_enum2.reset(file_util2->CreateFileEnumerator(
         context.get(), root2, true /* recursive */));
 
     while (!(current = file_enum2->Next()).empty()) {
-      FileSystemURL url1 = root1.WithPath(current);
-      FileSystemURL url2 = root2.WithPath(current);
+      FilePath relative;
+      root_path2.AppendRelativePath(current, &relative);
+      FileSystemURL url1 = root1.WithPath(root_path1.Append(relative));
+      FileSystemURL url2 = root2.WithPath(root_path2.Append(relative));
       if (file_enum2->IsDirectory()) {
         FileSystemOperationContext context1(file_system_context());
         FileSystemOperationContext context2(file_system_context());
         EXPECT_EQ(file_util1->IsDirectoryEmpty(&context1, url1),
                   file_util2->IsDirectoryEmpty(&context2, url2));
         continue;
       }
-      EXPECT_TRUE(file_set1.find(current) != file_set1.end());
+      EXPECT_TRUE(file_set1.find(relative) != file_set1.end());
       VerifyFilesHaveSameContent(file_util1, file_util2, url1, url2);
     }
   }
 
   scoped_ptr<FileSystemOperationContext> GetOperationContext() {
     return make_scoped_ptr(
         new FileSystemOperationContext(file_system_context())).Pass();
   }
 
 
@@ skipping 87 matching lines @@
   for (size_t i = 0; i < arraysize(kUnregisteredCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Creating kUnregisteredCases " << i);
     const test::TestCaseRecord& test_case = kUnregisteredCases[i];
     FileSystemURL url = GetFileSystemURL(FilePath(test_case.path));
 
     // This should fail as the paths in kUnregisteredCases are not included
     // in the dropped files (i.e. the regular test cases).
     base::PlatformFileInfo info;
     FilePath platform_path;
     FileSystemOperationContext context(file_system_context());
-    ASSERT_EQ(base::PLATFORM_FILE_ERROR_SECURITY,
+    ASSERT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
               file_util()->GetFileInfo(&context, url, &info, &platform_path));
   }
 }
 
 TEST_F(IsolatedFileUtilTest, ReadDirectoryTest) {
   for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) {
     const test::TestCaseRecord& test_case = test::kRegularTestCases[i];
     if (!test_case.is_directory)
       continue;
 
@@ skipping 86 matching lines @@
                   false /* exclusive */,
                   true /* recursive */));
 
     context.reset(new FileSystemOperationContext(file_system_context()));
     ASSERT_EQ(base::PLATFORM_FILE_OK,
               FileUtilHelper::Copy(
                   context.get(),
                   file_util(), other_file_util(),
                   src_url, dest_url));
 
-    // The other way (copy-in) should not work.
-    context.reset(new FileSystemOperationContext(file_system_context()));
-    ASSERT_EQ(base::PLATFORM_FILE_ERROR_SECURITY,
-              FileUtilHelper::Copy(
-                  context.get(),
-                  other_file_util(), file_util(),
-                  dest_url, src_url));
-
     VerifyFilesHaveSameContent(file_util(), other_file_util(),
                                src_url, dest_url);
   }
 }
 
 TEST_F(IsolatedFileUtilTest, CopyOutDirectoryTest) {
   scoped_ptr<FileSystemOperationContext> context(
       new FileSystemOperationContext(file_system_context()));
   FileSystemURL root_url = GetFileSystemURL(FilePath());
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
@@ skipping 20 matching lines @@
                   false /* exclusive */,
                   true /* recursive */));
 
     context.reset(new FileSystemOperationContext(file_system_context()));
     ASSERT_EQ(base::PLATFORM_FILE_OK,
               FileUtilHelper::Copy(
                   context.get(),
                   file_util(), other_file_util(),
                   src_url, dest_url));
 
-    // The other way (copy-in) should not work for two reasons:
-    // write is prohibited in the isolated filesystem, and copying directory
-    // to non-empty directory shouldn't work.
-    context.reset(new FileSystemOperationContext(file_system_context()));
-    base::PlatformFileError result = FileUtilHelper::Copy(
-        context.get(), other_file_util(), file_util(), dest_url, src_url);
-    ASSERT_TRUE(result == base::PLATFORM_FILE_ERROR_FAILED ||
-                result == base::PLATFORM_FILE_ERROR_NOT_EMPTY);
-
     VerifyDirectoriesHaveSameContent(file_util(), other_file_util(),
                                      src_url, dest_url);
   }
 }
 
 TEST_F(IsolatedFileUtilTest, TouchTest) {
   for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) {
     const test::TestCaseRecord& test_case = test::kRegularTestCases[i];
     if (test_case.is_directory)
       continue;
@@ skipping 42 matching lines @@
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               file_util()->Truncate(GetOperationContext().get(), url, 999));
     ASSERT_EQ(base::PLATFORM_FILE_OK,
               file_util()->GetFileInfo(GetOperationContext().get(), url,
                                        &info, &platform_path));
     EXPECT_EQ(999, info.size);
   }
 }
 
 }  // namespace fileapi