Cleanup: Removing FileSystemPathManager

chrome/browser/extensions/extension_file_browser_private_api.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 "chrome/browser/extensions/extension_file_browser_private_api.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 28 matching lines @@
 #include "content/public/browser/render_process_host.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "grit/platform_locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_operation_context.h"
-#include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using content::BrowserThread;
 using content::WebContents;
 
 namespace {
 
 // Error messages.
 const char kFileError[] = "File error %d";
@@ skipping 315 matching lines @@
       return false;
 
     // Make sure that only component extension can access the entire
     // local file system.
     if (extension_->location() != Extension::COMPONENT) {
       NOTREACHED() << "Private method access by non-component extension "
                    << extension_->id();
       return false;
     }
 
-    fileapi::FileSystemPathManager* path_manager =
-        profile_->GetFileSystemContext()->path_manager();
     fileapi::ExternalFileSystemMountPointProvider* provider =
-        path_manager->external_provider();
+        profile_->GetFileSystemContext()->external_provider();
     if (!provider)
       return false;
 
     // Grant full access to File API from this component extension.
     provider->GrantFullAccessToExtension(extension_->id());
 
     // Grant R/W file permissions to the renderer hosting component
     // extension for all paths exposed by our local file system provider.
     std::vector<FilePath> root_dirs = provider->GetRootDirectories();
     for (std::vector<FilePath>::iterator iter = root_dirs.begin();
@@ skipping 58 matching lines @@
 
 void RequestLocalFileSystemFunction::RespondFailedOnUIThread(
     base::PlatformFileError error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   error_ = base::StringPrintf(kFileError, static_cast<int>(error_code));
   SendResponse(false);
 }
 
 bool FileWatchBrowserFunctionBase::GetLocalFilePath(
     const GURL& file_url, FilePath* local_path, FilePath* virtual_path) {
-  fileapi::FileSystemPathManager* path_manager =
-      profile_->GetFileSystemContext()->path_manager();
   GURL file_origin_url;
   fileapi::FileSystemType type;
   if (!CrackFileSystemURL(file_url, &file_origin_url, &type,
                           virtual_path)) {
     return false;
   }
   if (type != fileapi::kFileSystemTypeExternal)
     return false;
 
-  FilePath root_path =
-      path_manager->ValidateFileSystemRootAndGetPathOnFileThread(
+  FilePath root_path = profile_->GetFileSystemContext()->external_provider()->
+      ValidateFileSystemRootAndGetPathOnFileThread(
           file_origin_url,
           fileapi::kFileSystemTypeExternal,
           *virtual_path,
           false);
   if (root_path == FilePath())
     return false;
 
   *local_path = root_path.Append(*virtual_path);
   return true;
 }
@@ skipping 247 matching lines @@
     FilePath virtual_path;
     fileapi::FileSystemType type;
     if (!CrackFileSystemURL(origin_file_url, &file_origin_url, &type,
                             &virtual_path)) {
       return false;
     }
 
     if (type != fileapi::kFileSystemTypeExternal)
       return false;
 
-    fileapi::FileSystemPathManager* path_manager =
-        profile_->GetFileSystemContext()->path_manager();
-    if (!path_manager->IsAccessAllowed(file_origin_url,
-                                       type,
-                                       virtual_path)) {
+    fileapi::ExternalFileSystemMountPointProvider* external_provider =
+        profile_->GetFileSystemContext()->external_provider();
+    if (!external_provider)
+      return false;
+
+    if (!external_provider->IsAccessAllowed(file_origin_url,
+                                            type,
+                                            virtual_path)) {
       return false;
     }
 
     // Make sure this url really being used by the right caller extension.
     if (source_url_.GetOrigin() != file_origin_url) {
       DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
       return false;
     }
 
     FilePath root_path =
-        path_manager->ValidateFileSystemRootAndGetPathOnFileThread(
+        external_provider->ValidateFileSystemRootAndGetPathOnFileThread(
           file_origin_url,
           fileapi::kFileSystemTypeExternal,
           virtual_path,
           false);     // create
     FilePath final_file_path = root_path.Append(virtual_path);
 
-    fileapi::ExternalFileSystemMountPointProvider* external_provider =
-        path_manager->external_provider();
-    if (!external_provider)
-      return false;
-
     // Check if this file system entry exists first.
     base::PlatformFileInfo file_info;
 
     if (!file_util::PathExists(final_file_path) ||
         file_util::IsLink(final_file_path) ||
         !file_util::GetFileInfo(final_file_path, &file_info))
       return false;
 
     // TODO(zelidrag): Let's just prevent all symlinks for now. We don't want a
     // USB drive content to point to something in the rest of the file system.
@@ skipping 220 matching lines @@
 // them to local paths and calls |callback| with the result vector, on the UI
 // thread.
 void FileBrowserFunction::GetLocalPathsOnFileThread(
     const UrlList& file_urls,
     GetLocalPathsCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   FilePathList selected_files;
 
   // FilePath(virtual_path) doesn't work on win, so limit this to ChromeOS.
 #if defined(OS_CHROMEOS)
+  fileapi::ExternalFileSystemMountPointProvider* provider =
+      profile_->GetFileSystemContext()->external_provider();
+  if (!provider) {
+    LOG(WARNING) << "External provider is not available";
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(callback, selected_files));
+    return;
+  }
+
   GURL origin_url = source_url().GetOrigin();
-  fileapi::FileSystemPathManager* path_manager =
-      profile()->GetFileSystemContext()->path_manager();
-
   size_t len = file_urls.size();
   selected_files.reserve(len);
   for (size_t i = 0; i < len; ++i) {
     const GURL& file_url = file_urls[i];
     GURL file_origin_url;
     FilePath virtual_path;
     fileapi::FileSystemType type;
     if (!CrackFileSystemURL(file_url, &file_origin_url, &type,
                             &virtual_path)) {
       continue;
     }
     if (type != fileapi::kFileSystemTypeExternal) {
       NOTREACHED();
       continue;
     }
-    FilePath root = path_manager->ValidateFileSystemRootAndGetPathOnFileThread(
+    FilePath root = provider->ValidateFileSystemRootAndGetPathOnFileThread(
         origin_url,
         fileapi::kFileSystemTypeExternal,
         FilePath(virtual_path),
         false);
     if (!root.empty()) {
       selected_files.push_back(root.Append(virtual_path));
     } else {
       LOG(WARNING) << "GetLocalPathsOnFileThread failed "
                    << file_url.spec();
     }
@@ skipping 629 matching lines @@
   SET_STRING(IDS_FILE_BROWSER, ENQUEUE);
 #undef SET_STRING
 
   ChromeURLDataManager::DataSource::SetFontAndTextDirection(dict);
 
   dict->SetString("PLAY_MEDIA",
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_PLAY));
 
   return true;
 }