Re-implement IsolateFileUtil tests on top of new cross-fs operation architecture

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 <queue>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webkit/fileapi/async_file_test_helper.h"
 #include "webkit/fileapi/external_mount_points.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_task_runners.h"
-#include "webkit/fileapi/file_util_helper.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/isolated_file_util.h"
 #include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/local_file_util.h"
 #include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/fileapi/native_file_util.h"
 #include "webkit/fileapi/test_file_set.h"
 #include "webkit/quota/mock_special_storage_policy.h"
 
 using file_util::FileEnumerator;
 
 namespace fileapi {
 
 namespace {
 
+typedef AsyncFileTestHelper::FileEntryList FileEntryList;
+
 // Used in IsolatedFileUtilTest::SimulateDropFiles().
 // Random root paths in which we create each file/directory of the
 // RegularTestCases (so that we can simulate a drop with files/directories
 // from multiple directories).
 static const base::FilePath::CharType* kRootPaths[] = {
   FILE_PATH_LITERAL("a"),
   FILE_PATH_LITERAL("b/c"),
   FILE_PATH_LITERAL("etc"),
 };
 
 base::FilePath GetTopLevelPath(const base::FilePath& path) {
   std::vector<base::FilePath::StringType> components;
   path.GetComponents(&components);
   return base::FilePath(components[0]);
 }
 
-bool IsDirectoryEmpty(FileSystemOperationContext* context,
-                      FileSystemFileUtil* file_util,
-                      const FileSystemURL& url) {
-  scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum =
-      file_util->CreateFileEnumerator(context, url, false /* recursive */);
-  return file_enum->Next().empty();
+bool IsDirectoryEmpty(FileSystemContext* context, const FileSystemURL& url) {
+  FileEntryList entries;
+  EXPECT_EQ(base::PLATFORM_FILE_OK,
+            AsyncFileTestHelper::ReadDirectory(context, url, &entries));
+  return entries.empty();
+}
+
+FileSystemURL GetEntryURL(FileSystemContext* file_system_context,
+                          const FileSystemURL& dir,
+                          const FilePath::StringType& name) {
+  return file_system_context->CreateCrackedFileSystemURL(
+      dir.origin(),
+      dir.mount_type(),
+      dir.virtual_path().Append(name));
+}
+
+FilePath GetRelativeVirtualPath(const FileSystemURL& root,
+                                const FileSystemURL& url) {
+  if (root.virtual_path().empty())
+    return url.virtual_path();
+  FilePath relative;
+  const bool success = root.virtual_path().AppendRelativePath(
+      url.virtual_path(), &relative);
+  DCHECK(success);
+  return relative;
+}
+
+FileSystemURL GetOtherURL(FileSystemContext* file_system_context,
+                          const FileSystemURL& root,
+                          const FileSystemURL& other_root,
+                          const FileSystemURL& url) {
+  return file_system_context->CreateCrackedFileSystemURL(
+      other_root.origin(),
+      other_root.mount_type(),
+      other_root.virtual_path().Append(GetRelativeVirtualPath(root, url)));
 }
 
 }  // namespace
 
 // TODO(kinuko): we should have separate tests for DraggedFileUtil and
 // IsolatedFileUtil.
 class IsolatedFileUtilTest : public testing::Test {
  public:
-  IsolatedFileUtilTest()
-      : other_file_util_helper_(GURL("http://foo/"), kFileSystemTypeTest) {}
+  IsolatedFileUtilTest() {}
 
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     ASSERT_TRUE(partition_dir_.CreateUniqueTempDir());
     file_util_.reset(new DraggedFileUtil());
 
     // Register the files/directories of RegularTestCases (with random
     // root paths) as dropped files.
     SimulateDropFiles();
 
     file_system_context_ = new FileSystemContext(
         FileSystemTaskRunners::CreateMockTaskRunners(),
         ExternalMountPoints::CreateRefCounted().get(),
         make_scoped_refptr(new quota::MockSpecialStoragePolicy()),
         NULL /* quota_manager */,
         partition_dir_.path(),
         CreateAllowFileAccessOptions());
 
-    // For cross-FileUtil copy/move tests.
-    other_file_util_helper_.SetUp(file_system_context_);
-
     isolated_context()->AddReference(filesystem_id_);
   }
 
   virtual void TearDown() {
     isolated_context()->RemoveReference(filesystem_id_);
-    other_file_util_helper_.TearDown();
   }
 
  protected:
   IsolatedContext* isolated_context() const {
     return IsolatedContext::GetInstance();
   }
   const base::FilePath& root_path() const {
     return data_dir_.path();
   }
   FileSystemContext* file_system_context() const {
     return file_system_context_.get();
   }
   FileSystemFileUtil* file_util() const { return file_util_.get(); }
-  FileSystemFileUtil* other_file_util() const {
-    return other_file_util_helper_.file_util();
-  }
   std::string filesystem_id() const { return filesystem_id_; }
 
-  base::FilePath GetTestCasePlatformPath(const base::FilePath::StringType& path) {
-    return toplevel_root_map_[GetTopLevelPath(base::FilePath(path))].Append(path).
-        NormalizePathSeparators();
+  base::FilePath GetTestCasePlatformPath(
+      const base::FilePath::StringType& path) {
+    return toplevel_root_map_[GetTopLevelPath(base::FilePath(path))]
+        .Append(path).NormalizePathSeparators();
   }
 
   base::FilePath GetTestCaseLocalPath(const base::FilePath& path) {
     base::FilePath relative;
     if (data_dir_.path().AppendRelativePath(path, &relative))
       return relative;
     return path;
   }
 
   FileSystemURL GetFileSystemURL(const base::FilePath& path) const {
     base::FilePath virtual_path = isolated_context()->CreateVirtualRootPath(
         filesystem_id()).Append(path);
     return file_system_context_->CreateCrackedFileSystemURL(
         GURL("http://example.com"),
         kFileSystemTypeIsolated,
         virtual_path);
   }
 
-  FileSystemURL GetOtherFileSystemURL(const base::FilePath& path) {
-    return other_file_util_helper_.CreateURL(GetTestCaseLocalPath(path));
+  FileSystemURL GetOtherFileSystemURL(const base::FilePath& path) const {
+    return file_system_context()->CreateCrackedFileSystemURL(
+        GURL("http://example.com"),
+        kFileSystemTypeTemporary,
+        FilePath().AppendASCII("dest").Append(path));
   }
 
-  void VerifyFilesHaveSameContent(FileSystemFileUtil* file_util1,
-                                  FileSystemFileUtil* file_util2,
-                                  const FileSystemURL& url1,
+  void VerifyFilesHaveSameContent(const FileSystemURL& url1,
                                   const FileSystemURL& url2) {
-    scoped_ptr<FileSystemOperationContext> context;
-
     // Get the file info for url1.
     base::PlatformFileInfo info1;
-    base::FilePath platform_path1;
-    context.reset(new FileSystemOperationContext(file_system_context()));
+    FilePath platform_path1;
     ASSERT_EQ(base::PLATFORM_FILE_OK,
-              file_util1->GetFileInfo(context.get(), url1,
-                                      &info1, &platform_path1));
+              AsyncFileTestHelper::GetMetadata(
+                  file_system_context(), url1, &info1, &platform_path1));
 
     // Get the file info for url2.
     base::PlatformFileInfo info2;
     base::FilePath platform_path2;
-    context.reset(new FileSystemOperationContext(file_system_context()));
     ASSERT_EQ(base::PLATFORM_FILE_OK,
-              file_util2->GetFileInfo(context.get(), url2,
-                                      &info2, &platform_path2));
+              AsyncFileTestHelper::GetMetadata(
+                  file_system_context(), url2, &info2, &platform_path2));
 
     // See if file info matches with the other one.
     EXPECT_EQ(info1.is_directory, info2.is_directory);
     EXPECT_EQ(info1.size, info2.size);
     EXPECT_EQ(info1.is_symbolic_link, info2.is_symbolic_link);
     EXPECT_NE(platform_path1, platform_path2);
 
     std::string content1, content2;
     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,
+  void VerifyDirectoriesHaveSameContent(const FileSystemURL& root1,
                                         const FileSystemURL& root2) {
-    scoped_ptr<FileSystemOperationContext> context;
     base::FilePath root_path1 = root1.path();
     base::FilePath root_path2 = root2.path();
 
-    context.reset(new FileSystemOperationContext(file_system_context()));
-    scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum1 =
-        file_util1->CreateFileEnumerator(context.get(), root1,
-                                         true /* recursive */);
+    FileEntryList entries;
+    std::queue<FileSystemURL> directories;
 
-    base::FilePath current;
+    directories.push(root1);
     std::set<base::FilePath> file_set1;
-    while (!(current = file_enum1->Next()).empty()) {
-      if (file_enum1->IsDirectory())
-        continue;
-      base::FilePath relative;
-      root_path1.AppendRelativePath(current, &relative);
-      file_set1.insert(relative);
+    while (!directories.empty()) {
+      FileSystemURL dir = directories.front();
+      directories.pop();
+
+      ASSERT_EQ(base::PLATFORM_FILE_OK,
+                AsyncFileTestHelper::ReadDirectory(
+                    file_system_context(), dir, &entries));
+      for (size_t i = 0; i < entries.size(); ++i) {
+        FileSystemURL url = GetEntryURL(file_system_context(),
+                                        dir, entries[i].name);
+        if (entries[i].is_directory) {
+          directories.push(url);
+          continue;
+        }
+        file_set1.insert(GetRelativeVirtualPath(root1, url));
+      }
     }
 
-    context.reset(new FileSystemOperationContext(file_system_context()));
-    scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum2 =
-        file_util2->CreateFileEnumerator(context.get(), root2,
-                                         true /* recursive */);
+    directories.push(root2);
+    while (!directories.empty()) {
+      FileSystemURL dir = directories.front();
+      directories.pop();
 
-    while (!(current = file_enum2->Next()).empty()) {
-      base::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(IsDirectoryEmpty(&context1, file_util1, url1),
-                  IsDirectoryEmpty(&context2, file_util2, url2));
-        continue;
+      ASSERT_EQ(base::PLATFORM_FILE_OK,
+                AsyncFileTestHelper::ReadDirectory(
+                    file_system_context(), dir, &entries));
+      for (size_t i = 0; i < entries.size(); ++i) {
+        FileSystemURL url2 = GetEntryURL(file_system_context(),
+                                         dir, entries[i].name);
+        FileSystemURL url1 = GetOtherURL(file_system_context(),
+                                         root2, root1, url2);
+        if (entries[i].is_directory) {
+          directories.push(url2);
+          EXPECT_EQ(IsDirectoryEmpty(file_system_context(), url1),
+                    IsDirectoryEmpty(file_system_context(), url2));
+          continue;
+        }
+        base::FilePath relative = GetRelativeVirtualPath(root2, url2);
+        EXPECT_TRUE(file_set1.find(relative) != file_set1.end());
+        VerifyFilesHaveSameContent(url1, url2);
       }
-      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();
   }
 
 
  private:
@@ skipping 22 matching lines @@
     filesystem_id_ = isolated_context()->RegisterDraggedFileSystem(toplevels);
   }
 
   base::ScopedTempDir data_dir_;
   base::ScopedTempDir partition_dir_;
   MessageLoop message_loop_;
   std::string filesystem_id_;
   scoped_refptr<FileSystemContext> file_system_context_;
   std::map<base::FilePath, base::FilePath> toplevel_root_map_;
   scoped_ptr<IsolatedFileUtil> file_util_;
-  LocalFileSystemTestOriginHelper other_file_util_helper_;
   DISALLOW_COPY_AND_ASSIGN(IsolatedFileUtilTest);
 };
 
 TEST_F(IsolatedFileUtilTest, BasicTest) {
   for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) {
     SCOPED_TRACE(testing::Message() << "Testing RegularTestCases " << i);
     const test::TestCaseRecord& test_case = test::kRegularTestCases[i];
 
     FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
 
@@ skipping 60 matching lines @@
 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;
 
     SCOPED_TRACE(testing::Message() << "Testing RegularTestCases " << i
                  << ": " << test_case.path);
 
     // Read entries in the directory to construct the expected results map.
-    typedef std::map<base::FilePath::StringType, base::FileUtilProxy::Entry> EntryMap;
+    typedef std::map<base::FilePath::StringType,
+                     base::FileUtilProxy::Entry> EntryMap;
     EntryMap expected_entry_map;
 
     FileEnumerator file_enum(
         GetTestCasePlatformPath(test_case.path), false /* not recursive */,
         FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
     base::FilePath current;
     while (!(current = file_enum.Next()).empty()) {
       FileEnumerator::FindInfo file_info;
       file_enum.GetFindInfo(&file_info);
       base::FileUtilProxy::Entry entry;
       entry.is_directory = FileEnumerator::IsDirectory(file_info);
       entry.name = current.BaseName().value();
       entry.size = FileEnumerator::GetFilesize(file_info);
       entry.last_modified_time = FileEnumerator::GetLastModifiedTime(file_info);
       expected_entry_map[entry.name] = entry;
     }
 
     // Perform ReadDirectory in the isolated filesystem.
     FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
-    std::vector<base::FileUtilProxy::Entry> entries;
-    FileSystemOperationContext context(file_system_context());
+    FileEntryList entries;
     ASSERT_EQ(base::PLATFORM_FILE_OK,
-              FileUtilHelper::ReadDirectory(
-                  &context, file_util(), url, &entries));
+              AsyncFileTestHelper::ReadDirectory(
+                  file_system_context(), url, &entries));
 
     EXPECT_EQ(expected_entry_map.size(), entries.size());
     for (size_t i = 0; i < entries.size(); ++i) {
       const base::FileUtilProxy::Entry& entry = entries[i];
       EntryMap::iterator found = expected_entry_map.find(entry.name);
       EXPECT_TRUE(found != expected_entry_map.end());
       EXPECT_EQ(found->second.name, entry.name);
       EXPECT_EQ(found->second.is_directory, entry.is_directory);
       EXPECT_EQ(found->second.size, entry.size);
       EXPECT_EQ(found->second.last_modified_time.ToDoubleT(),
@@ skipping 11 matching lines @@
 
     base::FilePath local_file_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               file_util()->GetLocalFilePath(&context, url, &local_file_path));
     EXPECT_EQ(GetTestCasePlatformPath(test_case.path).value(),
               local_file_path.value());
   }
 }
 
 TEST_F(IsolatedFileUtilTest, CopyOutFileTest) {
-  scoped_ptr<FileSystemOperationContext> context(
-      new FileSystemOperationContext(file_system_context()));
-  FileSystemURL root_url = GetFileSystemURL(base::FilePath());
-  scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
-      file_util()->CreateFileEnumerator(context.get(),
-                                        root_url,
-                                        true /* recursive */));
-  base::FilePath current;
-  while (!(current = file_enum->Next()).empty()) {
-    if (file_enum->IsDirectory())
-      continue;
+  FileSystemURL src_root = GetFileSystemURL(base::FilePath());
+  FileSystemURL dest_root = GetOtherFileSystemURL(base::FilePath());
 
-    SCOPED_TRACE(testing::Message() << "Testing file copy "
-                 << current.value());
+  FileEntryList entries;
+  std::queue<FileSystemURL> directories;
+  directories.push(src_root);
 
-    FileSystemURL src_url = root_url.WithPath(current);
-    FileSystemURL dest_url = GetOtherFileSystemURL(current);
+  ASSERT_EQ(base::PLATFORM_FILE_OK,
+            AsyncFileTestHelper::CreateDirectory(file_system_context(),
+                                                 dest_root));
 
-    // Create the parent directory of the destination.
-    context.reset(new FileSystemOperationContext(file_system_context()));
+  while (!directories.empty()) {
+    FileSystemURL dir = directories.front();
+    directories.pop();
     ASSERT_EQ(base::PLATFORM_FILE_OK,
-              other_file_util()->CreateDirectory(
-                  context.get(),
-                  GetOtherFileSystemURL(current.DirName()),
-                  false /* exclusive */,
-                  true /* recursive */));
+              AsyncFileTestHelper::ReadDirectory(file_system_context(),
+                                                 dir, &entries));
+    for (size_t i = 0; i < entries.size(); ++i) {
+      FileSystemURL src_url = GetEntryURL(file_system_context(),
+                                          dir, entries[i].name);
+      FileSystemURL dest_url = GetOtherURL(file_system_context(),
+                                           src_root, dest_root, src_url);
 
-    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));
-
-    VerifyFilesHaveSameContent(file_util(), other_file_util(),
-                               src_url, dest_url);
+      if (entries[i].is_directory) {
+        ASSERT_EQ(base::PLATFORM_FILE_OK,
+                  AsyncFileTestHelper::CreateDirectory(file_system_context(),
+                                                       dest_url));
+        directories.push(src_url);
+        continue;
+      }
+      SCOPED_TRACE(testing::Message() << "Testing file copy "
+                   << src_url.path().value());
+      ASSERT_EQ(base::PLATFORM_FILE_OK,
+                AsyncFileTestHelper::Copy(file_system_context(),
+                                          src_url, dest_url));
+      VerifyFilesHaveSameContent(src_url, dest_url);
+    }
   }
 }
 
 TEST_F(IsolatedFileUtilTest, CopyOutDirectoryTest) {
-  scoped_ptr<FileSystemOperationContext> context(
-      new FileSystemOperationContext(file_system_context()));
-  FileSystemURL root_url = GetFileSystemURL(base::FilePath());
-  scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
-      file_util()->CreateFileEnumerator(context.get(),
-                                        root_url,
-                                        false /* recursive */));
-  base::FilePath current;
-  while (!(current = file_enum->Next()).empty()) {
-    if (!file_enum->IsDirectory())
+  FileSystemURL src_root = GetFileSystemURL(base::FilePath());
+  FileSystemURL dest_root = GetOtherFileSystemURL(base::FilePath());
+
+  ASSERT_EQ(base::PLATFORM_FILE_OK,
+            AsyncFileTestHelper::CreateDirectory(file_system_context(),
+                                                 dest_root));
+
+  FileEntryList entries;
+  ASSERT_EQ(base::PLATFORM_FILE_OK,
+            AsyncFileTestHelper::ReadDirectory(file_system_context(),
+                                               src_root, &entries));
+  for (size_t i = 0; i < entries.size(); ++i) {
+    if (!entries[i].is_directory)
       continue;
-
-    SCOPED_TRACE(testing::Message() << "Testing directory copy "
-                 << current.value());
-
-    FileSystemURL src_url = root_url.WithPath(current);
-    FileSystemURL dest_url = GetOtherFileSystemURL(current);
-
-    // Create the parent directory of the destination.
-    context.reset(new FileSystemOperationContext(file_system_context()));
+    FileSystemURL src_url = GetEntryURL(file_system_context(),
+                                        src_root, entries[i].name);
+    FileSystemURL dest_url = GetOtherURL(file_system_context(),
+                                         src_root, dest_root, src_url);
+    SCOPED_TRACE(testing::Message() << "Testing file copy "
+                 << src_url.path().value());
     ASSERT_EQ(base::PLATFORM_FILE_OK,
-              other_file_util()->CreateDirectory(
-                  context.get(),
-                  GetOtherFileSystemURL(current.DirName()),
-                  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));
-
-    VerifyDirectoriesHaveSameContent(file_util(), other_file_util(),
-                                     src_url, dest_url);
+              AsyncFileTestHelper::Copy(file_system_context(),
+                                        src_url, dest_url));
+    VerifyDirectoriesHaveSameContent(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;
     SCOPED_TRACE(testing::Message() << test_case.path);
     FileSystemURL url = GetFileSystemURL(base::FilePath(test_case.path));
@@ skipping 40 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