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 <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/disks/disk_mount_manager.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_service_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/pref_names.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;
@@ skipping 172 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;
 }
 
+typedef std::vector<webkit_glue::WebIntentServiceData> ServiceList;
+
+// Returns the set of Web Intent actions for which the given |mime_type| is
+// allowed.
+std::set<std::string> ActionsForType(const std::string& mime_type,
+    const ServiceList& services) {
+  std::set<std::string> actions;
+  for (ServiceList::const_iterator i = services.begin();
+       i != services.end(); ++i) {
+    if (net::MatchesMimeType(UTF16ToUTF8(i->type), mime_type))
+      actions.insert(UTF16ToUTF8(i->action));
+  }
+  return actions;
+}
+
+// Given an extension and a set of |mime_types|, return the set of Web Intent
+// actions that are supported on every type within the set. This set may be
+// empty, in which case no actions are supported.
+std::set<std::string> ActionsForExtension(const Extension* extension,
+    const std::set<std::string>& mime_types) {
+  std::set<std::string> actions;
+
+  for (std::set<std::string>::const_iterator i = mime_types.begin();
+       i != mime_types.end(); ++i) {
+    std::set<std::string> inner =
+        ActionsForType(*i, extension->intents_services());
+
+    if (i == mime_types.begin()) {
+      actions = inner;
+    } else {
+      std::set<std::string> tmp;
+      std::set_intersection(actions.begin(),
+                            actions.end(),
+                            inner.begin(),
+                            inner.end(),
+                            std::inserter(tmp, tmp.begin()));
+      actions = tmp;
+    }
+
+    if (actions.empty())
+      break;  // fall-out early, this set will never grow
+  }
+
+  return actions;
+}
+
+// Retrieves the title for the given Extension and action pair, returning true
+// if it could be found.
+bool TitleForExtensionAction(const Extension* extension,
+    const std::string& action, std::string* title) {
+  for (ServiceList::const_iterator i = extension->intents_services().begin();
+       i != extension->intents_services().end(); ++i) {
+    if (action == UTF16ToUTF8(i->action)) {
+      *title = UTF16ToUTF8(i->title);
+      return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace
 
 class RequestLocalFileSystemFunction::LocalFileSystemCallbackDispatcher {
  public:
   static fileapi::FileSystemContext::OpenFileSystemCallback CreateCallback(
       RequestLocalFileSystemFunction* function,
       scoped_refptr<fileapi::FileSystemContext> file_system_context,
       int child_id,
       scoped_refptr<const Extension> extension) {
     return base::Bind(
@@ skipping 327 matching lines @@
     return true;
 
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::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_apps;
 
   IntersectAvailableDriveTasks(registry, file_info_list,
                                &app_info, &available_apps);
   CreateDriveTasks(registry, app_info, available_apps, result_list);
 
   // We own the pointers in |app_info|, so we need to delete them.
   STLDeleteContainerPairSecondPointers(app_info.begin(), app_info.end());
   return true;
 }
 
+// Find special tasks here for Web Intent platform apps. Iterate through
+// matching apps and add them. These tasks will be identified by the "http"
+// prefix found on the task action.
+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
+                                  // 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;
+
+    // We can't use hosted apps to open files.
+    if (!extension->is_platform_app() || !extension->has_background_page())

[benwells, 2012/08/27 08:02:59]

Don't need to check for background page here, all platform apps have them.

[thorogood, 2012/08/28 00:04:04]

Done.

+      continue;
+
+    if (profile_->IsOffTheRecord() &&
+        !service->IsIncognitoEnabled(extension->id()))
+      continue;
+
+    const std::set<std::string> actions =
+        ActionsForExtension(extension, mime_types);

[benwells, 2012/08/27 08:02:59]

I should have mentioned this, but we only care about the view action, other
actions should be ignored.

[thorogood, 2012/08/28 00:04:04]

Before I make this change, can I ask why? In my mind, it makes sense to support
all possible actions on files.

[thorogood, 2012/08/29 06:34:46]

I've updated this file to work this way now. PTAL!

+    for (std::set<std::string>::iterator ai = actions.begin();
+         ai != actions.end(); ++ai) {
+      std::string title;
+      DCHECK(TitleForExtensionAction(extension, *ai, &title));
+
+      DictionaryValue* task = new DictionaryValue;
+      std::string task_id =
+          file_handler_util::MakeTaskID(extension->id(), *ai);
+      task->SetString("taskId", task_id);
+      task->SetString("title", title);
+      task->Set("patterns", new ListValue);
+
+      GURL best_icon = extension->GetIconURL(kPreferredIconSize,
+                                             ExtensionIconSet::MATCH_BIGGER);
+      task->SetString("iconUrl", best_icon.spec());
+
+      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 61 matching lines @@
 
   // Take the union of Drive and extension tasks: Because any extension tasks we
   // found must apply to all of the files (intersection), and because the same
   // is true of the drive apps, we simply take the union of two lists by adding
   // the drive tasks to the extension task list. We know there aren't duplicates
   // because they're entirely different kinds of tasks, but there could be both
   // kinds of tasks for a file type (an image file, for instance).
   if (!FindDriveAppTasks(info_list, result_list))
     return false;
 
+  // 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);
 }
 
@@ skipping 1695 matching lines @@
   gdata::GDataSystemService* system_service =
       gdata::GDataSystemServiceFactory::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;
 }