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/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager_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 {
 
 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 |
                                       base::PLATFORM_FILE_EXCLUSIVE_READ |
@@ skipping 47 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 34 matching lines @@
                                  const LastUsedHandler& b) {
   return a.timestamp > b.timestamp;
 }
 
 // TODO(zelidrag): Wire this with ICU to make this sort I18N happy.
 bool SortByTaskName(const LastUsedHandler& a, const LastUsedHandler& b) {
   return base::strcasecmp(a.handler->title().c_str(),
                           b.handler->title().c_str()) > 0;
 }
 
+// Does this LastUsedHandlerList contain entries with only a common timestamp?
+bool HasCommonTimestamp(LastUsedHandlerList* list) {

[benwells, 2012/08/30 08:09:03]

Now I understand. Can you rename this to AllHaveSameTimestamp (or something), I
previously assumed from the name it was returning true if any of the list shared
a common timestamp.

[thorogood, 2012/08/31 01:27:32]

Done.

+  DCHECK(!list->empty());
+  int common_timestamp = list->begin()->timestamp;
+  for (LastUsedHandlerList::const_iterator iter = list->begin() + 1;
+       iter != list->end(); ++iter) {
+    if (common_timestamp != iter->timestamp)
+      return false;
+  }
+  return true;
+}
+
 void SortLastUsedHandlerList(LastUsedHandlerList *list) {
-  // Sort by the last used descending.
-  std::sort(list->begin(), list->end(), SortByLastUsedTimestampDesc);
-  if (list->size() > 1) {
-    // Sort the rest by name.
+  // If we've got one element or fewer, the list is already sorted. If the
+  // handlers have a common timestamp (e.g., if no handlers have ever been
+  // invoked), just sort by name. Otherwise, bring the last used handler to
+  // the front and sort the rest by name.
+  if (list->size() <= 1) {
+    // do nothing
+  } else if (HasCommonTimestamp(list)) {
+    std::sort(list->begin(), list->end(), SortByTaskName);
+  } else {
+    std::sort(list->begin(), list->end(), SortByLastUsedTimestampDesc);
     std::sort(list->begin() + 1, list->end(), SortByTaskName);
   }
 }
 
 }  // namespace
 
 // Update file handler usage stats.
 void UpdateFileHandlerUsageStats(Profile* profile, const std::string& task_id) {
   if (!profile || !profile->GetPrefs())
     return;
   DictionaryPrefUpdate prefs_usage_update(profile->GetPrefs(),
       prefs::kLastUsedFileBrowserHandlers);
   prefs_usage_update->SetWithoutPathExpansion(task_id,
       new base::FundamentalValue(
           static_cast<int>(base::Time::Now().ToInternalValue()/
                            base::Time::kMicrosecondsPerSecond)));
 }
 
 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
+      || task_type == TASK_WEBINTENT);
+
+  std::string out = base::StringPrintf("%s|%d|%s",
+                            extension_id.c_str(),
+                            task_type,
+                            action_id.c_str());
+
+  LOG(INFO) << "Made task_id=" << out

[benwells, 2012/08/30 08:09:03]

Make this VLOG(1) (then it will only show up with verbose logging enabled). Same
in CrackTaskID below.

[thorogood, 2012/08/31 01:27:32]

Removed actually. Was just for testing.

+            << ", ext=" << extension_id
+            << ", type=" << task_type
+            << ", action=" << action_id;
+
+  return out;
 }
 
-std::string MakeDriveTaskID(const std::string& app_id,
-                            const std::string& action_id) {
-  return MakeTaskID(FileTaskExecutor::kDriveTaskExtensionPrefix + app_id,
-                    action_id);
-}
-
-
 // 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>
 // Currently, the only supported task-type is of 'context'.
 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)
     return false;
   *extension_id = result[0];
-  *action_id = result[1];
+
+  *task_type = file_handler_util::TaskType(atoi(result[1].c_str()));
+  DCHECK(*task_type == TASK_FILE
+      || *task_type == TASK_DRIVE
+      || *task_type == TASK_WEBINTENT);
+
+  *action_id = result[2];
+
+  LOG(INFO) << "Cracked task_id=" << task_id
+            << ", ext=" << *extension_id
+            << ", type=" << *task_type
+            << ", action=" << *action_id;
+
   return true;
 }
 
 // Find a specific handler in the handler list.
 LastUsedHandlerList::iterator FindHandler(
     LastUsedHandlerList* list,
     const std::string& extension_id,
     const std::string& id) {
   LastUsedHandlerList::iterator iter = list->begin();
   while (iter != list->end() &&
          !(iter->handler->extension_id() == extension_id &&
            iter->handler->id() == id)) {
     iter++;
   }
   return iter;
 }
 
-// Given the list of selected files, returns array of context menu tasks
-// that are shared
+// Given the list of selected files, returns array of file action tasks
+// that are shared between them.
 bool FindCommonTasks(Profile* profile,
                      const std::vector<GURL>& files_list,
                      LastUsedHandlerList* named_action_list) {
   named_action_list->clear();
   ActionSet common_tasks;
   for (std::vector<GURL>::const_iterator it = files_list.begin();
        it != files_list.end(); ++it) {
     ActionSet file_actions;
     if (!GetFileBrowserHandlers(profile, *it, &file_actions))
       return false;
@@ skipping 24 matching lines @@
   for (ActionSet::const_iterator iter = common_tasks.begin();
        iter != common_tasks.end(); ++iter) {
     // Get timestamp of when this task was used last time.
     int last_used_timestamp = 0;
 
     if ((*iter)->extension_id() == kFileBrowserDomain) {
       // Give a little bump to the action from File Browser extension
       // to make sure it is the default on a fresh profile.
       last_used_timestamp = 1;
     }
-    prefs_tasks->GetInteger(MakeTaskID((*iter)->extension_id(), (*iter)->id()),
+    prefs_tasks->GetInteger(MakeTaskID((*iter)->extension_id(),
+                            TASK_FILE,
+                            (*iter)->id()),
                             &last_used_timestamp);
     URLPatternSet matching_patterns = GetAllMatchingPatterns(*iter, files_list);
     named_action_list->push_back(LastUsedHandler(last_used_timestamp, *iter,
                                                  matching_patterns));
   }
 
   LastUsedHandlerList::iterator watch_iter = FindHandler(
       named_action_list, kFileBrowserDomain, kFileBrowserWatchTaskId);
   LastUsedHandlerList::iterator gallery_iter = FindHandler(
       named_action_list, kFileBrowserDomain, kFileBrowserGalleryTaskId);
@@ skipping 36 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 173 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();
+         iter != file_list.end(); ++iter) {
+      extensions::LaunchPlatformAppWithPath(
+          profile(), GetExtension(), iter->absolute_path);
+    }
+    ExecuteDoneOnUIThread(true);
+    return;
+  }
+  DCHECK(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