New FileSystemURL cracking

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 <sys/stat.h>
 #include <sys/statvfs.h>
 #include <sys/types.h>
 #include <utime.h>
@@ skipping 76 matching lines @@
 using extensions::app_file_handler_util::FindFileHandlersForMimeTypes;
 using chromeos::disks::DiskMountManager;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 using extensions::ZipFileCreator;
 using file_handler_util::FileTaskExecutor;
+using fileapi::FileSystemURL;
 using google_apis::InstalledApp;
 
 namespace {
 
 // Default icon path for drive docs.
 const char kDefaultIcon[] = "images/filetype_generic.png";
 const int kPreferredIconSize = 16;
 
 // Error messages.
 const char kFileError[] = "File error %d";
@@ skipping 212 matching lines @@
         static_cast<uint64_t>(stat.f_bfree) * stat.f_frsize;
   }
   *total_size_kb = static_cast<size_t>(total_size_in_bytes / 1024);
   *remaining_size_kb = static_cast<size_t>(remaining_size_in_bytes / 1024);
 }
 
 // Given a |url|, return the virtual FilePath associated with it. If the file
 // isn't of the type CrosMountPointProvider handles, return an empty FilePath.
 //
 // Virtual paths will look like "Downloads/foo/bar.txt" or "drive/foo/bar.txt".
-FilePath GetVirtualPathFromURL(const GURL& url) {
-  fileapi::FileSystemURL filesystem_url(url);
+FilePath GetVirtualPathFromURL(fileapi::FileSystemContext* context,
+                               const GURL& url) {
+  fileapi::FileSystemURL filesystem_url(context->CrackURL(url));
   if (!chromeos::CrosMountPointProvider::CanHandleURL(filesystem_url))
     return FilePath();
   return filesystem_url.virtual_path();
 }
 
 // Given a |url|, return the local FilePath associated with it. If the file
 // isn't of the type CrosMountPointProvider handles, return an empty FilePath.
 //
 // Local paths will look like "/home/chronos/user/Downloads/foo/bar.txt" or
 // "/special/drive/foo/bar.txt".
-FilePath GetLocalPathFromURL(const GURL& url) {
-  fileapi::FileSystemURL filesystem_url(url);
+FilePath GetLocalPathFromURL(fileapi::FileSystemContext* context,
+                             const GURL& url) {
+  fileapi::FileSystemURL filesystem_url(context->CrackURL(url));
   if (!chromeos::CrosMountPointProvider::CanHandleURL(filesystem_url))
     return FilePath();
   return filesystem_url.path();
 }
 
 // Make a set of unique filename suffixes out of the list of file URLs.
-std::set<std::string> GetUniqueSuffixes(base::ListValue* file_url_list) {
+std::set<std::string> GetUniqueSuffixes(base::ListValue* file_url_list,
+                                        fileapi::FileSystemContext* context) {
   std::set<std::string> suffixes;
   for (size_t i = 0; i < file_url_list->GetSize(); ++i) {
-    std::string url;
-    if (!file_url_list->GetString(i, &url))
+    std::string url_str;
+    if (!file_url_list->GetString(i, &url_str))
       return std::set<std::string>();
-    FilePath path = GetVirtualPathFromURL(GURL(url));
-    if (path.empty())
+    FileSystemURL url = context->CrackURL(GURL(url_str));
+    if (!url.is_valid() || url.path().empty())
       return std::set<std::string>();
     // We'll skip empty suffixes.
-    if (!path.Extension().empty())
-      suffixes.insert(path.Extension());
+    if (!url.path().Extension().empty())
+      suffixes.insert(url.path().Extension());
   }
   return suffixes;
 }
 
 // Make a set of unique MIME types out of the list of MIME types.
 std::set<std::string> GetUniqueMimeTypes(base::ListValue* mime_type_list) {
   std::set<std::string> mime_types;
   for (size_t i = 0; i < mime_type_list->GetSize(); ++i) {
     std::string mime_type;
     if (!mime_type_list->GetString(i, &mime_type))
@@ skipping 62 matching lines @@
   if (!entry_proto.content_url().empty())
     property_dict->SetString("contentUrl", entry_proto.content_url());
 
   property_dict->SetBoolean("isHosted",
                             file_specific_info.is_hosted_document());
 
   property_dict->SetString("contentMimeType",
                            file_specific_info.content_mime_type());
 }
 
+void GetMimeTypesForFileURLs(const std::vector<FilePath>& file_paths,
+                             std::set<std::string>* mime_types) {
+  for (std::vector<FilePath>::const_iterator iter = file_paths.begin();
+       iter != file_paths.end(); ++iter) {
+    const FilePath::StringType file_extension =
+        StringToLowerASCII(iter->Extension());
+
+    // TODO(thorogood): Rearchitect this call so it can run on the File thread;
+    // GetMimeTypeFromFile requires this on Linux. Right now, we use
+    // Chrome-level knowledge only.
+    std::string mime_type;
+    if (file_extension.empty() ||
+        !net::GetWellKnownMimeTypeFromExtension(file_extension.substr(1),
+                                                &mime_type)) {
+      // If the file doesn't have an extension or its mime-type cannot be
+      // determined, then indicate that it has the empty mime-type. This will
+      // only be matched if the Web Intents accepts "*" or "*/*".
+      mime_types->insert("");
+    } else {
+      mime_types->insert(mime_type);
+    }
+  }
+}
+
 }  // namespace
 
 class RequestLocalFileSystemFunction::LocalFileSystemCallbackDispatcher {
  public:
   static fileapi::FileSystemContext::OpenFileSystemCallback CreateCallback(
       RequestLocalFileSystemFunction* function,
       scoped_refptr<fileapi::FileSystemContext> file_system_context,
       int child_id,
       scoped_refptr<const Extension> extension) {
     return base::Bind(
@@ skipping 213 matching lines @@
 
 bool FileWatchBrowserFunctionBase::RunImpl() {
   if (!render_view_host() || !render_view_host()->GetProcess())
     return false;
 
   // First param is url of a file to watch.
   std::string url;
   if (!args_->GetString(0, &url) || url.empty())
     return false;
 
-  GURL file_watch_url(url);
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  FileSystemURL file_watch_url = file_system_context->CrackURL(GURL(url));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(
           &FileWatchBrowserFunctionBase::RunFileWatchOperationOnFileThread,
           this,
           FileBrowserPrivateAPI::Get(profile_)->event_router(),
           file_watch_url,
           extension_id()));
 
   return true;
 }
 
 void FileWatchBrowserFunctionBase::RunFileWatchOperationOnFileThread(
     scoped_refptr<FileBrowserEventRouter> event_router,
-    const GURL& file_url, const std::string& extension_id) {
-  FilePath local_path = GetLocalPathFromURL(file_url);
-  FilePath virtual_path = GetVirtualPathFromURL(file_url);
+    const FileSystemURL& file_url, const std::string& extension_id) {
+  FilePath local_path = file_url.path();
+  FilePath virtual_path = file_url.virtual_path();
   bool result = !local_path.empty() && PerformFileWatchOperation(
       event_router, local_path, virtual_path, extension_id);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &FileWatchBrowserFunctionBase::RespondOnUIThread, this, result));
 }
 
 bool AddFileWatchBrowserFunction::PerformFileWatchOperation(
@@ skipping 164 matching lines @@
   std::set<std::string> default_tasks;
   FindDefaultDriveTasks(file_info_list, available_tasks, &default_tasks);
   CreateDriveTasks(registry, app_info, available_tasks, default_tasks,
                    result_list, default_already_set);
 
   // We own the pointers in |app_info|, so we need to delete them.
   STLDeleteContainerPairSecondPointers(app_info.begin(), app_info.end());
   return true;
 }
 
-static void GetMimeTypesForFileURLs(const std::vector<GURL>& file_urls,
-    std::set<std::string>* mime_types) {
-  for (std::vector<GURL>::const_iterator iter = file_urls.begin();
-       iter != file_urls.end(); ++iter) {
-    const FilePath file = FilePath(GURL(iter->spec()).ExtractFileName());
-    const FilePath::StringType file_extension =
-        StringToLowerASCII(file.Extension());
-
-    // TODO(thorogood): Rearchitect this call so it can run on the File thread;
-    // GetMimeTypeFromFile requires this on Linux. Right now, we use
-    // Chrome-level knowledge only.
-    std::string mime_type;
-    if (file_extension.empty() || !net::GetWellKnownMimeTypeFromExtension(
-            file_extension.substr(1), &mime_type)) {
-      // If the file doesn't have an extension or its mime-type cannot be
-      // determined, then indicate that it has the empty mime-type. This will
-      // only be matched if the Web Intents accepts "*" or "*/*".
-      mime_types->insert("");
-    } else {
-      mime_types->insert(mime_type);
-    }
-  }
-}
-
 bool GetFileTasksFileBrowserFunction::FindAppTasks(
-    const std::vector<GURL>& file_urls,
+    const std::vector<FilePath>& file_paths,
     ListValue* result_list) {
-  DCHECK(!file_urls.empty());
+  DCHECK(!file_paths.empty());
   ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return false;
 
   std::set<std::string> mime_types;
-  GetMimeTypesForFileURLs(file_urls, &mime_types);
+  GetMimeTypesForFileURLs(file_paths, &mime_types);
 
   for (ExtensionSet::const_iterator iter = service->extensions()->begin();
        iter != service->extensions()->end();
        ++iter) {
     const Extension* extension = *iter;
 
     // We don't support using hosted apps to open files.
     if (!extension->is_platform_app())
       continue;
 
@@ skipping 28 matching lines @@
       result_list->Append(task);
     }
   }
 
   return true;
 }
 
 // Find Web Intent platform apps that support the View task, and add them to
 // the |result_list|. These will be marked as kTaskWebIntent.
 bool GetFileTasksFileBrowserFunction::FindWebIntentTasks(
-    const std::vector<GURL>& file_urls,
+    const std::vector<FilePath>& file_paths,
     ListValue* result_list) {
-  DCHECK(!file_urls.empty());
+  DCHECK(!file_paths.empty());
   ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return false;
 
   std::set<std::string> mime_types;
-  GetMimeTypesForFileURLs(file_urls, &mime_types);
+  GetMimeTypesForFileURLs(file_paths, &mime_types);
 
   for (ExtensionSet::const_iterator iter = service->extensions()->begin();
        iter != service->extensions()->end();
        ++iter) {
     const Extension* extension = *iter;
 
     // We don't support using hosted apps to open files.
     if (!extension->is_platform_app())
       continue;
 
@@ skipping 36 matching lines @@
   // Second argument is the list of mime types of each of the files in the list.
   ListValue* mime_types_list = NULL;
   if (!args_->GetList(1, &mime_types_list))
     return false;
 
   // MIME types can either be empty, or there needs to be one for each file.
   if (mime_types_list->GetSize() != files_list->GetSize() &&
       mime_types_list->GetSize() != 0)
     return false;
 
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
   // Collect all the URLs, convert them to GURLs, and crack all the urls into
   // file paths.
   FileInfoList info_list;
   std::vector<GURL> file_urls;
+  std::vector<FilePath> file_paths;
   for (size_t i = 0; i < files_list->GetSize(); ++i) {
     FileInfo info;
-    std::string file_url;
-    if (!files_list->GetString(i, &file_url))
+    std::string file_url_str;
+    if (!files_list->GetString(i, &file_url_str))
       return false;
-    info.file_url = GURL(file_url);
-    file_urls.push_back(info.file_url);
+
     if (mime_types_list->GetSize() != 0 &&
         !mime_types_list->GetString(i, &info.mime_type))
       return false;
-    fileapi::FileSystemURL file_system_url(info.file_url);
-    if (chromeos::CrosMountPointProvider::CanHandleURL(file_system_url)) {
-      info.file_path = file_system_url.path();
-    }
+
+    GURL file_url(file_url_str);
+    fileapi::FileSystemURL file_system_url(
+        file_system_context->CrackURL(file_url));
+    if (!chromeos::CrosMountPointProvider::CanHandleURL(file_system_url))
+      continue;
+
+    file_urls.push_back(file_url);
+    file_paths.push_back(file_system_url.path());
+
+    info.file_url = file_url;
+    info.file_path = file_system_url.path();
     info_list.push_back(info);
   }
 
   ListValue* result_list = new ListValue();
   SetResult(result_list);
 
   // Find the Drive apps first, because we want them to take precedence
   // when setting the default app.
   bool default_already_set = false;
   if (!FindDriveAppTasks(info_list, result_list, &default_already_set))
     return false;
 
   // Take the union of Drive and extension tasks: Because any Drive tasks we
   // found must apply to all of the files (intersection), and because the same
   // is true of the extensions, we simply take the union of two lists by adding
   // the extension tasks to the Drive task list. We know there aren't duplicates
   // because they're entirely different kinds of tasks, but there could be both
   // kinds of tasks for a file type (an image file, for instance).
   std::set<const FileBrowserHandler*> common_tasks;
   std::set<const FileBrowserHandler*> default_tasks;
   if (!file_handler_util::FindCommonTasks(profile_, file_urls, &common_tasks))
     return false;
-  file_handler_util::FindDefaultTasks(profile_, file_urls,
+  file_handler_util::FindDefaultTasks(profile_, file_paths,
                                       common_tasks, &default_tasks);
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   for (std::set<const FileBrowserHandler*>::const_iterator iter =
            common_tasks.begin();
        iter != common_tasks.end();
        ++iter) {
     const FileBrowserHandler* handler = *iter;
     const std::string extension_id = handler->extension_id();
@@ skipping 22 matching lines @@
       task->SetBoolean("isDefault", false);
     }
 
     result_list->Append(task);
   }
 
   // Take the union of platform app file handlers, Web Intents that platform
   // apps may accept, and all previous Drive and extension tasks. As above, we
   // know there aren't duplicates because they're entirely different kinds of
   // tasks.
-  if (!FindAppTasks(file_urls, result_list))
+  if (!FindAppTasks(file_paths, result_list))
     return false;
 
   // TODO(benwells): remove the web intents tasks once we no longer support
   // them.
-  if (!FindWebIntentTasks(file_urls, result_list))
+  if (!FindWebIntentTasks(file_paths, result_list))
     return false;
 
   if (VLOG_IS_ON(1)) {
     std::string result_json;
     base::JSONWriter::WriteWithOptions(
         result_list,
         base::JSONWriter::OPTIONS_DO_NOT_ESCAPE |
           base::JSONWriter::OPTIONS_PRETTY_PRINT,
         &result_json);
     VLOG(1) << "GetFileTasks result:\n" << result_json;
@@ skipping 31 matching lines @@
   std::string action_id;
   if (!file_handler_util::CrackTaskID(
       task_id, &extension_id, &task_type, &action_id)) {
     LOG(WARNING) << "Invalid task " << task_id;
     return false;
   }
 
   if (!files_list->GetSize())
     return true;
 
-  std::vector<GURL> file_urls;
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  std::vector<FileSystemURL> file_urls;
   for (size_t i = 0; i < files_list->GetSize(); i++) {
-    std::string origin_file_url;
-    if (!files_list->GetString(i, &origin_file_url)) {
+    std::string file_url_str;
+    if (!files_list->GetString(i, &file_url_str)) {
       error_ = kInvalidFileUrl;
       return false;
     }
-    file_urls.push_back(GURL(origin_file_url));
+    FileSystemURL url = file_system_context->CrackURL(GURL(file_url_str));
+    if (!chromeos::CrosMountPointProvider::CanHandleURL(url)) {
+      error_ = kInvalidFileUrl;
+      return false;
+    }
+    file_urls.push_back(url);
   }
 
   WebContents* web_contents =
       dispatcher()->delegate()->GetAssociatedWebContents();
   int32 tab_id = 0;
   if (web_contents)
     tab_id = ExtensionTabUtil::GetTabId(web_contents);
 
   scoped_refptr<FileTaskExecutor> executor(
       FileTaskExecutor::Create(profile(),
@@ skipping 19 matching lines @@
 
 bool SetDefaultTaskFileBrowserFunction::RunImpl() {
   // First param is task id that was to the extension with setDefaultTask call.
   std::string task_id;
   if (!args_->GetString(0, &task_id) || !task_id.size())
     return false;
 
   base::ListValue* file_url_list;
   if (!args_->GetList(1, &file_url_list))
     return false;
-  std::set<std::string> suffixes = GetUniqueSuffixes(file_url_list);
+
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  std::set<std::string> suffixes = GetUniqueSuffixes(file_url_list, context);
 
   // MIME types are an optional parameter.
   base::ListValue* mime_type_list;
   std::set<std::string> mime_types;
   if (args_->GetList(2, &mime_type_list) && !mime_type_list->empty()) {
     if (mime_type_list->GetSize() != file_url_list->GetSize())
       return false;
     mime_types = GetUniqueMimeTypes(mime_type_list);
   }
 
@@ skipping 100 matching lines @@
                 net::UnescapeURLComponent(parameters[i].second,
                                           kUnescapeRuleForQueryParameters);
             local_path = FilePath::FromUTF8Unsafe(unescaped_value);
             break;
           }
         }
       }
     }
 
     // Extract the path from |file_url|.
-    fileapi::FileSystemURL url(file_url);
+    fileapi::FileSystemURL url(file_system_context->CrackURL(file_url));
     if (!chromeos::CrosMountPointProvider::CanHandleURL(url))
       continue;
 
     if (!url.path().empty()) {
       DVLOG(1) << "Selected: file path: " << url.path().value()
                << " local path: " << local_path.value();
       selected_files.push_back(
           ui::SelectedFileInfo(url.path(), local_path));
     }
   }
@@ skipping 43 matching lines @@
     return false;
   }
 
   ListValue* path_list = NULL;
   args_->GetList(0, &path_list);
   DCHECK(path_list);
 
   std::string internal_task_id;
   args_->GetString(1, &internal_task_id);
 
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
   std::vector<FilePath> files;
   for (size_t i = 0; i < path_list->GetSize(); ++i) {
     std::string url_as_string;
     path_list->GetString(i, &url_as_string);
-    FilePath path = GetLocalPathFromURL(GURL(url_as_string));
+    FilePath path = GetLocalPathFromURL(file_system_context,
+                                        GURL(url_as_string));
     if (path.empty())
       return false;
     files.push_back(path);
   }
 
   Browser* browser = GetCurrentBrowser();
   bool success = browser;
 
   if (browser) {
     for (size_t i = 0; i < files.size(); ++i) {
@@ skipping 252 matching lines @@
             file_url,
             strtoul(timestamp.c_str(), NULL, 0)));
 
   return true;
 }
 
 void SetLastModifiedFunction::RunOperationOnFileThread(std::string file_url,
                                                        time_t timestamp) {
   bool succeeded = false;
 
-  FilePath local_path = GetLocalPathFromURL(GURL(file_url));
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  FilePath local_path = GetLocalPathFromURL(file_system_context,
+                                            GURL(file_url));
   if (!local_path.empty()) {
     struct stat sb;
     if (stat(local_path.value().c_str(), &sb) == 0) {
       struct utimbuf times;
       times.actime = sb.st_atime;
       times.modtime = timestamp;
 
       if (utime(local_path.value().c_str(), &times) == 0)
         succeeded = true;
     }
@@ skipping 15 matching lines @@
 
 bool GetSizeStatsFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     return false;
   }
 
   std::string mount_url;
   if (!args_->GetString(0, &mount_url))
     return false;
 
-  FilePath file_path = GetLocalPathFromURL(GURL(mount_url));
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  FilePath file_path = GetLocalPathFromURL(file_system_context,
+                                           GURL(mount_url));
   if (file_path.empty())
     return false;
 
   if (file_path == drive::util::GetDriveMountPointPath()) {
     drive::DriveSystemService* system_service =
         drive::DriveSystemServiceFactory::GetForProfile(profile_);
     // |system_service| is NULL if Drive is disabled.
     if (!system_service) {
       // If stats couldn't be gotten for drive, result should be left
       // undefined. See comments in GetDriveAvailableSpaceCallback().
@@ skipping 75 matching lines @@
   if (args_->GetSize() != 1) {
     return false;
   }
 
   std::string volume_file_url;
   if (!args_->GetString(0, &volume_file_url)) {
     NOTREACHED();
     return false;
   }
 
-  FilePath file_path = GetLocalPathFromURL(GURL(volume_file_url));
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  FilePath file_path = GetLocalPathFromURL(file_system_context,
+                                           GURL(volume_file_url));
   if (file_path.empty())
     return false;
 
   DiskMountManager::GetInstance()->FormatMountedDevice(file_path.value());
   SendResponse(true);
   return true;
 }
 
 GetVolumeMetadataFunction::GetVolumeMetadataFunction() {
 }
 
 GetVolumeMetadataFunction::~GetVolumeMetadataFunction() {
 }
 
 bool GetVolumeMetadataFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     error_ = "Invalid argument count";
     return false;
   }
 
   std::string volume_mount_url;
   if (!args_->GetString(0, &volume_mount_url)) {
     NOTREACHED();
     return false;
   }
 
-  FilePath file_path = GetLocalPathFromURL(GURL(volume_mount_url));
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  FilePath file_path = GetLocalPathFromURL(file_system_context,
+                                           GURL(volume_mount_url));
   if (file_path.empty()) {
     error_ = "Invalid mount path.";
     return false;
   }
 
   results_.reset();
 
   const DiskMountManager::Disk* volume = GetVolumeAsDisk(file_path.value());
   if (volume) {
     DictionaryValue* volume_info =
@@ skipping 428 matching lines @@
 }
 
 void GetDriveFilePropertiesFunction::GetNextFileProperties() {
   if (current_index_ >= path_list_->GetSize()) {
     // Exit of asynchronous look and return the result.
     SetResult(file_properties_.release());
     SendResponse(true);
     return;
   }
 
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
   std::string file_str;
   path_list_->GetString(current_index_, &file_str);
   GURL file_url = GURL(file_str);
-  FilePath file_path = GetVirtualPathFromURL(file_url);
+  FilePath file_path = GetVirtualPathFromURL(file_system_context,
+                                             file_url);
 
   base::DictionaryValue* property_dict = new base::DictionaryValue;
   property_dict->SetString("fileUrl", file_url.spec());
   file_properties_->Append(property_dict);
 
   // Start getting the file info.
   drive::DriveSystemService* system_service =
       drive::DriveSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if Drive is disabled.
   if (!system_service) {
@@ skipping 197 matching lines @@
 }
 
 GetFileLocationsFunction::~GetFileLocationsFunction() {
 }
 
 bool GetFileLocationsFunction::RunImpl() {
   ListValue* file_urls_as_strings = NULL;
   if (!args_->GetList(0, &file_urls_as_strings))
     return false;
 
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
   // Convert the list of strings to a list of GURLs.
   scoped_ptr<ListValue> locations(new ListValue);
   for (size_t i = 0; i < file_urls_as_strings->GetSize(); ++i) {
     std::string file_url_as_string;
     if (!file_urls_as_strings->GetString(i, &file_url_as_string))
       return false;
 
-    fileapi::FileSystemURL url((GURL(file_url_as_string)));
+    fileapi::FileSystemURL url(
+        file_system_context->CrackURL(GURL(file_url_as_string)));
     if (url.type() == fileapi::kFileSystemTypeDrive)
       locations->Append(new base::StringValue("drive"));
     else
       locations->Append(new base::StringValue("local"));
   }
 
   SetResult(locations.release());
   SendResponse(true);
   return true;
 }
@@ skipping 135 matching lines @@
   ListValue* url_list = NULL;
   if (!args_->GetList(0, &url_list))
     return false;
 
   drive::DriveSystemService* system_service =
       drive::DriveSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if Drive is disabled.
   if (!system_service)
     return false;
 
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
   scoped_ptr<ListValue> responses(new ListValue());
   for (size_t i = 0; i < url_list->GetSize(); ++i) {
     std::string url_as_string;
     url_list->GetString(i, &url_as_string);
 
-    FilePath file_path = GetLocalPathFromURL(GURL(url_as_string));
+    FilePath file_path = GetLocalPathFromURL(file_system_context,
+                                             GURL(url_as_string));
     if (file_path.empty())
       continue;
 
     DCHECK(drive::util::IsUnderDriveMountPoint(file_path));
     file_path = drive::util::ExtractDrivePath(file_path);
     scoped_ptr<DictionaryValue> result(new DictionaryValue());
     result->SetBoolean(
         "canceled",
         system_service->drive_service()->CancelForFilePath(file_path));
     GURL file_url;
@@ skipping 21 matching lines @@
       !args_->GetString(1, &destination_file_url)) {
     return false;
   }
 
   drive::DriveSystemService* system_service =
       drive::DriveSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if Drive is disabled.
   if (!system_service)
     return false;
 
-  FilePath source_file = GetLocalPathFromURL(GURL(source_file_url));
-  FilePath destination_file = GetLocalPathFromURL(GURL(destination_file_url));
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  FilePath source_file = GetLocalPathFromURL(file_system_context,
+                                             GURL(source_file_url));
+  FilePath destination_file = GetLocalPathFromURL(file_system_context,
+                                                  GURL(destination_file_url));
   if (source_file.empty() || destination_file.empty())
     return false;
 
   bool source_file_under_drive =
       drive::util::IsUnderDriveMountPoint(source_file);
   bool destination_file_under_drive =
       drive::util::IsUnderDriveMountPoint(destination_file);
 
   if (source_file_under_drive && !destination_file_under_drive) {
     // Transfer a file from gdata to local file system.
@@ skipping 227 matching lines @@
   std::string file_url_as_string;
   if (!args_->GetString(0, &file_url_as_string))
     return false;
 
   drive::DriveSystemService* system_service =
       drive::DriveSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if Drive is disabled.
   if (!system_service || !system_service->file_system())
     return false;
 
-  FilePath directory_path = GetVirtualPathFromURL(GURL(file_url_as_string));
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  FilePath directory_path = GetVirtualPathFromURL(file_system_context,
+                                                  GURL(file_url_as_string));
   system_service->file_system()->RequestDirectoryRefresh(directory_path);
 
   return true;
 }
 
 ZipSelectionFunction::ZipSelectionFunction() {
 }
 
 ZipSelectionFunction::~ZipSelectionFunction() {
 }
 
 bool ZipSelectionFunction::RunImpl() {
   if (args_->GetSize() < 3) {
     return false;
   }
 
   // First param is the source directory URL.
   std::string dir_url;
   if (!args_->GetString(0, &dir_url) || dir_url.empty())
     return false;
 
-  FilePath src_dir = GetLocalPathFromURL(GURL(dir_url));
+  content::SiteInstance* site_instance = render_view_host()->GetSiteInstance();
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetStoragePartition(profile(), site_instance)->
+          GetFileSystemContext();
+
+  FilePath src_dir = GetLocalPathFromURL(file_system_context,
+                                         GURL(dir_url));
   if (src_dir.empty())
     return false;
 
   // Second param is the list of selected file URLs.
   ListValue* selection_urls = NULL;
   args_->GetList(1, &selection_urls);
   if (!selection_urls || !selection_urls->GetSize())
     return false;
 
   std::vector<FilePath> files;
   for (size_t i = 0; i < selection_urls->GetSize(); ++i) {
     std::string file_url;
     selection_urls->GetString(i, &file_url);
-    FilePath path = GetLocalPathFromURL(GURL(file_url));
+    FilePath path = GetLocalPathFromURL(file_system_context, GURL(file_url));
     if (path.empty())
       return false;
     files.push_back(path);
   }
 
   // Third param is the name of the output zip file.
   std::string dest_name;
   if (!args_->GetString(2, &dest_name) || dest_name.empty())
     return false;
 
@@ skipping 24 matching lines @@
   // Keep the refcount until the zipping is complete on utility process.
   AddRef();
   return true;
 }
 
 void ZipSelectionFunction::OnZipDone(bool success) {
   SetResult(new base::FundamentalValue(success));
   SendResponse(true);
   Release();
 }