Make isolated file system works for a device root (e.g. X:\\)

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 58 matching lines @@
         NULL /* quota_manager */,
         data_dir_.path(),
         CreateAllowFileAccessOptions());
 
     // For cross-FileUtil copy/move tests.
     other_file_util_.reset(new LocalFileUtil());
     other_file_util_helper_.SetUp(file_system_context_, other_file_util_.get());
   }
 
   void TearDown() {
-    isolated_context()->RevokeIsolatedFileSystem(filesystem_id_);
+    isolated_context()->RevokeFileSystem(filesystem_id_);
     other_file_util_helper_.TearDown();
   }
 
  protected:
   IsolatedContext* isolated_context() const {
     return IsolatedContext::GetInstance();
   }
   const 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_.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();
   }
 
   FileSystemURL GetFileSystemURL(const FilePath& path) const {
-    FilePath virtual_path = isolated_context()->CreateVirtualPath(
-        filesystem_id(), path);
+    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);
   }
 
   void VerifyFilesHaveSameContent(FileSystemFileUtil* file_util1,
@@ skipping 72 matching lines @@
   scoped_ptr<FileSystemOperationContext> GetOperationContext() {
     return make_scoped_ptr(
         new FileSystemOperationContext(file_system_context())).Pass();
   }
 
 
  private:
   void SimulateDropFiles() {
     size_t root_path_index = 0;
 
-    std::set<FilePath> toplevels;
+    std::vector<IsolatedContext::FileInfo> toplevels;
     for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) {
       const test::TestCaseRecord& test_case = test::kRegularTestCases[i];
       FilePath path(test_case.path);
       FilePath toplevel = GetTopLevelPath(path);
 
       // We create the test case files under one of the kRootPaths
       // to simulate a drop with multiple directories.
       if (toplevel_root_map_.find(toplevel) == toplevel_root_map_.end()) {
         FilePath root = root_path().Append(
             kRootPaths[(root_path_index++) % arraysize(kRootPaths)]);
         toplevel_root_map_[toplevel] = root;
-        toplevels.insert(root.Append(path));
+        path = root.Append(path);
+        toplevels.push_back(IsolatedContext::FileInfo(
+            IsolatedContext::GetNameForPath(path), path));
       }
 
       test::SetUpOneTestCase(toplevel_root_map_[toplevel], test_case);
     }
 
     // Register the toplevel entries.
-    filesystem_id_ = isolated_context()->RegisterIsolatedFileSystem(toplevels);
+    filesystem_id_ = isolated_context()->RegisterFileSystem(toplevels);
   }
 
   ScopedTempDir data_dir_;
   MessageLoop message_loop_;
   std::string filesystem_id_;
   scoped_refptr<FileSystemContext> file_system_context_;
   std::map<FilePath, FilePath> toplevel_root_map_;
   scoped_ptr<IsolatedFileUtil> file_util_;
   scoped_ptr<LocalFileUtil> other_file_util_;
   FileSystemTestOriginHelper other_file_util_helper_;
@@ skipping 120 matching lines @@
 TEST_F(IsolatedFileUtilTest, GetLocalFilePathTest) {
   for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) {
     const test::TestCaseRecord& test_case = test::kRegularTestCases[i];
     FileSystemURL url = GetFileSystemURL(FilePath(test_case.path));
 
     FileSystemOperationContext context(file_system_context());
 
     FilePath local_file_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               file_util()->GetLocalFilePath(&context, url, &local_file_path));
-    EXPECT_EQ(GetTestCasePlatformPath(test_case.path), 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(FilePath());
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       file_util()->CreateFileEnumerator(context.get(),
                                         root_url,
@@ skipping 155 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