New FileSystemURL cracking

chrome/browser/chromeos/extensions/file_handler_util.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_handler_util.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_writer.h"
@@ skipping 31 matching lines @@
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
+using fileapi::FileSystemURL;
 
 namespace file_handler_util {
 
 const char kTaskFile[] = "file";
 const char kTaskDrive[] = "drive";
 const char kTaskWebIntent[] = "web-intent";
 const char kTaskApp[] = "app";
 
 namespace {
 
@@ skipping 278 matching lines @@
          !((*iter)->extension_id() == extension_id &&
            (*iter)->id() == id)) {
     iter++;
   }
   return iter;
 }
 
 // Given the list of selected files, returns array of file action tasks
 // that are shared between them.
 void FindDefaultTasks(Profile* profile,
-                      const std::vector<GURL>& files_list,
+                      const std::vector<FilePath>& files_list,
                       const FileBrowserHandlerSet& common_tasks,
                       FileBrowserHandlerSet* default_tasks) {
   DCHECK(default_tasks);
   default_tasks->clear();
 
   std::set<std::string> default_ids;
-  for (std::vector<GURL>::const_iterator it = files_list.begin();
+  for (std::vector<FilePath>::const_iterator it = files_list.begin();
        it != files_list.end(); ++it) {
-    // Get the default task for this file based only on the extension (since
-    // we don't have MIME types here), and add it to the set of default tasks.
-    fileapi::FileSystemURL filesystem_url(*it);
-    if (filesystem_url.is_valid() &&
-        (filesystem_url.type() == fileapi::kFileSystemTypeDrive ||
-         filesystem_url.type() == fileapi::kFileSystemTypeNativeMedia ||
-         filesystem_url.type() == fileapi::kFileSystemTypeNativeLocal)) {
-      std::string task_id = file_handler_util::GetDefaultTaskIdFromPrefs(
-          profile, "", filesystem_url.virtual_path().Extension());
-      if (!task_id.empty())
-        default_ids.insert(task_id);
-    }
+    std::string task_id = file_handler_util::GetDefaultTaskIdFromPrefs(
+        profile, "", it->Extension());
+    if (!task_id.empty())
+      default_ids.insert(task_id);
   }
 
   const FileBrowserHandler* builtin_task = NULL;
   // Convert the default task IDs collected above to one of the handler pointers
   // from common_tasks.
   for (FileBrowserHandlerSet::const_iterator task_iter = common_tasks.begin();
        task_iter != common_tasks.end(); ++task_iter) {
     std::string task_id = MakeTaskID((*task_iter)->extension_id(), kTaskFile,
                                      (*task_iter)->id());
     std::set<std::string>::iterator default_iter = default_ids.find(task_id);
@@ skipping 66 matching lines @@
     if (files_list.size() == 1)
       common_task_set.erase(gallery_iter);
     else
       common_task_set.erase(watch_iter);
   }
 
   common_tasks->swap(common_task_set);
   return true;
 }
 
-bool GetTaskForURL(
-    Profile* profile, const GURL& url, const FileBrowserHandler** handler) {
+bool GetTaskForURLAndPath(Profile* profile,
+                   const GURL& url,
+                   const FilePath& file_path,
+                   const FileBrowserHandler** handler) {
   std::vector<GURL> file_urls;
   file_urls.push_back(url);
 
   FileBrowserHandlerSet default_tasks;
   FileBrowserHandlerSet common_tasks;
   if (!FindCommonTasks(profile, file_urls, &common_tasks))
     return false;
 
   if (common_tasks.empty())
     return false;
 
-  FindDefaultTasks(profile, file_urls, common_tasks, &default_tasks);
+  std::vector<FilePath> file_paths;
+  file_paths.push_back(file_path);
+
+  FindDefaultTasks(profile, file_paths, common_tasks, &default_tasks);
 
   // If there's none, or more than one, then we don't have a canonical default.
   if (!default_tasks.empty()) {
     // There should not be multiple default tasks for a single URL.
     DCHECK_EQ(1u, default_tasks.size());
 
     *handler = *default_tasks.begin();
     return true;
   }
 
   // If there are no default tasks, use first task in the list (file manager
   // does the same in this situation).
   // TODO(tbarzic): This is so not optimal behaviour.
   *handler = *common_tasks.begin();
   return true;
 }
 
 class ExtensionTaskExecutor : public FileTaskExecutor {
  public:
   // FileTaskExecutor overrides.
-  virtual bool ExecuteAndNotify(const std::vector<GURL>& file_urls,
+  virtual bool ExecuteAndNotify(const std::vector<FileSystemURL>& file_urls,
                        const FileTaskFinishedCallback& done) OVERRIDE;
 
  private:
   // FileTaskExecutor is the only class allowed to create one.
   friend class FileTaskExecutor;
 
   ExtensionTaskExecutor(Profile* profile,
                         const GURL& source_url,
                         const std::string& file_browser_id,
                         int32 tab_id,
                         const std::string& extension_id,
                         const std::string& action_id);
   virtual ~ExtensionTaskExecutor();
 
   struct FileDefinition {
     FileDefinition();
     ~FileDefinition();
 
-    GURL target_file_url;
     FilePath virtual_path;
     FilePath absolute_path;
     bool is_directory;
   };
 
   typedef std::vector<FileDefinition> FileDefinitionList;
   class ExecuteTasksFileSystemCallbackDispatcher;
   void RequestFileEntryOnFileThread(
       scoped_refptr<fileapi::FileSystemContext> file_system_context_handler,
       const GURL& handler_base_url,
       const scoped_refptr<const extensions::Extension>& handler,
       int handler_pid,
-      const std::vector<GURL>& file_urls);
+      const std::vector<FileSystemURL>& file_urls);
 
   void ExecuteDoneOnUIThread(bool success);
   void ExecuteFileActionsOnUIThread(const std::string& file_system_name,
                                     const GURL& file_system_root,
                                     const FileDefinitionList& file_list,
                                     int handler_pid);
   void SetupPermissionsAndDispatchEvent(const std::string& file_system_name,
                                         const GURL& file_system_root,
                                         const FileDefinitionList& file_list,
                                         int handler_pid_in,
                                         extensions::ExtensionHost* host);
 
   // Registers file permissions from |handler_host_permissions_| with
   // ChildProcessSecurityPolicy for process with id |handler_pid|.
   void SetupHandlerHostFileAccessPermissions(
       const FileDefinitionList& file_list,
       const Extension* extension,
       int handler_pid);
 
   int32 tab_id_;
   const std::string action_id_;
   FileTaskFinishedCallback done_;
 };
 
 class WebIntentTaskExecutor : public FileTaskExecutor {
  public:
   // FileTaskExecutor overrides.
-  virtual bool ExecuteAndNotify(const std::vector<GURL>& file_urls,
+  virtual bool ExecuteAndNotify(const std::vector<FileSystemURL>& file_urls,
                                 const FileTaskFinishedCallback& done) OVERRIDE;
 
  private:
   // FileTaskExecutor is the only class allowed to create one.
   friend class FileTaskExecutor;
 
   WebIntentTaskExecutor(Profile* profile,
                         const GURL& source_url,
                         const std::string& file_browser_id,
                         const std::string& extension_id,
                         const std::string& action_id);
   virtual ~WebIntentTaskExecutor();
 
   const std::string extension_id_;
   const std::string action_id_;
 };
 
 class AppTaskExecutor : public FileTaskExecutor {
  public:
   // FileTaskExecutor overrides.
-  virtual bool ExecuteAndNotify(const std::vector<GURL>& file_urls,
+  virtual bool ExecuteAndNotify(const std::vector<FileSystemURL>& file_urls,
                                 const FileTaskFinishedCallback& done) OVERRIDE;
 
  private:
   // FileTaskExecutor is the only class allowed to create one.
   friend class FileTaskExecutor;
 
   AppTaskExecutor(Profile* profile,
                   const GURL& source_url,
                   const std::string& file_browser_id,
                   const std::string& extension_id,
@@ skipping 49 matching lines @@
                                    const std::string& extension_id)
   : profile_(profile),
     source_url_(source_url),
     file_browser_id_(file_browser_id),
     extension_id_(extension_id) {
 }
 
 FileTaskExecutor::~FileTaskExecutor() {
 }
 
-bool FileTaskExecutor::Execute(const std::vector<GURL>& file_urls) {
+bool FileTaskExecutor::Execute(const std::vector<FileSystemURL>& file_urls) {
   return ExecuteAndNotify(file_urls, FileTaskFinishedCallback());
 }
 
 bool FileTaskExecutor::FileBrowserHasAccessPermissionForFiles(
-    const std::vector<GURL>& files) {
+    const std::vector<FileSystemURL>& files) {
   // Check if the file browser extension has permissions for the files in its
   // file system context.
   GURL site = extensions::ExtensionSystem::Get(profile())->extension_service()->
       GetSiteForExtensionId(file_browser_id_);
   fileapi::ExternalFileSystemMountPointProvider* external_provider =
       BrowserContext::GetStoragePartitionForSite(profile(), site)->
           GetFileSystemContext()->external_provider();
 
   if (!external_provider)
     return false;
 
   for (size_t i = 0; i < files.size(); ++i) {
-    fileapi::FileSystemURL url(files[i]);
     // Make sure this url really being used by the right caller extension.
-    if (source_url_.GetOrigin() != url.origin())
+    if (source_url_.GetOrigin() != files[i].origin())
       return false;
 
-    if (!chromeos::CrosMountPointProvider::CanHandleURL(url) ||
-        !external_provider->IsAccessAllowed(url)) {
+    if (!chromeos::CrosMountPointProvider::CanHandleURL(files[i]) ||
+        !external_provider->IsAccessAllowed(files[i])) {
       return false;
     }
   }
 
   return true;
 }
 
 // TODO(kaznacheev): Remove this method and inline its implementation at the
 // only place where it is used (DriveTaskExecutor::OnAppAuthorized)
 Browser* FileTaskExecutor::GetBrowser() const {
@@ skipping 18 matching lines @@
 }
 
 class ExtensionTaskExecutor::ExecuteTasksFileSystemCallbackDispatcher {
  public:
   static fileapi::FileSystemContext::OpenFileSystemCallback CreateCallback(
       ExtensionTaskExecutor* executor,
       scoped_refptr<fileapi::FileSystemContext> file_system_context_handler,
       scoped_refptr<const Extension> handler_extension,
       int handler_pid,
       const std::string& action_id,
-      const std::vector<GURL>& file_urls) {
+      const std::vector<FileSystemURL>& file_urls) {
     return base::Bind(
         &ExecuteTasksFileSystemCallbackDispatcher::DidOpenFileSystem,
         base::Owned(new ExecuteTasksFileSystemCallbackDispatcher(
             executor, file_system_context_handler, handler_extension,
             handler_pid, action_id, file_urls)));
   }
 
   void DidOpenFileSystem(base::PlatformFileError result,
                          const std::string& file_system_name,
                          const GURL& file_system_root) {
     if (result != base::PLATFORM_FILE_OK) {
       DidFail(result);
       return;
     }
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     ExtensionTaskExecutor::FileDefinitionList file_list;
-    for (std::vector<GURL>::iterator iter = origin_file_urls_.begin();
-         iter != origin_file_urls_.end();
+    for (std::vector<FileSystemURL>::iterator iter = urls_.begin();
+         iter != urls_.end();
          ++iter) {
       // Set up file permission access.
       ExtensionTaskExecutor::FileDefinition file;
       if (!SetupFileAccessPermissions(*iter, &file))
         continue;
       file_list.push_back(file);
     }
     if (file_list.empty()) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
@@ skipping 24 matching lines @@
             false));
   }
 
  private:
   ExecuteTasksFileSystemCallbackDispatcher(
       ExtensionTaskExecutor* executor,
       scoped_refptr<fileapi::FileSystemContext> file_system_context_handler,
       const scoped_refptr<const Extension>& handler_extension,
       int handler_pid,
       const std::string& action_id,
-      const std::vector<GURL>& file_urls)
+      const std::vector<FileSystemURL>& file_urls)
       : executor_(executor),
         file_system_context_handler_(file_system_context_handler),
         handler_extension_(handler_extension),
         handler_pid_(handler_pid),
         action_id_(action_id),
-        origin_file_urls_(file_urls) {
+        urls_(file_urls) {
     DCHECK(executor_);
   }
 
   // Checks legitimacy of file url and grants file RO access permissions from
   // handler (target) extension and its renderer process.
-  bool SetupFileAccessPermissions(const GURL& origin_file_url,
+  bool SetupFileAccessPermissions(const FileSystemURL& url,
                                   FileDefinition* file) {
     if (!handler_extension_.get())
       return false;
 
     if (handler_pid_ == 0)
       return false;
 
-    fileapi::FileSystemURL url(origin_file_url);
-
     fileapi::ExternalFileSystemMountPointProvider* external_provider_handler =
         file_system_context_handler_->external_provider();
 
     // Check if this file system entry exists first.
     base::PlatformFileInfo file_info;
 
     FilePath local_path = url.path();
     FilePath virtual_path = url.virtual_path();
 
     bool is_drive_file = url.type() == fileapi::kFileSystemTypeDrive;
     DCHECK(!is_drive_file || drive::util::IsUnderDriveMountPoint(local_path));
 
     // If the file is under gdata mount point, there is no actual file to be
     // found on the url.path().
     if (!is_drive_file) {
       if (!file_util::PathExists(local_path) ||
           file_util::IsLink(local_path) ||
           !file_util::GetFileInfo(local_path, &file_info)) {
         return false;
       }
     }
 
     // Grant access to this particular file to target extension. This will
     // ensure that the target extension can access only this FS entry and
     // prevent from traversing FS hierarchy upward.
     external_provider_handler->GrantFileAccessToExtension(
         handler_extension_->id(), virtual_path);
 
     // Output values.
-    GURL target_origin_url(Extension::GetBaseURLFromExtensionId(
-        handler_extension_->id()));
-    GURL base_url = fileapi::GetFileSystemRootURI(target_origin_url,
-        fileapi::kFileSystemTypeExternal);
-    file->target_file_url = GURL(base_url.spec() + virtual_path.value());
     file->virtual_path = virtual_path;
     file->is_directory = file_info.is_directory;
     file->absolute_path = local_path;
     return true;
   }
 
   ExtensionTaskExecutor* executor_;
   scoped_refptr<fileapi::FileSystemContext> file_system_context_handler_;
   scoped_refptr<const Extension> handler_extension_;
   int handler_pid_;
   std::string action_id_;
-  std::vector<GURL> origin_file_urls_;
+  std::vector<FileSystemURL> urls_;
   DISALLOW_COPY_AND_ASSIGN(ExecuteTasksFileSystemCallbackDispatcher);
 };
 
 ExtensionTaskExecutor::ExtensionTaskExecutor(
     Profile* profile,
     const GURL& source_url,
     const std::string& file_browser_id,
     int tab_id,
     const std::string& extension_id,
     const std::string& action_id)
     : FileTaskExecutor(profile, source_url, file_browser_id, extension_id),
       tab_id_(tab_id),
       action_id_(action_id) {
 }
 
 ExtensionTaskExecutor::~ExtensionTaskExecutor() {}
 
 bool ExtensionTaskExecutor::ExecuteAndNotify(
-    const std::vector<GURL>& file_urls,
+    const std::vector<FileSystemURL>& file_urls,
     const FileTaskFinishedCallback& done) {
   if (!FileBrowserHasAccessPermissionForFiles(file_urls))
     return false;
 
   scoped_refptr<const Extension> handler = GetExtension();
   if (!handler.get())
     return false;
 
   int handler_pid = ExtractProcessFromExtensionId(profile(), handler->id());
   if (handler_pid <= 0) {
@@ skipping 23 matching lines @@
           handler_pid,
           file_urls));
   return true;
 }
 
 void ExtensionTaskExecutor::RequestFileEntryOnFileThread(
     scoped_refptr<fileapi::FileSystemContext> file_system_context_handler,
     const GURL& handler_base_url,
     const scoped_refptr<const Extension>& handler,
     int handler_pid,
-    const std::vector<GURL>& file_urls) {
+    const std::vector<FileSystemURL>& file_urls) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   GURL origin_url = handler_base_url.GetOrigin();
   file_system_context_handler->OpenFileSystem(
       origin_url, fileapi::kFileSystemTypeExternal, false, // create
       ExecuteTasksFileSystemCallbackDispatcher::CreateCallback(
           this,
           file_system_context_handler,
           handler,
           handler_pid,
           action_id_,
@@ skipping 120 matching lines @@
     const std::string& file_browser_id,
     const std::string& extension_id,
     const std::string& action_id)
     : FileTaskExecutor(profile, source_url, file_browser_id, extension_id),
       action_id_(action_id) {
 }
 
 WebIntentTaskExecutor::~WebIntentTaskExecutor() {}
 
 bool WebIntentTaskExecutor::ExecuteAndNotify(
-    const std::vector<GURL>& file_urls,
+    const std::vector<FileSystemURL>& file_urls,
     const FileTaskFinishedCallback& done) {
   if (!FileBrowserHasAccessPermissionForFiles(file_urls))
     return false;
 
   for (size_t i = 0; i != file_urls.size(); ++i) {
-    fileapi::FileSystemURL url(file_urls[i]);
     extensions::LaunchPlatformAppWithPath(profile(), GetExtension(),
-                                          url.path());
+                                          file_urls[i].path());
   }
 
   if (!done.is_null())
     done.Run(true);
 
   return true;
 }
 
 AppTaskExecutor::AppTaskExecutor(
     Profile* profile,
     const GURL& source_url,
     const std::string& file_browser_id,
     const std::string& extension_id,
     const std::string& action_id)
     : FileTaskExecutor(profile, source_url, file_browser_id,  extension_id),
       action_id_(action_id) {
 }
 
 AppTaskExecutor::~AppTaskExecutor() {}
 
 bool AppTaskExecutor::ExecuteAndNotify(
-    const std::vector<GURL>& file_urls,
+    const std::vector<FileSystemURL>& file_urls,
     const FileTaskFinishedCallback& done) {
   if (!FileBrowserHasAccessPermissionForFiles(file_urls))
     return false;
 
   for (size_t i = 0; i != file_urls.size(); ++i) {
-    fileapi::FileSystemURL url(file_urls[i]);
     extensions::LaunchPlatformAppWithFileHandler(profile(), GetExtension(),
-        action_id_, url.path());
+        action_id_, file_urls[i].path());
   }
 
   if (!done.is_null())
     done.Run(true);
-
   return true;
 }
 
 } // namespace file_handler_util