Add verbs API to file handlers. Modify the Chrome OS UI so that it displayes the internationalized …

chrome/browser/chromeos/file_manager/file_tasks.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/file_manager/file_tasks.h"
 
 #include <stddef.h>
 
 #include <map>
 
@@ skipping 27 matching lines @@
 #include "extensions/browser/entry_info.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_set.h"
 #include "storage/browser/fileapi/file_system_url.h"
 
 using extensions::Extension;
+using extensions::api::file_manager_private::Verb;
 using extensions::app_file_handler_util::FindFileHandlersForEntries;
 using storage::FileSystemURL;
 
 namespace file_manager {
 namespace file_tasks {
 
 namespace {
 
 // The values "file" and "app" are confusing, but cannot be changed easily as
 // these are used in default task IDs stored in preferences.
 const char kFileBrowserHandlerTaskType[] = "file";
 const char kFileHandlerTaskType[] = "app";
 const char kDriveAppTaskType[] = "drive";
 const char kArcAppTaskType[] = "arc";
 
 // Drive apps always use the action ID.
-const char kDriveAppActionID[] = "open-with";
+const char kDriveAppActionID[] = "more-actions";
 
 // Converts a TaskType to a string.
 std::string TaskTypeToString(TaskType task_type) {
   switch (task_type) {
     case TASK_TYPE_FILE_BROWSER_HANDLER:
       return kFileBrowserHandlerTaskType;
     case TASK_TYPE_FILE_HANDLER:
       return kFileHandlerTaskType;
     case TASK_TYPE_DRIVE_APP:
       return kDriveAppTaskType;
@@ skipping 93 matching lines @@
     std::unique_ptr<std::vector<FullTaskDescriptor>> result_list) {
   // Google documents can only be handled by internal handlers.
   if (ContainsGoogleDocument(entries))
     KeepOnlyFileManagerInternalTasks(result_list.get());
   ChooseAndSetDefaultTask(*profile->GetPrefs(), entries, result_list.get());
   callback.Run(std::move(result_list));
 }
 
 }  // namespace
 
-FullTaskDescriptor::FullTaskDescriptor(
-    const TaskDescriptor& task_descriptor,
-    const std::string& task_title,
-    const GURL& icon_url,
-    bool is_default,
-    bool is_generic_file_handler)
+FullTaskDescriptor::FullTaskDescriptor(const TaskDescriptor& task_descriptor,
+                                       const std::string& task_title,
+                                       const Verb& task_verb,
+                                       const GURL& icon_url,
+                                       bool is_default,
+                                       bool is_generic_file_handler)
     : task_descriptor_(task_descriptor),
       task_title_(task_title),
+      task_verb_(task_verb),
       icon_url_(icon_url),
       is_default_(is_default),
-      is_generic_file_handler_(is_generic_file_handler) {
-}
+      is_generic_file_handler_(is_generic_file_handler) {}
+
+FullTaskDescriptor::~FullTaskDescriptor() {}
 
 FullTaskDescriptor::FullTaskDescriptor(const FullTaskDescriptor& other) =
     default;
 
 void UpdateDefaultTask(PrefService* pref_service,
                        const std::string& task_id,
                        const std::set<std::string>& suffixes,
                        const std::set<std::string>& mime_types) {
   if (!pref_service)
     return;
@@ skipping 204 matching lines @@
 
   for (DriveAppInfoMap::const_iterator iter = drive_app_map.begin();
        iter != drive_app_map.end(); ++iter) {
     const drive::DriveAppInfo& app_info = iter->second;
     TaskDescriptor descriptor(app_info.app_id,
                               TASK_TYPE_DRIVE_APP,
                               kDriveAppActionID);
     GURL icon_url = drive::util::FindPreferredIcon(
         app_info.app_icons,
         drive::util::kPreferredIconSize);
-    result_list->push_back(
-        FullTaskDescriptor(descriptor,
-                           app_info.app_name,
-                           icon_url,
-                           false /* is_default */,
-                           false /* is_generic_file_handler */));
+
+    result_list->push_back(FullTaskDescriptor(
+        descriptor, app_info.app_name, Verb::VERB_OPEN_WITH, icon_url,
+        false /* is_default */, false /* is_generic_file_handler */));
   }
 }
 
 bool IsGoodMatchFileHandler(
     const extensions::FileHandlerInfo& file_handler_info,
     const std::vector<extensions::EntryInfo>& entries) {
   if (file_handler_info.extensions.count("*") > 0 ||
       file_handler_info.types.count("*") > 0 ||
       file_handler_info.types.count("*/*") > 0)
     return false;
@@ skipping 46 matching lines @@
       continue;
 
     // If the new ZIP unpacker is disabled, then hide its handlers, so we don't
     // show both the legacy one and the new one in Files app for ZIP files.
     if (extension->id() == extension_misc::kZIPUnpackerExtensionId &&
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             chromeos::switches::kDisableNewZIPUnpacker)) {
       continue;
     }
 
-    // Show the first good matching handler of each app. If there doesn't exist
-    // such handler, show the first matching handler of the app.
-    const extensions::FileHandlerInfo* file_handler = file_handlers.front();
-    for (auto handler : file_handlers) {
-      if (IsGoodMatchFileHandler(*handler, entries)) {
-        file_handler = handler;
-        break;
+    // A map which has as key a handler verb, and as value a pair of the
+    // handler with which to open the given entries and a boolean marking
+    // if the handler is a good match.
+    std::map<std::string, std::pair<const extensions::FileHandlerInfo*, bool>>
+        handlers_for_entries;
+    // Show the first good matching handler of each verb supporting the given
+    // entries that corresponds to the app. If there doesn't exist such handler,
+    // show the first matching handler of the verb.
+    for (const extensions::FileHandlerInfo* handler : file_handlers) {
+      bool good_match = IsGoodMatchFileHandler(*handler, entries);
+      auto it = handlers_for_entries.find(handler->verb);
+      if (it == handlers_for_entries.end() ||
+          (!it->second.second /* existing handler not a good match */ &&
+           good_match)) {
+        handlers_for_entries[handler->verb] =
+            std::make_pair(handler, good_match);
       }
     }
 
-    std::string task_id = file_tasks::MakeTaskID(
-        extension->id(), file_tasks::TASK_TYPE_FILE_HANDLER, file_handler->id);
+    for (const auto& entry : handlers_for_entries) {
+      const extensions::FileHandlerInfo* handler = entry.second.first;
+      std::string task_id = file_tasks::MakeTaskID(
+          extension->id(), file_tasks::TASK_TYPE_FILE_HANDLER, handler->id);
 
-    GURL best_icon = extensions::ExtensionIconSource::GetIconURL(
-        extension,
-        drive::util::kPreferredIconSize,
-        ExtensionIconSet::MATCH_BIGGER,
-        false,  // grayscale
-        NULL);  // exists
+      GURL best_icon = extensions::ExtensionIconSource::GetIconURL(
+          extension, drive::util::kPreferredIconSize,
+          ExtensionIconSet::MATCH_BIGGER,
+          false,  // grayscale
+          NULL);  // exists
 
-    // If file handler doesn't match as good match, regards it as generic file
-    // handler.
-    const bool is_generic_file_handler =
-        !IsGoodMatchFileHandler(*file_handler, entries);
-    result_list->push_back(FullTaskDescriptor(
-        TaskDescriptor(extension->id(), file_tasks::TASK_TYPE_FILE_HANDLER,
-                       file_handler->id),
-        extension->name(), best_icon, false /* is_default */,
-        is_generic_file_handler));
+      // If file handler doesn't match as good match, regards it as generic file
+      // handler.
+      const bool is_generic_file_handler =
+          !IsGoodMatchFileHandler(*handler, entries);
+      Verb verb;
+      if (handler->verb == extensions::file_handler_verbs::kAddTo) {
+        verb = Verb::VERB_ADD_TO;
+      } else if (handler->verb == extensions::file_handler_verbs::kPackWith) {
+        verb = Verb::VERB_PACK_WITH;
+      } else {
+        // Only kOpenWith is a valid remaining verb. Invalid verbs should fall
+        // back to it.
+        DCHECK(handler->verb == extensions::file_handler_verbs::kOpenWith);
+        verb = Verb::VERB_OPEN_WITH;
+      }
+
+      result_list->push_back(FullTaskDescriptor(
+          TaskDescriptor(extension->id(), file_tasks::TASK_TYPE_FILE_HANDLER,
+                         handler->id),
+          extension->name(), verb, best_icon, false /* is_default */,
+          is_generic_file_handler));
+    }
   }
 }
 
 void FindFileBrowserHandlerTasks(
     Profile* profile,
     const std::vector<GURL>& file_urls,
     std::vector<FullTaskDescriptor>* result_list) {
   DCHECK(!file_urls.empty());
   DCHECK(result_list);
 
@@ skipping 16 matching lines @@
     // TODO(zelidrag): Figure out how to expose icon URL that task defined in
     // manifest instead of the default extension icon.
     const GURL icon_url = extensions::ExtensionIconSource::GetIconURL(
         extension,
         extension_misc::EXTENSION_ICON_BITTY,
         ExtensionIconSet::MATCH_BIGGER,
         false,  // grayscale
         NULL);  // exists
 
     result_list->push_back(FullTaskDescriptor(
-        TaskDescriptor(extension_id,
-                       file_tasks::TASK_TYPE_FILE_BROWSER_HANDLER,
+        TaskDescriptor(extension_id, file_tasks::TASK_TYPE_FILE_BROWSER_HANDLER,
                        handler->id()),
-        handler->title(),
-        icon_url,
-        false /* is_default */,
-        false /* is_generic_file_handler */));
+        handler->title(), Verb::VERB_NONE /* no verb for FileBrowserHandler */,
+        icon_url, false /* is_default */, false /* is_generic_file_handler */));
   }
 }
 
 void FindAllTypesOfTasks(Profile* profile,
                          const drive::DriveAppRegistry* drive_app_registry,
                          const std::vector<extensions::EntryInfo>& entries,
                          const std::vector<GURL>& file_urls,
                          const FindTasksCallback& callback) {
   DCHECK(profile);
   std::unique_ptr<std::vector<FullTaskDescriptor>> result_list(
@@ skipping 51 matching lines @@
     DCHECK(!task->is_default());
     if (IsFallbackFileHandler(task->task_descriptor())) {
       task->set_is_default(true);
       return;
     }
   }
 }
 
 }  // namespace file_tasks
 }  // namespace file_manager