Chrome OS "open with" picker allowing Web Intents

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/statvfs.h>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/i18n/case_conversion.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/singleton.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/values.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/extensions/file_handler_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system_util.h"
 #include "chrome/browser/chromeos/gdata/drive_service_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_system_service.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_parser.h"
 #include "chrome/browser/chromeos/gdata/operation_registry.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/process_map.h"
+#include "chrome/browser/intents/web_intents_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/views/select_file_dialog_extension.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "grit/platform_locale_settings.h"
 #include "net/base/escape.h"
+#include "net/base/mime_util.h"
 #include "ui/base/dialogs/selected_file_info.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/glue/web_intent_service_data.h"
 
 using chromeos::disks::DiskMountManager;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 using file_handler_util::FileTaskExecutor;
 using gdata::InstalledApp;
 using gdata::OperationRegistry;
 
 namespace {
 
 // Default icon path for drive docs.
-const char kDefaultDriveIcon[] = "images/filetype_generic.png";
+const char kDefaultIcon[] = "images/filetype_generic.png";
 const int kPreferredIconSize = 16;
 
 // Error messages.
 const char kFileError[] = "File error %d";
 const char kInvalidFileUrl[] = "Invalid file URL";
 const char kVolumeDevicePathNotFound[] = "Device path not found";
 
 // Unescape rules used for parsing query parameters.
 const net::UnescapeRule::Type kUnescapeRuleForQueryParameters =
     net::UnescapeRule::SPACES |
@@ skipping 136 matching lines @@
   if (icons.empty())
     return result;
   result = icons.rbegin()->second;
   for (InstalledApp::IconList::const_reverse_iterator iter = icons.rbegin();
        iter != icons.rend() && iter->first >= preferred_size; ++iter) {
         result = iter->second;
   }
   return result;
 }
 
+// Given an extension, a Web Intents |action|, and a set of |mime_types|,
+// determines whether this extension supports this action for all specified
+// mime-types.
+// If this method returns true, also returns the |title| of this action.

[tbarzic, 2012/09/13 04:29:17]

why not add function std::string GetTitleForAction()
that will return the title of the first intents_service (or first non empty
title,, in case it can be ''). 

[thorogood, 2012/09/13 08:14:04]

I actually started with that, and benwells@ suggested rolling it into this
method. I feel like this approach is fine.

[benwells, 2012/09/13 09:52:30]

Either way you have to handle the case where an extension has multiple view
actions for different mime types, with different titles. In this case you need
to look at the mime types you're handling to pick the right title. If there are
multiple mime types being handled there might be multiple possible titles, but
you should always pick a valid one.

[tbarzic, 2012/09/13 18:44:45]

yeah, makes sense..
I missed continue part in the for loop when I was writing the comment.

Still, I think it would be clearer if we avoided having function that does two
things.. but, do as you like :)

You should probably reflect in the function name that it also returns action
title..

[thorogood, 2012/09/16 03:41:18]

I've changed this method to be named "FindTitleForActionWithTypes", which I feel
is also accurate, and updated the comment. Basically you can legitimately think
of this method as finding the title of the specified action that supports these
mime-types.

Btw, interestingly enough, since Web Intents are specified as a action/spec
mapping, then there is a direct mapping between action and title. (It's just
that if an action supports multiple mime types, this is flattened in the
Extension initialisation code - so finding the "first" match is fine, since
they'll all be the same). Ben's comment is thus invalid.

I know this probably feels like bikeshedding from all directions, but given the
above paragraph, I'm happy to break this apart into two methods again if you
think it's cleaner.

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

I'm ok with this..

[benwells, 2012/09/17 01:37:23]

Ah, my bad. I'm OK with either one or two functions since the titles will all be
the same.

+bool ExtensionSupportsAction(const Extension* extension,
+    const std::string& action,
+    const std::set<std::string>& mime_types,
+    std::string* title) {
+  DCHECK(!mime_types.empty());
+  std::set<std::string> pending(mime_types.begin(), mime_types.end());
+  std::string found_title;
+
+  for (std::vector<webkit_glue::WebIntentServiceData>::const_iterator i =

[tbarzic, 2012/09/13 04:29:17]

since you have nested loops, it would probably be better if iterator names are
more descriptive.

[thorogood, 2012/09/13 08:14:04]

Done.

+          extension->intents_services().begin();
+       i != extension->intents_services().end(); ++i) {
+    if (pending.empty())
+      break;
+
+    if (UTF16ToUTF8(i->action) != action)
+      continue;
+
+    std::set<std::string>::iterator pi = pending.begin();
+    while (pi != pending.end()) {

[tbarzic, 2012/09/13 04:29:17]

how about (I think it is nicer, but your call):

std::set<std::string>::iterator current = pi++;
if (net::MatchesMime...)
  pending.erase(current);

[thorogood, 2012/09/13 08:14:04]

I like it. I'm hardly a C++ guru :)

+      if (net::MatchesMimeType(UTF16ToUTF8(i->type), *pi))
+        pending.erase(pi++);
+      else
+        ++pi;
+    }
+    if (found_title.empty())
+      found_title = UTF16ToUTF8(i->title);
+  }
+
+  if (!pending.empty())
+    return false;   // we haven't found all mime-types
+
+  *title = found_title;
+  return true;
+}
+
 // Retrieves total and remaining available size on |mount_path|.
 void GetSizeStatsOnFileThread(const std::string& mount_path,
                               size_t* total_size_kb,
                               size_t* remaining_size_kb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   uint64_t total_size_in_bytes = 0;
   uint64_t remaining_size_in_bytes = 0;
 
   struct statvfs stat = {};  // Zero-clear
@@ skipping 346 matching lines @@
                                 file_iter->mime_type, &info);
     std::vector<gdata::DriveWebAppInfo*> info_ptrs;
     info.release(&info_ptrs);  // so they don't go away prematurely.
     std::set<std::string> tasks_for_this_file;
     for (std::vector<gdata::DriveWebAppInfo*>::iterator
          apps = info_ptrs.begin(); apps != info_ptrs.end(); ++apps) {
       std::pair<WebAppInfoMap::iterator, bool> insert_result =
           app_info->insert(std::make_pair((*apps)->app_id, *apps));
       // TODO(gspencer): For now, the action id is always "open-with", but we
       // could add any actions that the drive app supports.
-      std::string task_id =
-          file_handler_util::MakeDriveTaskID((*apps)->app_id, "open-with");
+      std::string task_id = file_handler_util::MakeTaskID(
+          (*apps)->app_id, file_handler_util::TASK_DRIVE, "open-with");
       tasks_for_this_file.insert(task_id);
       // If we failed to insert a task_id because there was a duplicate, then we
       // must delete it (since we own it).
       if (!insert_result.second)
         delete *apps;
     }
     if (file_iter == file_info_list.begin()) {
       *available_tasks = tasks_for_this_file;
     } else {
       std::set<std::string> intersection;
@@ skipping 32 matching lines @@
     const std::set<std::string>& available_tasks,
     const std::set<std::string>& default_tasks,
     ListValue* result_list,
     bool* default_already_set) {
   *default_already_set = false;
   // OK, now we traverse the intersection of available applications for this
   // list of files, adding a task for each one that is found.
   for (std::set<std::string>::const_iterator app_iter = available_tasks.begin();
        app_iter != available_tasks.end(); ++app_iter) {
     std::string app_id;
-    bool result = file_handler_util::CrackDriveTaskID(*app_iter, &app_id, NULL);
+    file_handler_util::TaskType task_type;
+    bool result = file_handler_util::CrackTaskID(
+        *app_iter, &app_id, &task_type, NULL);
     DCHECK(result) << "Unable to parse Drive task id: " << *app_iter;
-    if (!result)
+    DCHECK_EQ(task_type, file_handler_util::TASK_DRIVE)

[tbarzic, 2012/09/13 04:29:17]

I don't think the log adds extra value to the check..

[thorogood, 2012/09/13 08:14:04]

Done.

+        << "Expected Drive task type";
+    if (!result || task_type != file_handler_util::TASK_DRIVE)

[tbarzic, 2012/09/13 04:29:17]

you have a dcheck for (task_type == TASK_DRIVE), so you shouldn't handle the
case task_type != TASK_DRIVE...

[thorogood, 2012/09/13 08:14:04]

Well, before I got here, there was also a DCHECK for calling CrackDriveTaskID.
This if statement was also here before, and is just sanity for production code.

[tbarzic, 2012/09/13 18:44:45]

yeah, but the thing is DCHECK contradicts the need to handle failure case. So
you should either remove if() or DCHECK.
(in this case, tasks in available_tasks are created by MakeDriveTaskID (see
IntersectAvaliableDriveTasks) just before calling this function, so I would go
with keeping DCHECKs)

[thorogood, 2012/09/16 03:41:18]

Fair enough. I think I assumed that this might be somehow unsanitised data, but
you're right here. I'll remove the if in favour of DCHECKs.

       continue;
     WebAppInfoMap::const_iterator info_iter = app_info.find(app_id);
     DCHECK(info_iter != app_info.end());
     gdata::DriveWebAppInfo* info = info_iter->second;
     DictionaryValue* task = new DictionaryValue;
 
     task->SetString("taskId", *app_iter);
     task->SetString("title", info->app_name);
 
     GURL best_icon = FindPreferredIcon(info->app_icons,
@@ skipping 28 matching lines @@
     return true;
 
   gdata::DriveSystemService* system_service =
       gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   // |system_service| is NULL if incognito window / guest login. We return true
   // in this case because there might be other extension tasks, even if we don't
   // have any to add.
   if (!system_service || !system_service->webapps_registry())
     return true;
 
-
   gdata::DriveWebAppsRegistry* registry = system_service->webapps_registry();
 
   // Map of app_id to DriveWebAppInfo so we can look up the apps we've found
   // after taking the intersection of available apps.
   std::map<std::string, gdata::DriveWebAppInfo*> app_info;
   // Set of application IDs. This will end up with the intersection of the
   // application IDs that apply to the paths in |file_paths|.
   std::set<std::string> available_tasks;
 
   IntersectAvailableDriveTasks(registry, file_info_list,
                                &app_info, &available_tasks);
   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;
 }
 
+// Find Web Intent platform apps that support the View task, and add them to
+// the |result_list|. These will be marked as TASK_WEBINTENT.
+bool GetFileTasksFileBrowserFunction::FindWebIntentTasks(
+    const std::vector<GURL>& file_urls,
+    ListValue* result_list) {
+  DCHECK(!file_urls.empty());
+  ExtensionService* service = profile_->GetExtensionService();
+  if (!service)
+    return false;
+
+  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))
+      mime_type = std::string();  // There was no mime-type available from this

[tbarzic, 2012/09/13 04:29:17]

does this mean that std::string() is used to represent "*" matcher?

[thorogood, 2012/09/13 08:14:04]

Almost. You're the wrong way around; this says that if the file doesn't have an
extension (or we can't find it's mime-type) then we say the file has a mime type
of "", which is only supported if the Web Intents handler is "*" or "*/*".

[tbarzic, 2012/09/13 18:44:45]

oh, could you please clarify this in the comment.

also nits:
could you put the comment in the line before |mime_type = std::string()|

please add { } for the if block

[thorogood, 2012/09/16 03:41:18]

I've made these changes and made this a bit clearer with an if/else block.

+                                  // file, but we'll still match "*".
+    mime_types.insert(mime_type);
+  }
+
+  for (ExtensionSet::const_iterator iter = service->extensions()->begin();
+       iter != service->extensions()->end();
+       ++iter) {
+    const Extension* extension = *iter;
+    std::string title;
+
+    // We don't support using hosted apps to open files.
+    if (!extension->is_platform_app())
+      continue;
+
+    if (profile_->IsOffTheRecord() &&
+        !service->IsIncognitoEnabled(extension->id()))
+      continue;
+
+    if (!ExtensionSupportsAction(
+        extension, web_intents::kActionView, mime_types, &title))
+      continue;
+
+    DictionaryValue* task = new DictionaryValue;
+    std::string task_id = file_handler_util::MakeTaskID(extension->id(),
+        file_handler_util::TASK_WEBINTENT, web_intents::kActionView);
+    task->SetString("taskId", task_id);
+    task->SetString("title", title);
+    task->SetBoolean("isDefault", false);
+
+    GURL best_icon = extension->GetIconURL(kPreferredIconSize,
+                                           ExtensionIconSet::MATCH_BIGGER);
+    if (!best_icon.is_empty())
+      task->SetString("iconUrl", best_icon.spec());
+    else
+      task->SetString("iconUrl", kDefaultIcon);
+
+    task->SetBoolean("driveApp", false);
+    result_list->Append(task);
+  }
+
+  return true;
+}
+
 bool GetFileTasksFileBrowserFunction::RunImpl() {
   // First argument is the list of files to get tasks for.
   ListValue* files_list = NULL;
   if (!args_->GetList(0, &files_list))
     return false;
 
   // 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;
@@ skipping 49 matching lines @@
   ExtensionService* service = profile_->GetExtensionService();
   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();
     const Extension* extension = service->GetExtensionById(extension_id, false);
     CHECK(extension);
     DictionaryValue* task = new DictionaryValue;
-    task->SetString("taskId",
-        file_handler_util::MakeTaskID(extension_id, handler->id()));
+    task->SetString("taskId", file_handler_util::MakeTaskID(
+        extension_id, file_handler_util::TASK_FILE, handler->id()));
     task->SetString("title", handler->title());
     // TODO(zelidrag): Figure out how to expose icon URL that task defined in
     // manifest instead of the default extension icon.
     GURL icon =
         ExtensionIconSource::GetIconURL(extension,
                                         extension_misc::EXTENSION_ICON_BITTY,
                                         ExtensionIconSet::MATCH_BIGGER,
                                         false, NULL);     // grayscale
     task->SetString("iconUrl", icon.spec());
     task->SetBoolean("driveApp", false);
 
     // Only set the default if there isn't already a default set.
     if (!default_already_set &&
         default_tasks.find(*iter) != default_tasks.end()) {
       task->SetBoolean("isDefault", true);
       default_already_set = true;
     } else {
       task->SetBoolean("isDefault", false);
     }
 
     result_list->Append(task);
   }
 
+  // Take the union of 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 (!FindWebIntentTasks(file_urls, 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;
   }
 
-  // TODO(zelidrag, serya): Add intent content tasks to result_list once we
-  // implement that API.
   SendResponse(true);
   return true;
 }
 
 ExecuteTasksFileBrowserFunction::ExecuteTasksFileBrowserFunction() {}
 
 void ExecuteTasksFileBrowserFunction::OnTaskExecuted(bool success) {
   SendResponse(success);
 }
 
 ExecuteTasksFileBrowserFunction::~ExecuteTasksFileBrowserFunction() {}
 
 bool ExecuteTasksFileBrowserFunction::RunImpl() {
   // First param is task id that was to the extension with getFileTasks call.
   std::string task_id;
   if (!args_->GetString(0, &task_id) || !task_id.size())
     return false;
 
   // TODO(kaznacheev): Crack the task_id here, store it in the Executor
   // and avoid passing it around.
 
   // The second param is the list of files that need to be executed with this
   // task.
   ListValue* files_list = NULL;
   if (!args_->GetList(1, &files_list))
     return false;
 
   std::string extension_id;
+  file_handler_util::TaskType task_type;
   std::string action_id;
-  if (!file_handler_util::CrackTaskID(task_id, &extension_id, &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;
   for (size_t i = 0; i < files_list->GetSize(); i++) {
     std::string origin_file_url;
     if (!files_list->GetString(i, &origin_file_url)) {
       error_ = kInvalidFileUrl;
       return false;
     }
     file_urls.push_back(GURL(origin_file_url));
   }
 
   scoped_refptr<FileTaskExecutor> executor(
       FileTaskExecutor::Create(profile(),
                                source_url(),
                                extension_id,
+                               task_type,
                                action_id));
 
   if (!executor->ExecuteAndNotify(
       file_urls,
       base::Bind(&ExecuteTasksFileBrowserFunction::OnTaskExecuted, this)))
     return false;
 
   SetResult(new base::FundamentalValue(true));
   return true;
 }
@@ skipping 1111 matching lines @@
   // Get drive WebApps that can accept this file.
   ScopedVector<gdata::DriveWebAppInfo> web_apps;
   system_service->webapps_registry()->GetWebAppsForFile(
           file_path, file_specific_info.content_mime_type(), &web_apps);
   if (!web_apps.empty()) {
     std::string default_task_id = file_handler_util::GetDefaultTaskIdFromPrefs(
         profile_,
         file_specific_info.content_mime_type(),
         file_path.Extension());
     std::string default_app_id;
-    file_handler_util::CrackDriveTaskID(default_task_id, &default_app_id, NULL);
+    file_handler_util::CrackTaskID(
+        default_task_id, &default_app_id, NULL, NULL);
 
     ListValue* apps = new ListValue();
     property_dict->Set("driveApps", apps);
     for (ScopedVector<gdata::DriveWebAppInfo>::const_iterator it =
              web_apps.begin();
          it != web_apps.end(); ++it) {
       const gdata::DriveWebAppInfo* webapp_info = *it;
       DictionaryValue* app = new DictionaryValue();
       app->SetString("appId", webapp_info->app_id);
       app->SetString("appName", webapp_info->app_name);
@@ skipping 567 matching lines @@
   gdata::DriveSystemService* system_service =
       gdata::DriveSystemServiceFactory::GetForProfile(profile_);
   if (!system_service || !system_service->file_system())
     return false;
 
   FilePath directory_path = GetVirtualPathFromURL(GURL(file_url_as_string));
   system_service->file_system()->RequestDirectoryRefresh(directory_path);
 
   return true;
 }