Stop returning the true root path of each filesystem from openFileSystem....

webkit/fileapi/file_system_path_manager_unittest.cc

 // Copyright (c) 2010 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_path_manager.h"
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/ref_counted.h"
 #include "base/scoped_callback_factory.h"
 #include "base/scoped_ptr.h"
 #include "base/scoped_temp_dir.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/sandbox_mount_point_provider.h"
 
 using namespace fileapi;
 
 namespace {
 
 // PS stands for path separator.
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 #define PS  "\\"
 #else
 #define PS  "/"
@@ skipping 175 matching lines @@
   }
 
   bool CheckValidFileSystemPath(FileSystemPathManager* manager,
                                 const FilePath& path) {
     return manager->CrackFileSystemPath(path, NULL, NULL, NULL);
   }
 
   FilePath data_path() { return data_dir_.path(); }
   FilePath file_system_path() {
     return data_dir_.path().Append(
-        FileSystemPathManager::kFileSystemDirectory);
+        SandboxMountPointProvider::kFileSystemDirectory);
   }
 
  private:
   ScopedTempDir data_dir_;
   base::ScopedCallbackFactory<FileSystemPathManagerTest> callback_factory_;
 
   bool root_path_callback_status_;
   FilePath root_path_;
   std::string file_system_name_;
 
@@ skipping 112 matching lines @@
                             true /* create */, &root_path));
     FilePath expected = file_system_path().AppendASCII(
         kRootPathFileURITestCases[i].expected_path);
     EXPECT_EQ(expected.value(), root_path.DirName().value());
     EXPECT_TRUE(file_util::DirectoryExists(root_path));
   }
 }
 
 TEST_F(FileSystemPathManagerTest, VirtualPathFromFileSystemPathTest) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
-  FilePath root_path;
-  EXPECT_TRUE(GetRootPath(manager.get(), GURL("http://foo.com/"),
-                          fileapi::kFileSystemTypeTemporary,
-                          true /* create */, &root_path));
+  GURL root_url = GetFileSystemRootURI(
+      GURL("http://foo.com/"), fileapi::kFileSystemTypeTemporary);
+  FilePath root_path = FilePath().AppendASCII(root_url.spec());
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kPathToVirtualPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "PathToVirtualPath #"
                  << i << " " << kPathToVirtualPathTestCases[i]);
-    FilePath absolute_path = root_path.AppendASCII(
-        kPathToVirtualPathTestCases[i]);
+    FilePath absolute_path;
+    // TODO(ericu): Clean this up when we've got more sane path-handling.
+    // This hack is necessary because root_path is actually a URL [ending with a
+    // forward slash], and AppendASCII("") on Windows will delete the trailing
+    // slash, making the path invalid as far as CrackFileSystemPath is
+    // concerned.
+    if (strlen(kPathToVirtualPathTestCases[i]))
+      absolute_path = root_path.AppendASCII(
+          kPathToVirtualPathTestCases[i]);
+    else
+      absolute_path = root_path;
     FilePath virtual_path;
     EXPECT_TRUE(manager->CrackFileSystemPath(absolute_path, NULL, NULL,
                                              &virtual_path));
 
     FilePath test_case_path;
     test_case_path = test_case_path.AppendASCII(
         kPathToVirtualPathTestCases[i]);
     EXPECT_EQ(test_case_path.value(), virtual_path.value());
   }
 }
 
 TEST_F(FileSystemPathManagerTest, TypeFromFileSystemPathTest) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
 
-  FilePath root_path;
   fileapi::FileSystemType type;
 
-  EXPECT_TRUE(GetRootPath(manager.get(), GURL("http://foo.com/"),
-                          fileapi::kFileSystemTypeTemporary,
-                          true /* create */, &root_path));
+  GURL root_url = GetFileSystemRootURI(
+      GURL("http://foo.com/"), fileapi::kFileSystemTypeTemporary);
+  FilePath root_path = FilePath().AppendASCII(root_url.spec());
   FilePath path = root_path.AppendASCII("test");
   EXPECT_TRUE(manager->CrackFileSystemPath(path, NULL, &type, NULL));
   EXPECT_EQ(fileapi::kFileSystemTypeTemporary, type);
 
-  EXPECT_TRUE(GetRootPath(manager.get(), GURL("http://foo.com/"),
-                          fileapi::kFileSystemTypePersistent,
-                          true /* create */, &root_path));
+  root_url = GetFileSystemRootURI(
+      GURL("http://foo.com/"), fileapi::kFileSystemTypePersistent);
+  root_path = FilePath().AppendASCII(root_url.spec());
   path = root_path.AppendASCII("test");
   EXPECT_TRUE(manager->CrackFileSystemPath(path, NULL, &type, NULL));
   EXPECT_EQ(fileapi::kFileSystemTypePersistent, type);
 }
 
 TEST_F(FileSystemPathManagerTest, CheckValidPath) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
-  FilePath root_path;
-  EXPECT_TRUE(GetRootPath(manager.get(), GURL("http://foo.com/"),
-                          kFileSystemTypePersistent, true, &root_path));
+  GURL root_url = GetFileSystemRootURI(
+      GURL("http://foo.com/"), fileapi::kFileSystemTypePersistent);
+  FilePath root_path = FilePath().AppendASCII(root_url.spec());
 
   // The root path must be valid, but upper directories or directories
   // that are not in our temporary or persistent directory must be
   // evaluated invalid.
   EXPECT_TRUE(CheckValidFileSystemPath(manager.get(), root_path));
   EXPECT_FALSE(CheckValidFileSystemPath(manager.get(), root_path.DirName()));
   EXPECT_FALSE(CheckValidFileSystemPath(manager.get(),
                                         root_path.DirName().DirName()));
   EXPECT_FALSE(CheckValidFileSystemPath(manager.get(),
                                         root_path.DirName().DirName()
                                             .AppendASCII("ArbitraryName")
                                             .AppendASCII("chrome-dummy")));
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kCheckValidPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "CheckValidPath #" << i << " "
                  << kCheckValidPathTestCases[i].path);
     FilePath path(kCheckValidPathTestCases[i].path);
+#ifdef FILE_PATH_USES_WIN_SEPARATORS
+    path = path.NormalizeWindowsPathSeparators();
+#endif
     if (!path.IsAbsolute())
       path = root_path.Append(path);
     EXPECT_EQ(kCheckValidPathTestCases[i].expected_valid,
               CheckValidFileSystemPath(manager.get(), path));
   }
 }
 
 TEST_F(FileSystemPathManagerTest, IsRestrictedName) {
+  scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kIsRestrictedNameTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "IsRestrictedName #" << i << " "
                  << kIsRestrictedNameTestCases[i].name);
     FilePath name(kIsRestrictedNameTestCases[i].name);
     EXPECT_EQ(kIsRestrictedNameTestCases[i].expected_dangerous,
-              FileSystemPathManager::IsRestrictedFileName(name));
+              manager->IsRestrictedFileName(kFileSystemTypeTemporary, name));
   }
 }
-
-class FileSystemPathManagerOriginEnumeratorTest : public testing::Test {
- public:
-  void SetUp() {
-    ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
-    enumerator_.reset(new FileSystemPathManager::OriginEnumerator(
-        data_dir_.path()));
-  }
-
-  FileSystemPathManager::OriginEnumerator* enumerator() const {
-    return enumerator_.get();
-  }
-
- protected:
-  void CreateOriginTypeDirectory(const std::string& origin_identifier,
-                                 fileapi::FileSystemType type) {
-    std::string type_string =
-        FileSystemPathManager::GetFileSystemTypeString(type);
-    ASSERT_TRUE(!type_string.empty());
-    FilePath target = data_dir_.path().AppendASCII(origin_identifier)
-                                      .AppendASCII(type_string);
-    file_util::CreateDirectory(target);
-    ASSERT_TRUE(file_util::DirectoryExists(target));
-  }
-
-  ScopedTempDir data_dir_;
-  scoped_ptr<FileSystemPathManager::OriginEnumerator> enumerator_;
-};
-
-TEST_F(FileSystemPathManagerOriginEnumeratorTest, Empty) {
-  ASSERT_TRUE(enumerator()->Next().empty());
-}
-
-TEST_F(FileSystemPathManagerOriginEnumeratorTest, EnumerateOrigins) {
-  const char* temporary_origins[] = {
-    "http_www.bar.com_0",
-    "http_www.foo.com_0",
-    "http_www.foo.com_80",
-    "http_www.example.com_8080",
-    "http_www.google.com_80",
-  };
-  const char* persistent_origins[] = {
-    "http_www.bar.com_0",
-    "http_www.foo.com_8080",
-    "http_www.foo.com_80",
-  };
-  size_t temporary_size = ARRAYSIZE_UNSAFE(temporary_origins);
-  size_t persistent_size = ARRAYSIZE_UNSAFE(persistent_origins);
-  std::set<std::string> temporary_set, persistent_set;
-  for (size_t i = 0; i < temporary_size; ++i) {
-    CreateOriginTypeDirectory(temporary_origins[i],
-        fileapi::kFileSystemTypeTemporary);
-    temporary_set.insert(temporary_origins[i]);
-  }
-  for (size_t i = 0; i < persistent_size; ++i) {
-    CreateOriginTypeDirectory(persistent_origins[i], kFileSystemTypePersistent);
-    persistent_set.insert(persistent_origins[i]);
-  }
-
-  size_t temporary_actual_size = 0;
-  size_t persistent_actual_size = 0;
-  std::string current;
-  while (!(current = enumerator()->Next()).empty()) {
-    SCOPED_TRACE(testing::Message() << "EnumerateOrigin " << current);
-    if (enumerator()->HasTemporary()) {
-      ASSERT_TRUE(temporary_set.find(current) != temporary_set.end());
-      ++temporary_actual_size;
-    }
-    if (enumerator()->HasPersistent()) {
-      ASSERT_TRUE(persistent_set.find(current) != persistent_set.end());
-      ++persistent_actual_size;
-    }
-  }
-
-  ASSERT_EQ(temporary_size, temporary_actual_size);
-  ASSERT_EQ(persistent_size, persistent_actual_size);
-}