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_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"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_parser.h"
@@ skipping 16 matching lines @@
 #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 {
 
+// The default View action for Web Intents.
+const char kWebIntentViewAction[] = "http://webintents.org/view";
+
 // 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 156 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.
+bool ExtensionSupportsAction(const Extension* extension,
+    const std::string& action,
+    const std::set<std::string>& mime_types) {
+  DCHECK(!mime_types.empty());
+  std::set<std::string> pending(mime_types.begin(), mime_types.end());
+
+  for (std::vector<webkit_glue::WebIntentServiceData>::const_iterator i =
+          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()) {
+      if (net::MatchesMimeType(UTF16ToUTF8(i->type), *pi))
+        pending.erase(pi++);
+      else
+        ++pi;
+    }
+  }
+
+  return pending.empty();  // if empty, we've found all mime-types
+}
+
+// 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) {

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

I think you should pass in the mime types here and make sure the service you get
the title from matches at least one of the mime types.

Perhaps the function ExtensionSupportsAction could output a title.

[thorogood, 2012/09/01 03:02:11]

Sounds good. My original methods made more sense when this was more open-ended
to multiple intent types.

+  for (std::vector<webkit_glue::WebIntentServiceData>::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;
+}
+
 // 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 302 matching lines @@
   // 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>::iterator app_iter = available_apps.begin();
        app_iter != available_apps.end(); ++app_iter) {
     WebAppInfoMap::const_iterator info_iter = app_info.find(*app_iter);
     DCHECK(info_iter != app_info.end());
     gdata::DriveWebAppInfo* info = info_iter->second;
     DictionaryValue* task = new DictionaryValue;
     // 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(*app_iter, "open-with");
+    std::string task_id = file_handler_util::MakeTaskID(
+        *app_iter, file_handler_util::TASK_DRIVE, "open-with");
     task->SetString("taskId", task_id);
     task->SetString("title", info->app_name);
 
     // Create the list of extensions as patterns registered for this
     // application. (Extensions here refers to filename suffixes (extensions),
     // not Chrome or Drive extensions.)
     ListValue* pattern_list = new ListValue;
     std::set<std::string> extensions =
         registry->GetExtensionsForWebStoreApp(*app_iter);
     for (std::set<std::string>::iterator ext_iter = extensions.begin();
@@ skipping 23 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"

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

Is this comment still correct?

[thorogood, 2012/09/01 03:02:11]

Nope, clarified.

+// 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))

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

Should this be if (file_extension.empty || !net::.....)?

[thorogood, 2012/09/01 03:02:11]

Well, the second command should only run if the file_extension is _not_ empty.
The mime_type is empty already due to the constructor above.

The condition in here is basically just for safety: if
GetWellKnownMimeTypeFromExtension returns false, but modifies mime_type, that we
reset it.

Perhaps I'm thinking about this too much :)

+      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.

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

Hmm ... apart from it not being implemented, is there a reason why not? Maybe
this should be a TODO instead, or the comment make it clearer that this isn't a
design choice but a limitation.

As an aside, after you download a file if you have an extension installed
(hosted app or platform app) that can view the file, it should show the picker
and let you open the file in the chosen app.

[thorogood, 2012/09/01 03:02:11]

I've now said "We don't support using hosted apps to open files.".
Is there a bug to track this? :)

+    if (!extension->is_platform_app())
+      continue;
+
+    if (profile_->IsOffTheRecord() &&
+        !service->IsIncognitoEnabled(extension->id()))
+      continue;
+
+    if (!ExtensionSupportsAction(extension, kWebIntentViewAction, mime_types))
+      continue;
+
+    std::string title;
+    DCHECK(TitleForExtensionAction(extension, kWebIntentViewAction, &title));
+
+    DictionaryValue* task = new DictionaryValue;
+    std::string task_id = file_handler_util::MakeTaskID(extension->id(),
+        file_handler_util::TASK_WEBINTENT, kWebIntentViewAction);
+    task->SetString("taskId", task_id);
+    task->SetString("title", title);
+    task->Set("patterns", new ListValue);
+
+    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 36 matching lines @@
   ExtensionService* service = profile_->GetExtensionService();
   for (file_handler_util::LastUsedHandlerList::const_iterator iter =
            common_tasks.begin();
        iter != common_tasks.end();
        ++iter) {
     const FileBrowserHandler* handler = iter->handler;
     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());
     task->Set("patterns", URLPatternSetToStringList(iter->patterns));
     // 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);
     result_list->Append(task);
   }
 
   // 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);
 }
 
 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 1643 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;
 }