Cleanup: Removing FileSystemPathManager

webkit/fileapi/sandbox_mount_point_provider_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/sandbox_mount_point_provider.h"
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/scoped_temp_dir.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_context.h"
+#include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation_context.h"
-#include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/quota/mock_special_storage_policy.h"
 
 namespace fileapi {
 
-class MockFileSystemPathManager : public FileSystemPathManager {
- public:
-  explicit MockFileSystemPathManager(const FilePath& profile_path)
-      : FileSystemPathManager(base::MessageLoopProxy::current(),
-                              profile_path, NULL, false, true) {}
-};
-
 class SandboxMountPointProviderOriginEnumeratorTest : public testing::Test {
  public:
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
-    path_manager_.reset(new MockFileSystemPathManager(data_dir_.path()));
+    sandbox_provider_.reset(
+        new SandboxMountPointProvider(
+          base::MessageLoopProxy::current(),
+          data_dir_.path(),
+          CreateAllowFileAccessOptions()));
   }
 
   SandboxMountPointProvider::OriginEnumerator* CreateEnumerator() const {
-    return path_manager_->sandbox_provider()->CreateOriginEnumerator();
+    return sandbox_provider_->CreateOriginEnumerator();
   }
 
  protected:
   void CreateOriginTypeDirectory(const GURL& origin,
                                  fileapi::FileSystemType type) {
-    FilePath target = path_manager_->sandbox_provider()->
+    FilePath target = sandbox_provider_->
         GetBaseDirectoryForOriginAndType(origin, type, true);
     ASSERT_TRUE(!target.empty());
     ASSERT_TRUE(file_util::DirectoryExists(target));
   }
 
   ScopedTempDir data_dir_;
-  scoped_ptr<FileSystemPathManager> path_manager_;
+  scoped_ptr<SandboxMountPointProvider> sandbox_provider_;
 };
 
 TEST_F(SandboxMountPointProviderOriginEnumeratorTest, Empty) {
   scoped_ptr<SandboxMountPointProvider::OriginEnumerator> enumerator(
       CreateEnumerator());
   ASSERT_TRUE(enumerator->Next().is_empty());
 }
 
 TEST_F(SandboxMountPointProviderOriginEnumeratorTest, EnumerateOrigins) {
   const char* temporary_origins[] = {
@@ skipping 63 matching lines @@
 }  // anonymous namespace
 
 class SandboxMountPointProviderMigrationTest : public testing::Test {
  public:
   SandboxMountPointProviderMigrationTest() :
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
-    path_manager_ = new MockFileSystemPathManager(data_dir_.path());
-
     scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
         new quota::MockSpecialStoragePolicy;
     special_storage_policy->SetAllUnlimited(true);
     file_system_context_ = new FileSystemContext(
         base::MessageLoopProxy::current(),
         base::MessageLoopProxy::current(),
         special_storage_policy,
         NULL,
         data_dir_.path(),
-        false,  // incognito
-        true,  // allow_file_access_from_files
-        path_manager_);
-  }
-
-  FileSystemPathManager* path_manager() {
-    return path_manager_;
+        CreateAllowFileAccessOptions());
   }
 
   SandboxMountPointProvider* sandbox_provider() {
-    return path_manager()->sandbox_provider();
+    return file_system_context_->sandbox_provider();
   }
 
   FileSystemFileUtil* file_util() {
     return sandbox_provider()->GetFileUtil();
   }
 
   void OnGetRootPath(bool success, const FilePath& unused,
                      const std::string& unused_also) {
     EXPECT_FALSE(success);  // We told it not to create.
   }
 
-  FileSystemPathManager::GetRootPathCallback GetRootPathCallback() {
+  FileSystemMountPointProvider::GetRootPathCallback GetRootPathCallback() {
     return base::Bind(&SandboxMountPointProviderMigrationTest::OnGetRootPath,
                       weak_factory_.GetWeakPtr());
   }
 
   void EnsureFileExists(const FilePath& path) {
     bool created = false;
     PlatformFileError error_code = base::PLATFORM_FILE_OK;
     PlatformFile handle = base::CreatePlatformFile(
         path,
         base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ,
@@ skipping 25 matching lines @@
     FileSystemOperationContext* context = new FileSystemOperationContext(
       file_system_context_, file_util());
     context->set_src_origin_url(origin_url);
     context->set_src_type(type);
     return context;
   }
 
   std::string URLAndTypeToSeedString(const GURL& origin_url,
     fileapi::FileSystemType type) {
     return GetOriginIdentifierFromURL(origin_url) +
-        FileSystemPathManager::GetFileSystemTypeString(type);
+        GetFileSystemTypeString(type);
   }
 
   void ValidateDataInNewFileSystem(
       const GURL& origin_url, fileapi::FileSystemType type) {
 
     scoped_ptr<FileSystemOperationContext> context;
     FilePath seed = FilePath().AppendASCII(
         URLAndTypeToSeedString(origin_url, type));
 
     context.reset(NewContext(origin_url, type));
@@ skipping 118 matching lines @@
       ASSERT_TRUE(test_case.has_temporary || test_case.has_persistent);
       if (test_case.has_temporary)
         ValidateDataInNewFileSystem(origin_url, kFileSystemTypeTemporary);
       if (test_case.has_persistent)
         ValidateDataInNewFileSystem(origin_url, kFileSystemTypePersistent);
     }
   }
 
  protected:
   ScopedTempDir data_dir_;
-  FileSystemPathManager* path_manager_;
   scoped_refptr<FileSystemContext> file_system_context_;
   base::WeakPtrFactory<SandboxMountPointProviderMigrationTest> weak_factory_;
 };
 
 TEST_F(SandboxMountPointProviderMigrationTest, TestMigrateViaMethod0) {
   RunMigrationTest(0);
 }
 
 TEST_F(SandboxMountPointProviderMigrationTest, TestMigrateViaMethod1) {
   RunMigrationTest(1);
@@ skipping 25 matching lines @@
 
 TEST_F(SandboxMountPointProviderMigrationTest, TestMigrateViaMethod8) {
   RunMigrationTest(8);
 }
 
 TEST_F(SandboxMountPointProviderMigrationTest, TestMigrateViaMethod9) {
   RunMigrationTest(9);
 }
 
 }  // namespace fileapi