Chrome OS "open with" picker allowing Web Intents

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"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system_util.h"
 #include "chrome/browser/chromeos/gdata/drive_task_executor.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
+#include "chrome/browser/extensions/platform_app_launcher.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/escape.h"
 #include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
 #include "webkit/fileapi/file_system_context.h"
 #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;
 
 namespace file_handler_util {
 
-// The prefix used to differentiate drive extensions from Chrome extensions.
-const char FileTaskExecutor::kDriveTaskExtensionPrefix[] = "drive-app:";
-const size_t FileTaskExecutor::kDriveTaskExtensionPrefixLength =
-    arraysize(FileTaskExecutor::kDriveTaskExtensionPrefix) - 1;
-
 namespace {
 typedef std::set<const FileBrowserHandler*> FileBrowserHandlerSet;
 
 const int kReadWriteFilePermissions = base::PLATFORM_FILE_OPEN |
                                       base::PLATFORM_FILE_CREATE |
                                       base::PLATFORM_FILE_OPEN_ALWAYS |
                                       base::PLATFORM_FILE_CREATE_ALWAYS |
                                       base::PLATFORM_FILE_OPEN_TRUNCATED |
                                       base::PLATFORM_FILE_READ |
                                       base::PLATFORM_FILE_WRITE |
@@ skipping 39 matching lines @@
   for (Extension::FileBrowserHandlerList::const_iterator action_iter =
            extension->file_browser_handlers()->begin();
        action_iter != extension->file_browser_handlers()->end();
        ++action_iter) {
     if (action_iter->get()->id() == action_id)
       return action_iter->get();
   }
   return NULL;
 }
 
-unsigned int GetAccessPermissionsForHandler(const Extension* extension,
-                                            const std::string& action_id) {
+unsigned int GetAccessPermissionsForFileBrowserHandler(
+    const Extension* extension,
+    const std::string& action_id) {
   const FileBrowserHandler* action =
       FindFileBrowserHandler(extension, action_id);
   if (!action)
     return 0;
   unsigned int result = 0;
   if (action->CanRead())
     result |= kReadOnlyFilePermissions;
   if (action->CanWrite())
     result |= kReadWriteFilePermissions;
   // TODO(tbarzic): We don't handle Create yet.
   return result;
 }
 
-
 std::string EscapedUtf8ToLower(const std::string& str) {
   string16 utf16 = UTF8ToUTF16(
       net::UnescapeURLComponent(str, net::UnescapeRule::NORMAL));
   return net::EscapeUrlEncodedData(
       UTF16ToUTF8(base::i18n::ToLower(utf16)),
       false /* do not replace space with plus */);
 }
 
 bool GetFileBrowserHandlers(Profile* profile,
                             const GURL& selected_file_url,
@@ skipping 97 matching lines @@
 
 int GetReadWritePermissions() {
   return kReadWriteFilePermissions;
 }
 
 int GetReadOnlyPermissions() {
   return kReadOnlyFilePermissions;
 }
 
 std::string MakeTaskID(const std::string& extension_id,
+                       TaskType task_type,
                        const std::string& action_id) {
-  return base::StringPrintf("%s|%s", extension_id.c_str(), action_id.c_str());
+  DCHECK(task_type == TASK_FILE
+      || task_type == TASK_DRIVE

[tbarzic, 2012/09/16 04:26:11]

nit:
|| should be at the end of the previous line.

[thorogood, 2012/09/18 02:13:02]

Done.

+      || task_type == TASK_WEBINTENT);
+  return base::StringPrintf("%s|%d|%s",
+                            extension_id.c_str(),
+                            task_type,
+                            action_id.c_str());
 }
 
-std::string MakeDriveTaskID(const std::string& app_id,
-                            const std::string& action_id) {
-  return MakeTaskID(FileTaskExecutor::kDriveTaskExtensionPrefix + app_id,
-                    action_id);
-}
-
-bool CrackDriveTaskID(const std::string& task_id,
-                      std::string* app_id,
-                      std::string* action_id) {
-  std::string app_id_tmp;
-  std::string action_id_tmp;
-  if (!CrackTaskID(task_id, &app_id_tmp, &action_id_tmp))
-    return false;
-  if (StartsWithASCII(app_id_tmp,
-                      FileTaskExecutor::kDriveTaskExtensionPrefix,
-                      false)) {
-    // Strip off the prefix from the extension ID so we convert it to an app id.
-    if (app_id) {
-      *app_id = app_id_tmp.substr(
-          FileTaskExecutor::kDriveTaskExtensionPrefixLength);
-    }
-    if (action_id)
-      *action_id = action_id_tmp;
-    return true;
-  }
-  return false;
-}
+const char kDriveTaskExtensionPrefix[] = "drive-app:";
+const size_t kDriveTaskExtensionPrefixLength =

[tbarzic, 2012/09/16 04:26:11]

should these go in anonymous namespace?

[thorogood, 2012/09/18 02:13:02]

Done.

+    arraysize(kDriveTaskExtensionPrefix) - 1;
 
 // Breaks down task_id that is used between getFileTasks() and executeTask() on
 // its building blocks. task_id field the following structure:
-//     <extension-id>|<task-action-id>
+//     <extension-id>|<task-type>|<task-action-id>
 bool CrackTaskID(const std::string& task_id,
                  std::string* extension_id,
+                 TaskType* task_type,
                  std::string* action_id) {
   std::vector<std::string> result;
   int count = Tokenize(task_id, std::string("|"), &result);
-  if (count != 2)
+
+  // Parse historic task_id parameters that only contain two parts. Drive tasks
+  // are identified by a prefix "drive-app:" on the extension ID.
+  if (count == 2) {
+    if (StartsWithASCII(result[0], kDriveTaskExtensionPrefix, true)) {
+      if (task_type)
+        *task_type = TASK_DRIVE;
+
+      if (extension_id)
+        *extension_id = result[0].substr(kDriveTaskExtensionPrefixLength);
+    } else {
+      if (task_type)
+        *task_type = TASK_FILE;
+
+      if (extension_id)
+        *extension_id = result[0];
+    }
+
+    if (action_id)
+      *action_id = result[1];
+
+    return true;
+  }
+
+  if (count != 3)
     return false;
+
   if (extension_id)
     *extension_id = result[0];
+
+  if (task_type) {
+    *task_type = file_handler_util::TaskType(atoi(result[1].c_str()));
+    DCHECK(*task_type == TASK_FILE
+        || *task_type == TASK_DRIVE

[tbarzic, 2012/09/16 04:26:11]

nit:
|| should go at the end of previous line

[thorogood, 2012/09/18 02:13:02]

Done.

+        || *task_type == TASK_WEBINTENT);
+  }
+
   if (action_id)
-    *action_id = result[1];
+    *action_id = result[2];
+
   return true;
 }
 
 // Find a specific handler in the handler list.
 FileBrowserHandlerSet::iterator FindHandler(
     FileBrowserHandlerSet* handler_set,
     const std::string& extension_id,
     const std::string& id) {
   FileBrowserHandlerSet::iterator iter = handler_set->begin();
   while (iter != handler_set->end() &&
          !((*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 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();
        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);
     }
   }
 
   // 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(),
+    std::string task_id = MakeTaskID((*task_iter)->extension_id(), TASK_FILE,
                                      (*task_iter)->id());
     for (std::set<std::string>::iterator default_iter = default_ids.begin();
          default_iter != default_ids.end(); ++default_iter) {
       if (task_id == *default_iter) {
         default_tasks->insert(*task_iter);
         break;
       }
     }
   }
 }
@@ skipping 134 matching lines @@
                                         const GURL& file_system_root,
                                         const FileDefinitionList& file_list,
                                         int handler_pid_in,
                                         extensions::ExtensionHost* host);
 
   // Populates |handler_host_permissions| with file path-permissions pairs that
   // will be given to the handler extension host process.
   void InitHandlerHostFileAccessPermissions(
       const FileDefinitionList& file_list,
       const extensions::Extension* handler_extension,
-      const std::string& action_id,
       const base::Closure& callback);
 
   // Invoked upon completion of InitHandlerHostFileAccessPermissions initiated
   // by ExecuteFileActionsOnUIThread.
   void OnInitAccessForExecuteFileActionsOnUIThread(
       const std::string& file_system_name,
       const GURL& file_system_root,
       const FileDefinitionList& file_list,
       int handler_pid);
 
   // Registers file permissions from |handler_host_permissions_| with
   // ChildProcessSecurityPolicy for process with id |handler_pid|.
   void SetupHandlerHostFileAccessPermissions(int handler_pid);
 
-  // Helper function to get the extension pointer.
-  const extensions::Extension* GetExtension();
-
   const GURL source_url_;
-  const std::string extension_id_;
   const std::string action_id_;
   FileTaskFinishedCallback done_;
 
   // (File path, permission for file path) pairs for the handler.
   std::vector<std::pair<FilePath, int> > handler_host_permissions_;
 };
 
+class WebIntentTaskExecutor : public FileTaskExecutor {
+ public:
+  // FileTaskExecutor overrides.
+  virtual bool ExecuteAndNotify(const std::vector<GURL>& 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& extension_id,
+                        const std::string& action_id);
+  virtual ~WebIntentTaskExecutor();
+
+  bool ExecuteForURL(const GURL& file_url);
+
+  const GURL source_url_;
+  const std::string extension_id_;
+  const std::string action_id_;
+};
+
 // static
 FileTaskExecutor* FileTaskExecutor::Create(Profile* profile,
                                            const GURL source_url,
                                            const std::string& extension_id,
+                                           TaskType task_type,
                                            const std::string& action_id) {
-  // Check out the extension ID and see if this is a drive task,
-  // and instantiate drive-specific executor if so.
-  if (StartsWithASCII(extension_id,
-                      FileTaskExecutor::kDriveTaskExtensionPrefix,
-                      false)) {
-    return new gdata::DriveTaskExecutor(profile,
-                                        extension_id, // really app_id
-                                        action_id);
-  } else {
-    return new ExtensionTaskExecutor(profile,
-                                     source_url,
-                                     extension_id,
-                                     action_id);
+  switch (task_type) {
+    case TASK_DRIVE:
+      return new gdata::DriveTaskExecutor(profile,
+                                          extension_id, // really app_id

[tbarzic, 2012/09/16 04:26:11]

nit:
two spaces before //

[thorogood, 2012/09/18 02:13:02]

Done.

+                                          action_id);
+    case TASK_WEBINTENT:
+      return new WebIntentTaskExecutor(profile,
+                                       source_url,
+                                       extension_id,
+                                       action_id);
+    case TASK_FILE:
+      return new ExtensionTaskExecutor(profile,
+                                       source_url,
+                                       extension_id,
+                                       action_id);
+    default:
+      NOTREACHED();
+      return NULL;
+      // TODO: bigger explosion than this

[tbarzic, 2012/09/16 04:26:11]

nit: '.' at the end.

[thorogood, 2012/09/18 02:13:02]

I've removed this TODO. It was just a note for me, mostly. I think the
NOTREACHED check is fine since the data should be sanitised at this point.

The alternative check is to handle NULL where we use this call, and make the API
call fail.

[tbarzic, 2012/09/18 03:21:57]

this looks ok

   }
 }
 
-FileTaskExecutor::FileTaskExecutor(Profile* profile) : profile_(profile) {
+FileTaskExecutor::FileTaskExecutor(
+    Profile* profile,
+    const std::string& extension_id)
+  : profile_(profile),
+    extension_id_(extension_id) {
 }
 
 FileTaskExecutor::~FileTaskExecutor() {
 }
 
 bool FileTaskExecutor::Execute(const std::vector<GURL>& file_urls) {
   return ExecuteAndNotify(file_urls, FileTaskFinishedCallback());
 }
 
 Browser* FileTaskExecutor::GetBrowser() const {
   return browser::FindOrCreateTabbedBrowser(
       profile_ ? profile_ : ProfileManager::GetDefaultProfileOrOffTheRecord());
 }
 
+const Extension* FileTaskExecutor::GetExtension() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  ExtensionService* service = profile()->GetExtensionService();
+  return service ? service->GetExtensionById(extension_id_, false) :
+                   NULL;
+}
+
 ExtensionTaskExecutor::FileDefinition::FileDefinition() : is_directory(false) {
 }
 
 ExtensionTaskExecutor::FileDefinition::~FileDefinition() {
 }
 
 class ExtensionTaskExecutor::ExecuteTasksFileSystemCallbackDispatcher {
  public:
   static fileapi::FileSystemContext::OpenFileSystemCallback CreateCallback(
       ExtensionTaskExecutor* executor,
@@ skipping 149 matching lines @@
   std::string action_id_;
   std::vector<GURL> origin_file_urls_;
   DISALLOW_COPY_AND_ASSIGN(ExecuteTasksFileSystemCallbackDispatcher);
 };
 
 ExtensionTaskExecutor::ExtensionTaskExecutor(
     Profile* profile,
     const GURL source_url,
     const std::string& extension_id,
     const std::string& action_id)
-  : FileTaskExecutor(profile),
+  : FileTaskExecutor(profile, extension_id),
     source_url_(source_url),
-    extension_id_(extension_id),
     action_id_(action_id) {
 }
 
 ExtensionTaskExecutor::~ExtensionTaskExecutor() {}
 
 bool ExtensionTaskExecutor::ExecuteAndNotify(
     const std::vector<GURL>& file_urls,
     const FileTaskFinishedCallback& done) {
-  ExtensionService* service = profile()->GetExtensionService();
-  if (!service)
-    return false;
-
-  scoped_refptr<const Extension> handler =
-      service->GetExtensionById(extension_id_, false);
+  scoped_refptr<const Extension> handler = GetExtension();
 
   if (!handler.get())
     return false;
 
   int handler_pid = ExtractProcessFromExtensionId(handler->id(), profile());
   if (handler_pid <= 0) {
     if (!handler->has_lazy_background_page())
       return false;
   }
 
@@ skipping 35 matching lines @@
           file_urls));
 }
 
 void ExtensionTaskExecutor::ExecuteDoneOnUIThread(bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!done_.is_null())
     done_.Run(success);
   done_.Reset();
 }
 
-const Extension* ExtensionTaskExecutor::GetExtension() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  ExtensionService* service = profile()->GetExtensionService();
-  return service ? service->GetExtensionById(extension_id_, false) :
-                   NULL;
-}
-
 void ExtensionTaskExecutor::ExecuteFileActionsOnUIThread(
     const std::string& file_system_name,
     const GURL& file_system_root,
     const FileDefinitionList& file_list,
     int handler_pid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const Extension* extension = GetExtension();
   if (!extension) {
     ExecuteDoneOnUIThread(false);
     return;
   }
 
   InitHandlerHostFileAccessPermissions(
       file_list,
       extension,
-      action_id_,
       base::Bind(
           &ExtensionTaskExecutor::OnInitAccessForExecuteFileActionsOnUIThread,
           this,
           file_system_name,
           file_system_root,
           file_list,
           handler_pid));
 }
 
 void ExtensionTaskExecutor::OnInitAccessForExecuteFileActionsOnUIThread(
@@ skipping 15 matching lines @@
   } else {
     // We have to wake the handler background page before we proceed.
     extensions::LazyBackgroundTaskQueue* queue =
         extensions::ExtensionSystem::Get(profile())->
         lazy_background_task_queue();
     if (!queue->ShouldEnqueueTask(profile(), extension)) {
       ExecuteDoneOnUIThread(false);
       return;
     }
     queue->AddPendingTask(
-        profile(), extension_id_,
+        profile(), extension_id(),
         base::Bind(&ExtensionTaskExecutor::SetupPermissionsAndDispatchEvent,
                    this, file_system_name, file_system_root, file_list,
                    handler_pid));
   }
 }
 
 void ExtensionTaskExecutor::SetupPermissionsAndDispatchEvent(
     const std::string& file_system_name,
     const GURL& file_system_root,
     const FileDefinitionList& file_list,
@@ skipping 38 matching lines @@
 
   // Get tab id.
   Browser* current_browser = GetBrowser();
   if (current_browser) {
     WebContents* contents = chrome::GetActiveWebContents(current_browser);
     if (contents)
       details->SetInteger("tab_id", ExtensionTabUtil::GetTabId(contents));
   }
 
   event_router->DispatchEventToExtension(
-      extension_id_, std::string("fileBrowserHandler.onExecute"),
+      extension_id(), std::string("fileBrowserHandler.onExecute"),
       event_args.Pass(), profile(), GURL());
   ExecuteDoneOnUIThread(true);
 }
 
 void ExtensionTaskExecutor::InitHandlerHostFileAccessPermissions(
     const FileDefinitionList& file_list,
     const Extension* handler_extension,
-    const std::string& action_id,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<std::vector<FilePath> > gdata_paths(new std::vector<FilePath>);
   for (FileDefinitionList::const_iterator iter = file_list.begin();
        iter != file_list.end();
        ++iter) {
     // Setup permission for file's absolute file.
-    handler_host_permissions_.push_back(std::make_pair(
-        iter->absolute_path,
-        GetAccessPermissionsForHandler(handler_extension, action_id)));
+    handler_host_permissions_.push_back(std::make_pair(iter->absolute_path,
+        GetAccessPermissionsForFileBrowserHandler(handler_extension,
+                                                  action_id_)));
 
     if (gdata::util::IsUnderDriveMountPoint(iter->absolute_path))
       gdata_paths->push_back(iter->virtual_path);
   }
 
   if (gdata_paths->empty()) {
     // Invoke callback if none of the files are on gdata mount point.
     callback.Run();
     return;
   }
@@ skipping 12 matching lines @@
     content::ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
         handler_pid,
         handler_host_permissions_[i].first,
         handler_host_permissions_[i].second);
   }
 
   // We don't need this anymore.
   handler_host_permissions_.clear();
 }
 
+WebIntentTaskExecutor::WebIntentTaskExecutor(
+    Profile* profile,
+    const GURL source_url,
+    const std::string& extension_id,
+    const std::string& action_id)
+  : FileTaskExecutor(profile, extension_id),
+    source_url_(source_url),
+    action_id_(action_id) {
+}
+
+WebIntentTaskExecutor::~WebIntentTaskExecutor() {}
+
+bool WebIntentTaskExecutor::ExecuteAndNotify(
+    const std::vector<GURL>& file_urls,
+    const FileTaskFinishedCallback& done) {
+  bool success = true;
+
+  for (std::vector<GURL>::const_iterator i = file_urls.begin();
+       i != file_urls.end(); ++i) {
+    if (!ExecuteForURL(*i))
+      success = false;
+  }
+
+  if (!done.is_null())
+    done.Run(success);
+
+  return true;
+}
+
+bool WebIntentTaskExecutor::ExecuteForURL(const GURL& file_url) {
+  fileapi::FileSystemURL url(file_url);
+  if (!chromeos::CrosMountPointProvider::CanHandleURL(url))
+    return false;
+
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetFileSystemContext(profile());
+  fileapi::ExternalFileSystemMountPointProvider* external_provider =
+      file_system_context->external_provider();
+  if (!external_provider || !external_provider->IsAccessAllowed(url))
+    return false;
+
+  // Make sure this url really being used by the right caller extension.
+  if (source_url_.GetOrigin() != url.origin())
+    return false;
+
+  FilePath local_path = url.path();
+  extensions::LaunchPlatformAppWithPath(profile(), GetExtension(), local_path);
+  return true;
+}
+
 } // namespace file_handler_util