Integrate external mount points to IsolatedContext

chrome/browser/chromeos/extensions/file_browser_private_api.cc

 // Copyright (c) 2012 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/chromeos/extensions/file_browser_private_api.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 34 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "grit/platform_locale_settings.h"
 #include "net/base/escape.h"
 #include "ui/base/dialogs/selected_file_info.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "webkit/chromeos/fileapi/cros_mount_point_provider.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_context.h"
 #include "webkit/fileapi/file_system_types.h"
+#include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using chromeos::disks::DiskMountManager;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 using file_handler_util::FileTaskExecutor;
@@ skipping 151 matching lines @@
           gdata::GDataCache::CACHE_TYPE_PERSISTENT),
       file_handler_util::GetReadOnlyPermissions());
 
   FilePath mount_point_virtual;
   if (provider->GetVirtualPath(mount_point, &mount_point_virtual))
     provider->GrantFileAccessToExtension(extension_id, mount_point_virtual);
 }
 
 // Given a file url, find the virtual FilePath associated with it.
 FilePath GetVirtualPathFromURL(const GURL& file_url) {
-  FilePath virtual_path;
-  fileapi::FileSystemType type = fileapi::kFileSystemTypeUnknown;
-  GURL file_origin_url;
-  if (!CrackFileSystemURL(file_url, &file_origin_url, &type, &virtual_path) ||
-      type != fileapi::kFileSystemTypeExternal) {
+  fileapi::FileSystemURL url(file_url);
+  if (!chromeos::CrosMountPointProvider::CanHandleURL(url)) {
     NOTREACHED();
     return FilePath();
   }
-  return virtual_path;
+  return url.virtual_path();
 }
 
 // Look up apps in the registry, and collect applications that match the file
 // paths given. Returns the intersection of all available application ids in
 // |available_apps| and a map of application ID to the Drive web application
 // info collected in |app_info| so details can be collected later. The caller
 // takes ownership of the pointers in |app_info|.
 void IntersectAvailableDriveTasks(
     gdata::DriveWebAppsRegistry* registry,
     const std::vector<FilePath>& file_paths,
@@ skipping 172 matching lines @@
         file_system_context_->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();
-         iter != root_dirs.end();
-         ++iter) {
+    for (size_t i = 0; i < root_dirs.size(); ++i) {
       ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
-          child_id_, *iter, file_handler_util::GetReadWritePermissions());
+          child_id_, root_dirs[i],
+          file_handler_util::GetReadWritePermissions());
     }
     return true;
   }
 
   RequestLocalFileSystemFunction* function_;
   scoped_refptr<fileapi::FileSystemContext> file_system_context_;
   // Renderer process id.
   int child_id_;
   // Extension source URL.
   scoped_refptr<const Extension> extension_;
@@ skipping 49 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(
-    scoped_refptr<fileapi::FileSystemContext> file_system_context,
     const GURL& file_url, FilePath* local_path, FilePath* virtual_path) {
-  GURL file_origin_url;
-  fileapi::FileSystemType type;
-  if (!CrackFileSystemURL(file_url, &file_origin_url, &type,
-                          virtual_path)) {
+  fileapi::FileSystemURL url(file_url);
+  if (!chromeos::CrosMountPointProvider::CanHandleURL(url))
     return false;
-  }
-  if (type != fileapi::kFileSystemTypeExternal)
-    return false;
-
-  FilePath root_path = file_system_context->
-      external_provider()->GetFileSystemRootPathOnFileThread(
-          file_origin_url,
-          fileapi::kFileSystemTypeExternal,
-          *virtual_path,
-          false);
-  if (root_path == FilePath())
-    return false;
-
-  *local_path = root_path.Append(*virtual_path);
+  *local_path = url.path();
+  *virtual_path = url.virtual_path();
   return true;
 }
 
 void FileWatchBrowserFunctionBase::RespondOnUIThread(bool success) {
   SetResult(Value::CreateBooleanValue(success));
   SendResponse(success);
 }
 
 bool FileWatchBrowserFunctionBase::RunImpl() {
   if (!render_view_host() || !render_view_host()->GetProcess())
@@ skipping 19 matching lines @@
 
   return true;
 }
 
 void FileWatchBrowserFunctionBase::RunFileWatchOperationOnFileThread(
     scoped_refptr<fileapi::FileSystemContext> file_system_context,
     scoped_refptr<FileBrowserEventRouter> event_router,
     const GURL& file_url, const std::string& extension_id) {
   FilePath local_path;
   FilePath virtual_path;
-  if (!GetLocalFilePath(
-          file_system_context, file_url, &local_path, &virtual_path) ||
+  if (!GetLocalFilePath(file_url, &local_path, &virtual_path) ||
       local_path == FilePath()) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(
             &FileWatchBrowserFunctionBase::RespondOnUIThread,
             this,
             false));
   }
   if (!PerformFileWatchOperation(event_router,
                                  local_path,
@@ skipping 34 matching lines @@
 // from drive. We'll know that they are drive apps because the extension id will
 // begin with kDriveTaskExtensionPrefix.
 bool GetFileTasksFileBrowserFunction::FindDriveAppTasks(
     const std::vector<GURL>& file_urls,
     ListValue* result_list) {
 
   // Crack all the urls into file paths.
   std::vector<FilePath> file_paths;
   for (std::vector<GURL>::const_iterator iter = file_urls.begin();
        iter != file_urls.end(); ++iter) {
-    FilePath raw_path;
-    fileapi::FileSystemType type = fileapi::kFileSystemTypeUnknown;
-    if (fileapi::CrackFileSystemURL(*iter, NULL, &type, &raw_path) &&
-        type == fileapi::kFileSystemTypeExternal) {
-      file_paths.push_back(raw_path);
-    }
+    fileapi::FileSystemURL url(*iter);
+    if (chromeos::CrosMountPointProvider::CanHandleURL(url))
+      file_paths.push_back(url.virtual_path());
   }
 
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if incognito window / guest login. We return true
   // in this case because there might be other extension tasks, even if we don't
   // have any to add.
   if (!system_service || !system_service->webapps_registry())
     return true;
 
@@ skipping 190 matching lines @@
       base::Bind(
           &FileBrowserFunction::GetLocalPathsOnFileThread,
           this,
           file_system_context, file_urls, callback));
 }
 
 // GetFileSystemRootPathOnFileThread can only be called from the file thread,
 // so here we are. This function takes a vector of virtual paths, converts
 // them to local paths and calls |callback| with the result vector, on the UI
 // thread.
+// TODO(kinuko): We no longer call GetFileSystemRootPathOnFileThread and
+// we can likely remove this cross-thread helper method.
 void FileBrowserFunction::GetLocalPathsOnFileThread(
     scoped_refptr<fileapi::FileSystemContext> file_system_context,
     const UrlList& file_urls,
     GetLocalPathsCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   std::vector<ui::SelectedFileInfo> selected_files;
 
-  // FilePath(virtual_path) doesn't work on win, so limit this to ChromeOS.
-  fileapi::ExternalFileSystemMountPointProvider* provider =
-      file_system_context->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();
   size_t len = file_urls.size();
   selected_files.reserve(len);
   for (size_t i = 0; i < len; ++i) {
     FilePath local_path;
     const GURL& file_url = file_urls[i];
 
     // If "localPath" parameter is set, use it as the real path.
     // TODO(satorux): Eventually, we should be able to get the real path
     // from GDataFileSystem instead of passing through with filesystem
@@ skipping 14 matching lines @@
                 net::UnescapeURLComponent(parameters[i].second,
                                           kUnescapeRuleForQueryParameters);
             local_path = FilePath::FromUTF8Unsafe(unescaped_value);
             break;
           }
         }
       }
     }
 
     // Extract the path from |file_url|.
-    GURL file_origin_url;
-    FilePath virtual_path;
-    fileapi::FileSystemType type;
+    fileapi::FileSystemURL url(file_url);
+    if (!chromeos::CrosMountPointProvider::CanHandleURL(url))
+      continue;
 
-    if (!CrackFileSystemURL(file_url, &file_origin_url, &type,
-                            &virtual_path)) {
-      continue;
-    }
-    if (type != fileapi::kFileSystemTypeExternal) {
-      NOTREACHED();
-      continue;
-    }
-
-    FilePath root = provider->GetFileSystemRootPathOnFileThread(
-        origin_url,
-        fileapi::kFileSystemTypeExternal,
-        FilePath(virtual_path),
-        false);
-    FilePath file_path;
-    if (!root.empty()) {
-      file_path = root.Append(virtual_path);
-    } else {
-      LOG(WARNING) << "GetLocalPathsOnFileThread failed "
-                   << file_url.spec();
-    }
-
-    if (!file_path.empty()) {
-      DVLOG(1) << "Selected: file path: " << file_path.value()
+    if (!url.path().empty()) {
+      DVLOG(1) << "Selected: file path: " << url.path().value()
                << " local path: " << local_path.value();
       selected_files.push_back(
-          ui::SelectedFileInfo(file_path, local_path));
+          ui::SelectedFileInfo(url.path(), local_path));
     }
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, selected_files));
 }
 
 bool SelectFileFunction::RunImpl() {
   if (args_->GetSize() != 2) {
     return false;
@@ skipping 1501 matching lines @@
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::GetForProfile(profile_);
   if (!system_service || !system_service->file_system())
     return false;
 
   FilePath directory_path = GetVirtualPathFromURL(GURL(file_url_as_string));
   system_service->file_system()->RequestDirectoryRefresh(directory_path);
 
   return true;
 }