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 28 matching lines @@
            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) {
+                                            const std::string& action_id,
+                                            TaskType task_type) {
+  if (task_type == TASK_WEBINTENT)
+    return kReadOnlyFilePermissions;
+
   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());
-}
-
-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;
+  DCHECK(task_type == TASK_FILE
+      || task_type == TASK_DRIVE
+      || task_type == TASK_WEBINTENT);
+  return base::StringPrintf("%s|%d|%s",

[tbarzic, 2012/09/11 02:01:40]

I'd rather make task_type string (or, if you keep integers, add a comment in
TaskType enum that order of enum values cannot change)

[thorogood, 2012/09/13 02:34:49]

I agree with you. I've updated this CL with all the other suggestions, and I'll
ping it again when I've converted this to a string.

[thorogood, 2012/09/19 07:07:17]

just updating this as Done :)

+                            extension_id.c_str(),
+                            task_type,
+                            action_id.c_str());
 }
 
 // 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)
+  if (count != 3)

[tbarzic, 2012/09/11 02:01:40]

Since task ids are persisted in prefs, we should probably keep supporting old
style task ids (at least for a while)

[thorogood, 2012/09/13 02:34:49]

Sounds good. If we see two components I'll try to parse out the Drive/File
intent that was previously contained.

     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
+        || *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 81 matching lines @@
   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;
 
   ExtensionTaskExecutor(Profile* profile,
                         const GURL source_url,
                         const std::string& extension_id,
+                        TaskType task_type,
                         const std::string& action_id);
   virtual ~ExtensionTaskExecutor();
 
   struct FileDefinition {
     FileDefinition();
     ~FileDefinition();
 
     GURL target_file_url;
     FilePath virtual_path;
     FilePath absolute_path;
@@ skipping 18 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_;
+  TaskType task_type_;
   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_;
 };
 
 // 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)) {
+  if (task_type == TASK_DRIVE) {
     return new gdata::DriveTaskExecutor(profile,
                                         extension_id, // really app_id
                                         action_id);
   } else {
     return new ExtensionTaskExecutor(profile,
                                      source_url,
                                      extension_id,
+                                     task_type,
                                      action_id);
   }
 }
 
 FileTaskExecutor::FileTaskExecutor(Profile* profile) : profile_(profile) {
 }
 
 FileTaskExecutor::~FileTaskExecutor() {
 }
 
@@ skipping 167 matching lines @@
   int handler_pid_;
   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,
+    TaskType task_type,
     const std::string& action_id)
   : FileTaskExecutor(profile),
     source_url_(source_url),
     extension_id_(extension_id),
+    task_type_(task_type),
     action_id_(action_id) {
 }
 
 ExtensionTaskExecutor::~ExtensionTaskExecutor() {}
 
 bool ExtensionTaskExecutor::ExecuteAndNotify(
     const std::vector<GURL>& file_urls,
     const FileTaskFinishedCallback& done) {
   ExtensionService* service = profile()->GetExtensionService();
   if (!service)
@@ skipping 73 matching lines @@
 
   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 36 matching lines @@
     int handler_pid_in,
     extensions::ExtensionHost* host) {
   int handler_pid = host ? host->render_process_host()->GetID() :
                            handler_pid_in;
 
   if (handler_pid <= 0) {
     ExecuteDoneOnUIThread(false);
     return;
   }
 
+  // If we're a Web Intent action (to an extension), short-circuit and deliver
+  // the Web Intent via LaunchPlatformAppWithPath.
+  if (task_type_ == TASK_WEBINTENT) {
+    for (FileDefinitionList::const_iterator iter = file_list.begin();

[tbarzic, 2012/09/11 02:01:40]

why don't you create a separate executor for intents.. looks like you don't need
the most of the stuff handled in ExtensionTaskExecutor (opening external file
system, granting file access permissions and waking up lazy background page,
dispatching task event).
afaik, LaunchPlatformAppWihtPath does all of this for the web intent (correct me
if I'm wrong :) )

(the extension only needs access to isolated file system, right?)

[thorogood, 2012/09/13 02:34:49]

Yup. You're totally right. This is much more concise now, thanks for the
suggestion.

+         iter != file_list.end(); ++iter) {
+      extensions::LaunchPlatformAppWithPath(
+          profile(), GetExtension(), iter->absolute_path);
+    }
+    ExecuteDoneOnUIThread(true);
+    return;
+  }
+  DCHECK_EQ(task_type_, TASK_FILE);
+
   extensions::EventRouter* event_router = profile()->GetExtensionEventRouter();
   if (!event_router) {
     ExecuteDoneOnUIThread(false);
     return;
   }
 
   SetupHandlerHostFileAccessPermissions(handler_pid);
 
   scoped_ptr<ListValue> event_args(new ListValue());
   event_args->Append(Value::CreateStringValue(action_id_));
@@ skipping 26 matching lines @@
 
   event_router->DispatchEventToExtension(
       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,
+        GetAccessPermissionsForHandler(handler_extension,
+                                       action_id_,
+                                       task_type_)));
 
     if (gdata::util::IsUnderGDataMountPoint(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 13 matching lines @@
         handler_pid,
         handler_host_permissions_[i].first,
         handler_host_permissions_[i].second);
   }
 
   // We don't need this anymore.
   handler_host_permissions_.clear();
 }
 
 } // namespace file_handler_util