Make MountPointProvider pluggable from outside webkit/fileapi

webkit/fileapi/file_system_context_unittest.cc

 // Copyright (c) 2013 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_context.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/external_mount_points.h"
+#include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/quota/mock_quota_manager.h"
 #include "webkit/quota/mock_special_storage_policy.h"
 
 #define FPL(x) FILE_PATH_LITERAL(x)
 
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
 #define DRIVE FPL("C:")
@@ skipping 17 matching lines @@
   return GURL(url_str);
 }
 
 class FileSystemContextTest : public testing::Test {
  public:
   FileSystemContextTest() {}
 
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
 
-    storage_policy_ = new quota::MockSpecialStoragePolicy();
-
     mock_quota_manager_ = new quota::MockQuotaManager(
         false /* is_incognito */,
         data_dir_.path(),
         base::MessageLoopProxy::current(),
         base::MessageLoopProxy::current(),
-        storage_policy_);
+        new quota::MockSpecialStoragePolicy());
   }
 
  protected:
   FileSystemContext* CreateFileSystemContextForTest(
       ExternalMountPoints* external_mount_points) {
+    std::vector<MountPoints*> additional_mount_points;
+    if (external_mount_points)
+      additional_mount_points.push_back(external_mount_points);
     return new FileSystemContext(
         FileSystemTaskRunners::CreateMockTaskRunners(),
-        external_mount_points,
-        storage_policy_,
         mock_quota_manager_->proxy(),
+        ScopedVector<FileSystemMountPointProvider>(),
+        additional_mount_points,
         data_dir_.path(),
         CreateAllowFileAccessOptions());
   }
 
   // Verifies a *valid* filesystem url has expected values.
   void ExpectFileSystemURLMatches(const FileSystemURL& url,
                                   const GURL& expect_origin,
                                   FileSystemType expect_mount_type,
                                   FileSystemType expect_type,
                                   const base::FilePath& expect_path,
                                   const base::FilePath& expect_virtual_path,
                                   const std::string& expect_filesystem_id) {
     EXPECT_TRUE(url.is_valid());
 
     EXPECT_EQ(expect_origin, url.origin());
     EXPECT_EQ(expect_mount_type, url.mount_type());
     EXPECT_EQ(expect_type, url.type());
     EXPECT_EQ(expect_path, url.path());
     EXPECT_EQ(expect_virtual_path, url.virtual_path());
     EXPECT_EQ(expect_filesystem_id, url.filesystem_id());
   }
 
  private:
   base::ScopedTempDir data_dir_;
   MessageLoop message_loop_;
-  scoped_refptr<quota::SpecialStoragePolicy> storage_policy_;
   scoped_refptr<quota::MockQuotaManager> mock_quota_manager_;
 };
 
-// It is not valid to pass NULL ExternalMountPoints to FileSystemContext on
-// ChromeOS.
-#if !defined(OS_CHROMEOS)
 TEST_F(FileSystemContextTest, NullExternalMountPoints) {
   scoped_refptr<FileSystemContext> file_system_context(
       CreateFileSystemContextForTest(NULL));
 
   // Cracking system external mount and isolated mount points should work.
   std::string isolated_name = "root";
   std::string isolated_id =
       IsolatedContext::GetInstance()->RegisterFileSystemForPath(
           kFileSystemTypeNativeLocal,
           base::FilePath(DRIVE FPL("/test/isolated/root")),
           &isolated_name);
   // Register system external mount point.
   ASSERT_TRUE(ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
       "system",
       kFileSystemTypeNativeLocal,
       base::FilePath(DRIVE FPL("/test/sys/"))));
 
   FileSystemURL cracked_isolated = file_system_context->CrackURL(
       CreateRawFileSystemURL("isolated", isolated_id));
 
   ExpectFileSystemURLMatches(
       cracked_isolated,
       GURL(kTestOrigin),
       kFileSystemTypeIsolated,
       kFileSystemTypeNativeLocal,
-      base::FilePath(DRIVE FPL("/test/isolated/root/file")).NormalizePathSeparators(),
+      base::FilePath(
+          DRIVE FPL("/test/isolated/root/file")).NormalizePathSeparators(),
       base::FilePath::FromUTF8Unsafe(isolated_id).Append(FPL("root/file")).
           NormalizePathSeparators(),
       isolated_id);
 
   FileSystemURL cracked_external = file_system_context->CrackURL(
       CreateRawFileSystemURL("external", "system"));
 
   ExpectFileSystemURLMatches(
       cracked_external,
       GURL(kTestOrigin),
       kFileSystemTypeExternal,
       kFileSystemTypeNativeLocal,
-      base::FilePath(DRIVE FPL("/test/sys/root/file")).NormalizePathSeparators(),
+      base::FilePath(
+          DRIVE FPL("/test/sys/root/file")).NormalizePathSeparators(),
       base::FilePath(FPL("system/root/file")).NormalizePathSeparators(),
       "system");
 
 
   IsolatedContext::GetInstance()->RevokeFileSystem(isolated_id);
   ExternalMountPoints::GetSystemInstance()->RevokeFileSystem("system");
 }
-#endif  // !defiend(OS_CHROMEOS)
-
-TEST_F(FileSystemContextTest, FileSystemContextKeepsMountPointsAlive) {
-  scoped_refptr<ExternalMountPoints> mount_points =
-      ExternalMountPoints::CreateRefCounted();
-
-  // Register system external mount point.
-  ASSERT_TRUE(mount_points->RegisterFileSystem(
-      "system",
-      kFileSystemTypeNativeLocal,
-      base::FilePath(DRIVE FPL("/test/sys/"))));
-
-  scoped_refptr<FileSystemContext> file_system_context(
-      CreateFileSystemContextForTest(mount_points.get()));
-
-  // Release a MountPoints reference created in the test.
-  mount_points = NULL;
-
-  // FileSystemContext should keep a reference to the |mount_points|, so it
-  // should be able to resolve the URL.
-  FileSystemURL cracked_external = file_system_context->CrackURL(
-      CreateRawFileSystemURL("external", "system"));
-
-  ExpectFileSystemURLMatches(
-      cracked_external,
-      GURL(kTestOrigin),
-      kFileSystemTypeExternal,
-      kFileSystemTypeNativeLocal,
-      base::FilePath(DRIVE FPL("/test/sys/root/file")).NormalizePathSeparators(),
-      base::FilePath(FPL("system/root/file")).NormalizePathSeparators(),
-      "system");
-
-  // No need to revoke the registered filesystem since |mount_points| lifetime
-  // is bound to this test.
-}
 
 TEST_F(FileSystemContextTest, CrackFileSystemURL) {
   scoped_refptr<ExternalMountPoints> external_mount_points(
       ExternalMountPoints::CreateRefCounted());
   scoped_refptr<FileSystemContext> file_system_context(
       CreateFileSystemContextForTest(external_mount_points));
 
   // Register an isolated mount point.
   std::string isolated_file_system_name = "root";
   const std::string kIsolatedFileSystemID =
@@ skipping 126 matching lines @@
       base::FilePath(DRIVE FPL("/test/isolated/root")));
   ExternalMountPoints::GetSystemInstance()->RevokeFileSystem("system");
   ExternalMountPoints::GetSystemInstance()->RevokeFileSystem("ext");
   ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(
       kIsolatedFileSystemID);
 }
 
 }  // namespace
 
 }  // namespace fileapi