Cleanup: Removing FileSystemPathManager

webkit/fileapi/file_system_operation.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_operation.h"
 
 #include "base/bind.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util_proxy.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_quota_util.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/file_writer_delegate.h"
 #include "webkit/fileapi/local_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/quota/quota_types.h"
 
 namespace fileapi {
 
@@ skipping 67 matching lines @@
 
   DCHECK(file_system_context());
   operation_context_.set_src_origin_url(origin_url);
   operation_context_.set_src_type(type);
   // TODO(ericu): We don't really need to make this call if !create.
   // Also, in the future we won't need it either way, as long as we do all
   // permission+quota checks beforehand.  We only need it now because we have to
   // create an unpredictable directory name.  Without that, we could lazily
   // create the root later on the first filesystem write operation, and just
   // return GetFileSystemRootURI() here.
-  file_system_context()->path_manager()->ValidateFileSystemRootAndGetURL(
+  FileSystemMountPointProvider* mount_point_provider =
+      file_system_context()->GetMountPointProvider(type);
+  if (!mount_point_provider) {
+    DidGetRootPath(false, FilePath(), std::string());
+    delete this;
+    return;
+  }
+  mount_point_provider->ValidateFileSystemRootAndGetURL(
       origin_url, type, create,
       base::Bind(&FileSystemOperation::DidGetRootPath,
                  base::Owned(this)));
 }
 
 void FileSystemOperation::CreateFile(const GURL& path,
                                      bool exclusive) {
 #ifndef NDEBUG
   DCHECK(kOperationNone == pending_operation_);
   pending_operation_ = kOperationCreateFile;
@@ skipping 654 matching lines @@
     FilePath* virtual_path, FileSystemFileUtil** file_util) {
   if (!VerifyFileSystemPath(path, origin_url, type, virtual_path, file_util))
     return false;
 
   // Any write access is disallowed on the root path.
   if (virtual_path->value().length() == 0 ||
       virtual_path->DirName().value() == virtual_path->value()) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
-  if (create && file_system_context()->path_manager()->IsRestrictedFileName(
-          *type, virtual_path->BaseName())) {
+  if (create &&
+      file_system_context()->GetMountPointProvider(*type)->IsRestrictedFileName(
+          virtual_path->BaseName())) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
 
   return true;
 }
 
 bool FileSystemOperation::VerifyFileSystemPath(
     const GURL& path, GURL* origin_url, FileSystemType* type,
     FilePath* virtual_path, FileSystemFileUtil** file_util) {
   DCHECK(file_system_context());
 
   if (!CrackFileSystemURL(path, origin_url, type, virtual_path)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_INVALID_URL);
     return false;
   }
-  if (!file_system_context()->path_manager()->IsAccessAllowed(
+  if (!file_system_context()->GetMountPointProvider(*type)->IsAccessAllowed(
       *origin_url, *type, *virtual_path)) {
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
   DCHECK(file_util);
-  *file_util = file_system_context()->path_manager()->GetFileUtil(*type);
+  *file_util = file_system_context()->GetFileUtil(*type);
   DCHECK(*file_util);
 
   return true;
 }
 
 bool FileSystemOperation::SetupSrcContextForRead(const GURL& path) {
   GURL origin_url;
   FileSystemType type;
   FileSystemFileUtil* file_util;
   bool result = VerifyFileSystemPathForRead(
@@ skipping 27 matching lines @@
   bool result = VerifyFileSystemPathForWrite(
       path, create, &origin_url, &type, &dest_virtual_path_, &file_util);
   operation_context_.set_dest_origin_url(origin_url);
   operation_context_.set_dest_type(type);
   if (!operation_context_.dest_file_util())
     operation_context_.set_dest_file_util(file_util);
   return result;
 }
 
 }  // namespace fileapi