Fixed file/directory url resolution for external mount point provider.

webkit/fileapi/file_system_path_manager_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 "webkit/fileapi/file_system_path_manager.h"
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 41 matching lines @@
   { fileapi::kFileSystemTypePersistent, "http://bar.com/",
     "http_bar.com_0" PS "Persistent" },
   { fileapi::kFileSystemTypeTemporary, "https://foo:2/",
     "https_foo_2" PS "Temporary" },
   { fileapi::kFileSystemTypePersistent, "https://foo:2/",
     "https_foo_2" PS "Persistent" },
   { fileapi::kFileSystemTypeTemporary, "https://bar.com/",
     "https_bar.com_0" PS "Temporary" },
   { fileapi::kFileSystemTypePersistent, "https://bar.com/",
     "https_bar.com_0" PS "Persistent" },
+#if defined(OS_CHROMEOS)
+    { fileapi::kFileSystemTypeExternal, "chrome-extension://foo/",

[ericu, 2011/04/18 20:35:56]

Fix indent.

+      "chrome-extension__0" PS "External" },
+#endif
 };
 
 const struct RootPathFileURITest {
   fileapi::FileSystemType type;
   const char* origin_url;
   const char* expected_path;
+  const char* virtual_path;
 } kRootPathFileURITestCases[] = {
   { fileapi::kFileSystemTypeTemporary, "file:///",
-    "file__0" PS "Temporary" },
+    "file__0" PS "Temporary", NULL },
   { fileapi::kFileSystemTypePersistent, "file:///",
-    "file__0" PS "Persistent" },
-    // TODO(zelidrag): Add fileapi::kFileSystemTypeLocal test cases here once
-    // we fix ChromeOS build of this test.
+    "file__0" PS "Persistent", NULL },
+#if defined(OS_CHROMEOS)
+  { fileapi::kFileSystemTypeExternal, "chrome-extension://foo/",
+    "chrome-extension__0" PS "External", "tmp/test.txt" },
+#endif
 };
 
 const struct CheckValidPathTest {
   FilePath::StringType path;
   bool expected_valid;
 } kCheckValidPathTestCases[] = {
   { FILE_PATH_LITERAL("//tmp/foo.txt"), false, },
   { FILE_PATH_LITERAL("//etc/hosts"), false, },
   { FILE_PATH_LITERAL("foo.txt"), true, },
   { FILE_PATH_LITERAL("a/b/c"), true, },
@@ skipping 105 matching lines @@
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     root_path_callback_status_ = false;
     root_path_.clear();
     file_system_name_.clear();
   }
 
  protected:
   FileSystemPathManager* NewPathManager(
       bool incognito,
       bool allow_file_access) {
-    return new FileSystemPathManager(
+    FileSystemPathManager* manager = new FileSystemPathManager(
         base::MessageLoopProxy::CreateForCurrentThread(),
         data_dir_.path(),
         scoped_refptr<quota::SpecialStoragePolicy>(
             new TestSpecialStoragePolicy()),
         incognito,
         allow_file_access);
+#if defined(OS_CHROMEOS)
+    fileapi::ExternalFileSystemMountPointProvider* ext_provider =
+        manager->external_provider();
+    ext_provider->AddMountPoint(FilePath("/tmp"));
+#endif
+    return manager;
   }
 
   void OnGetRootPath(bool success,
-                           const FilePath& root_path,
-                           const std::string& name) {
+                     const FilePath& root_path,
+                     const std::string& name) {
     root_path_callback_status_ = success;
     root_path_ = root_path;
     file_system_name_ = name;
   }
 
   bool GetRootPath(FileSystemPathManager* manager,
                    const GURL& origin_url,
                    fileapi::FileSystemType type,
                    bool create,
+                   bool is_file_system,
+                   const FilePath& virtual_path,
                    FilePath* root_path) {
-    manager->GetFileSystemRootPath(origin_url, type, create,
-        callback_factory_.NewCallback(
+    manager->GetFileSystemRootPath(origin_url, type, create, is_file_system,
+        virtual_path, callback_factory_.NewCallback(
             &FileSystemPathManagerTest::OnGetRootPath));
     MessageLoop::current()->RunAllPending();
     if (root_path)
       *root_path = root_path_;
     return root_path_callback_status_;
   }
 
   FilePath data_path() { return data_dir_.path(); }
   FilePath file_system_path() {
     return data_dir_.path().Append(
         SandboxMountPointProvider::kFileSystemDirectory);
   }
+  FilePath external_file_system_path() {
+    return FilePath(fileapi::kExternalDir);
+  }
 
  private:
   ScopedTempDir data_dir_;
   base::ScopedCallbackFactory<FileSystemPathManagerTest> callback_factory_;
 
   bool root_path_callback_status_;
   FilePath root_path_;
   std::string file_system_name_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemPathManagerTest);
 };
 
 TEST_F(FileSystemPathManagerTest, GetRootPathCreateAndExamine) {
   std::vector<FilePath> returned_root_path(
       ARRAYSIZE_UNSAFE(kRootPathTestCases));
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
 
   // Create a new root directory.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (create) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
 
     FilePath root_path;
     EXPECT_TRUE(GetRootPath(manager.get(),
                             GURL(kRootPathTestCases[i].origin_url),
                             kRootPathTestCases[i].type,
-                            true /* create */, &root_path));
+                            true /* create */, true /* is_file_system */,
+                            FilePath(),
+                            &root_path));
 
-    FilePath expected = file_system_path().AppendASCII(
-        kRootPathTestCases[i].expected_path);
-    EXPECT_EQ(expected.value(), root_path.DirName().value());
-    EXPECT_TRUE(file_util::DirectoryExists(root_path));
+    if (kRootPathTestCases[i].type != fileapi::kFileSystemTypeExternal) {
+      FilePath expected = file_system_path().AppendASCII(
+          kRootPathTestCases[i].expected_path);
+      EXPECT_EQ(expected.value(), root_path.DirName().value());
+      EXPECT_TRUE(file_util::DirectoryExists(root_path));
+    } else {
+      // External file system root path is virtual one and does not match
+      // anything from the actual file system.
+      EXPECT_EQ(external_file_system_path().value(),
+                root_path.value());
+    }
     ASSERT_TRUE(returned_root_path.size() > i);
     returned_root_path[i] = root_path;
   }
 
   // Get the root directory with create=false and see if we get the
   // same directory.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (get) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
 
     FilePath root_path;
     EXPECT_TRUE(GetRootPath(manager.get(),
                             GURL(kRootPathTestCases[i].origin_url),
                             kRootPathTestCases[i].type,
-                            false /* create */, &root_path));
+                            false /* create */, true /* is_file_system */,
+                            FilePath(), &root_path));
     ASSERT_TRUE(returned_root_path.size() > i);
     EXPECT_EQ(returned_root_path[i].value(), root_path.value());
   }
 }
 
 TEST_F(FileSystemPathManagerTest, GetRootPathCreateAndExamineWithNewManager) {
   std::vector<FilePath> returned_root_path(
       ARRAYSIZE_UNSAFE(kRootPathTestCases));
   scoped_ptr<FileSystemPathManager> manager1(NewPathManager(false, false));
   scoped_ptr<FileSystemPathManager> manager2(NewPathManager(false, false));
 
   GURL origin_url("http://foo.com:1/");
 
   FilePath root_path1;
   EXPECT_TRUE(GetRootPath(manager1.get(), origin_url,
-                          kFileSystemTypeTemporary, true, &root_path1));
+                          kFileSystemTypeTemporary, true, false, FilePath(),
+                          &root_path1));
   FilePath root_path2;
   EXPECT_TRUE(GetRootPath(manager2.get(), origin_url,
-                          kFileSystemTypeTemporary, false, &root_path2));
+                          kFileSystemTypeTemporary, false, false, FilePath(),
+                          &root_path2));
 
   EXPECT_EQ(root_path1.value(), root_path2.value());
 }
 
 TEST_F(FileSystemPathManagerTest, GetRootPathGetWithoutCreate) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
 
   // Try to get a root directory without creating.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (create=false) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
     EXPECT_FALSE(GetRootPath(manager.get(),
                              GURL(kRootPathTestCases[i].origin_url),
                              kRootPathTestCases[i].type,
-                             false /* create */, NULL));
+                             false /* create */, false /* is_file_system */,
+                             FilePath(), NULL));
   }
 }
 
 TEST_F(FileSystemPathManagerTest, GetRootPathInIncognito) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(
       true /* incognito */, false));
 
   // Try to get a root directory.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (incognito) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
     EXPECT_FALSE(GetRootPath(manager.get(),
                              GURL(kRootPathTestCases[i].origin_url),
                              kRootPathTestCases[i].type,
-                             true /* create */, NULL));
+                             true /* create */, false /* is_file_system */,
+                             FilePath(), NULL));
   }
 }
 
 TEST_F(FileSystemPathManagerTest, GetRootPathFileURI) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(false, false));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathFileURITestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPathFileURI (disallow) #"
                  << i << " " << kRootPathFileURITestCases[i].expected_path);
     EXPECT_FALSE(GetRootPath(manager.get(),
                              GURL(kRootPathFileURITestCases[i].origin_url),
                              kRootPathFileURITestCases[i].type,
-                             true /* create */, NULL));
+                             true /* create */, false /* is_file_system */,
+                             FilePath(), NULL));
   }
 }
 
 TEST_F(FileSystemPathManagerTest, GetRootPathFileURIWithAllowFlag) {
   scoped_ptr<FileSystemPathManager> manager(NewPathManager(
       false, true /* allow_file_access_from_files */));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathFileURITestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPathFileURI (allow) #"
                  << i << " " << kRootPathFileURITestCases[i].expected_path);
     FilePath root_path;
     EXPECT_TRUE(GetRootPath(manager.get(),
                             GURL(kRootPathFileURITestCases[i].origin_url),
                             kRootPathFileURITestCases[i].type,
-                            true /* create */, &root_path));
-    FilePath expected = file_system_path().AppendASCII(
-        kRootPathFileURITestCases[i].expected_path);
-    EXPECT_EQ(expected.value(), root_path.DirName().value());
+                            true /* create */, false /* is_file_system */,
+                            FilePath(kRootPathFileURITestCases[i].virtual_path),
+                            &root_path));
+    if (kRootPathFileURITestCases[i].type != fileapi::kFileSystemTypeExternal) {
+      FilePath expected = file_system_path().AppendASCII(
+          kRootPathFileURITestCases[i].expected_path);
+      EXPECT_EQ(expected.value(), root_path.DirName().value());
+    } else {
+      FilePath expected = external_file_system_path();
+      EXPECT_EQ(expected.value(), root_path.value());
+    }
     EXPECT_TRUE(file_util::DirectoryExists(root_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,
               manager->IsRestrictedFileName(kFileSystemTypeTemporary, name));
   }
 }