Cleanup: Removing FileSystemPathManager

webkit/fileapi/file_system_quota_client_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 "base/bind.h"
 #include "base/basictypes.h"
 #include "base/file_util.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_operation_context.h"
 #include "webkit/fileapi/file_system_quota_client.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/fileapi/obfuscated_file_util.h"
+#include "webkit/fileapi/quota_file_util.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
-#include "webkit/fileapi/quota_file_util.h"
 #include "webkit/quota/quota_types.h"
 
 namespace fileapi {
 namespace {
 
 const char kDummyURL1[] = "http://www.dummy.org";
 const char kDummyURL2[] = "http://www.example.com";
 const char kDummyURL3[] = "http://www.bleh";
 
 // Declared to shorten the variable names.
 const quota::StorageType kTemporary = quota::kStorageTypeTemporary;
 const quota::StorageType kPersistent = quota::kStorageTypePersistent;
 
-class MockFileSystemPathManager : public FileSystemPathManager {
- public:
-  explicit MockFileSystemPathManager(const FilePath& filesystem_path)
-      : FileSystemPathManager(base::MessageLoopProxy::current(),
-                              filesystem_path, NULL, false, true) {}
-};
-
 }  // namespace
 
 class FileSystemQuotaClientTest : public testing::Test {
  public:
   FileSystemQuotaClientTest()
       : weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         additional_callback_count_(0),
         deletion_status_(quota::kQuotaStatusUnknown) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     file_system_context_ =
         new FileSystemContext(
             base::MessageLoopProxy::current(),
             base::MessageLoopProxy::current(),
             NULL, NULL,
-            FilePath(), false /* is_incognito */, true /* allow_file_access */,
-            new MockFileSystemPathManager(data_dir_.path()));
+            data_dir_.path(),
+            CreateDisallowFileAccessOptions());
   }
 
   struct TestFile {
     bool isDirectory;
     const char* name;
     int64 size;
     const char* origin_url;
     quota::StorageType type;
   };
 
@@ skipping 50 matching lines @@
     quota_client->GetOriginUsage(
         GURL(origin_url), type,
         base::Bind(&FileSystemQuotaClientTest::OnGetAdditionalUsage,
                    weak_factory_.GetWeakPtr()));
   }
 
   FilePath GetOriginBasePath(const std::string& origin_url,
                              quota::StorageType type) {
     // Note: this test assumes sandbox_provider impl is used for
     // temporary and persistent filesystem.
-    return file_system_context_->path_manager()->sandbox_provider()->
+    return file_system_context_->sandbox_provider()->
         GetBaseDirectoryForOriginAndType(
             GURL(origin_url), QuotaStorageTypeToFileSystemType(type), true);
   }
 
   FileSystemOperationContext* CreateFileSystemOperationContext(
       FileSystemFileUtil* file_util,
       const FilePath& virtual_path,
       const std::string& origin_url,
       quota::StorageType type) {
     FileSystemOperationContext* context =
         new FileSystemOperationContext(file_system_context_, file_util);
     context->set_src_origin_url(GURL(origin_url));
     context->set_src_type(QuotaStorageTypeToFileSystemType(type));
     context->set_allowed_bytes_growth(100000000);
     return context;
   }
 
   bool CreateFileSystemDirectory(const FilePath& path,
                                  const std::string& origin_url,
                                  quota::StorageType type) {
-    FileSystemFileUtil* file_util = file_system_context_->path_manager()->
+    FileSystemFileUtil* file_util = file_system_context_->
         GetFileUtil(QuotaStorageTypeToFileSystemType(type));
 
     scoped_ptr<FileSystemOperationContext> context(
         CreateFileSystemOperationContext(file_util, path, origin_url, type));
 
     base::PlatformFileError result =
         file_util->CreateDirectory(context.get(), path, false, false);
     if (result != base::PLATFORM_FILE_OK)
       return false;
     return true;
   }
 
   bool CreateFileSystemFile(const FilePath& path,
                             int64 file_size,
                             const std::string& origin_url,
                             quota::StorageType type) {
     if (path.empty())
       return false;
 
-    FileSystemFileUtil* file_util = file_system_context_->path_manager()->
+    FileSystemFileUtil* file_util = file_system_context_->
         sandbox_provider()->GetFileUtil();
 
     scoped_ptr<FileSystemOperationContext> context(
         CreateFileSystemOperationContext(file_util, path, origin_url, type));
 
     bool created = false;
     if (base::PLATFORM_FILE_OK !=
         file_util->EnsureFileExists(context.get(), path, &created))
       return false;
     EXPECT_TRUE(created);
@@ skipping 414 matching lines @@
             GetOriginUsage(quota_client.get(),
                            "https://bar.com/",
                            kPersistent));
   EXPECT_EQ(64 + file_paths_cost_temporary_bar_https,
             GetOriginUsage(quota_client.get(),
                            "https://bar.com/",
                            kTemporary));
 }
 
 }  // namespace fileapi