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

chrome/browser/chromeos/file_manager/file_tasks_unittest.cc

 // Copyright 2013 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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 15 matching lines @@
 #include "components/prefs/testing_pref_service.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/entry_info.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension_builder.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
+using extensions::api::file_manager_private::Verb;
+
 namespace file_manager {
 namespace file_tasks {
 namespace {
 
 // Registers the default task preferences. Used for testing
 // ChooseAndSetDefaultTask().
 void RegisterDefaultTaskPreferences(TestingPrefServiceSimple* pref_service) {
   DCHECK(pref_service);
 
   pref_service->registry()->RegisterDictionaryPref(
@@ skipping 11 matching lines @@
 
   pref_service->Set(prefs::kDefaultTasksByMimeType, mime_types);
   pref_service->Set(prefs::kDefaultTasksBySuffix, suffixes);
 }
 
 }  // namespace
 
 TEST(FileManagerFileTasksTest,
      FullTaskDescriptor_NonDriveAppWithIconAndDefault) {
   FullTaskDescriptor full_descriptor(
-      TaskDescriptor("app-id",
-                     TASK_TYPE_FILE_BROWSER_HANDLER,
-                     "action-id"),
-      "task title",
-      GURL("http://example.com/icon.png"),
-      true /* is_default */,
-      false /* is_generic_file_handler */);
+      TaskDescriptor("app-id", TASK_TYPE_FILE_BROWSER_HANDLER, "action-id"),
+      "task title", Verb::VERB_OPEN_WITH, GURL("http://example.com/icon.png"),
+      true /* is_default */, false /* is_generic_file_handler */);
 
   const std::string task_id =
       TaskDescriptorToId(full_descriptor.task_descriptor());
   EXPECT_EQ("app-id|file|action-id", task_id);
   EXPECT_EQ("http://example.com/icon.png", full_descriptor.icon_url().spec());
   EXPECT_EQ("task title", full_descriptor.task_title());
+  EXPECT_EQ(Verb::VERB_OPEN_WITH, full_descriptor.task_verb());
   EXPECT_TRUE(full_descriptor.is_default());
 }
 
 TEST(FileManagerFileTasksTest,
      FullTaskDescriptor_DriveAppWithoutIconAndNotDefault) {
   FullTaskDescriptor full_descriptor(
-      TaskDescriptor("app-id",
-                     TASK_TYPE_DRIVE_APP,
-                     "action-id"),
-      "task title",
+      TaskDescriptor("app-id", TASK_TYPE_DRIVE_APP, "action-id"), "task title",
+      Verb::VERB_OPEN_WITH,
       GURL(),  // No icon URL.
-      false /* is_default */,
-      false /* is_generic_file_handler */);
+      false /* is_default */, false /* is_generic_file_handler */);
 
   const std::string task_id =
       TaskDescriptorToId(full_descriptor.task_descriptor());
   EXPECT_EQ("app-id|drive|action-id", task_id);
   EXPECT_TRUE(full_descriptor.icon_url().is_empty());
   EXPECT_EQ("task title", full_descriptor.task_title());
+  EXPECT_EQ(Verb::VERB_OPEN_WITH, full_descriptor.task_verb());
   EXPECT_FALSE(full_descriptor.is_default());
 }
 
 TEST(FileManagerFileTasksTest, MakeTaskID) {
   EXPECT_EQ("app-id|file|action-id",
             MakeTaskID("app-id", TASK_TYPE_FILE_BROWSER_HANDLER, "action-id"));
   EXPECT_EQ("app-id|app|action-id",
             MakeTaskID("app-id", TASK_TYPE_FILE_HANDLER, "action-id"));
   EXPECT_EQ("app-id|drive|action-id",
             MakeTaskID("app-id", TASK_TYPE_DRIVE_APP, "action-id"));
@@ skipping 146 matching lines @@
 
   // Text.app and Nice.app were found for "foo.txt".
   TaskDescriptor text_app_task("text-app-id",
                                TASK_TYPE_FILE_HANDLER,
                                "action-id");
   TaskDescriptor nice_app_task("nice-app-id",
                                TASK_TYPE_FILE_HANDLER,
                                "action-id");
   std::vector<FullTaskDescriptor> tasks;
   tasks.push_back(FullTaskDescriptor(
-      text_app_task,
-      "Text.app",
-      GURL("http://example.com/text_app.png"),
-      false /* is_default */,
+      text_app_task, "Text.app", Verb::VERB_OPEN_WITH,
+      GURL("http://example.com/text_app.png"), false /* is_default */,
       false /* is_generic_file_handler */));
   tasks.push_back(FullTaskDescriptor(
-      nice_app_task,
-      "Nice.app",
-      GURL("http://example.com/nice_app.png"),
-      false /* is_default */,
+      nice_app_task, "Nice.app", Verb::VERB_ADD_TO,
+      GURL("http://example.com/nice_app.png"), false /* is_default */,
       false /* is_generic_file_handler */));
   std::vector<extensions::EntryInfo> entries;
   entries.push_back(extensions::EntryInfo(
       base::FilePath::FromUTF8Unsafe("foo.txt"), "text/plain", false));
 
   // None of them should be chosen as default, as nothing is set in the
   // preferences.
   ChooseAndSetDefaultTask(pref_service, entries, &tasks);
   EXPECT_FALSE(tasks[0].is_default());
   EXPECT_FALSE(tasks[1].is_default());
@@ skipping 38 matching lines @@
 TEST(FileManagerFileTasksTest, ChooseAndSetDefaultTask_FallbackFileBrowser) {
   TestingPrefServiceSimple pref_service;
   RegisterDefaultTaskPreferences(&pref_service);
 
   // Files.app's internal file browser handler was found for "foo.txt".
   TaskDescriptor files_app_task(kFileManagerAppId,
                                 TASK_TYPE_FILE_BROWSER_HANDLER,
                                 "view-in-browser");
   std::vector<FullTaskDescriptor> tasks;
   tasks.push_back(FullTaskDescriptor(
-      files_app_task,
-      "View in browser",
-      GURL("http://example.com/some_icon.png"),
-      false /* is_default */,
+      files_app_task, "View in browser", Verb::VERB_OPEN_WITH,
+      GURL("http://example.com/some_icon.png"), false /* is_default */,
       false /* is_generic_file_handler */));
   std::vector<extensions::EntryInfo> entries;
   entries.push_back(extensions::EntryInfo(
       base::FilePath::FromUTF8Unsafe("foo.txt"), "text/plain", false));
 
   // The internal file browser handler should be chosen as default, as it's a
   // fallback file browser handler.
   ChooseAndSetDefaultTask(pref_service, entries, &tasks);
   EXPECT_TRUE(tasks[0].is_default());
 }
@@ skipping 702 matching lines @@
       drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII("dir"),
       "", true));
   std::vector<FullTaskDescriptor> dir_result;
   FindFileHandlerTasks(&test_profile_, dir_entries, &dir_result);
   ASSERT_EQ(1U, dir_result.size());
   // Confirm that only Bar.app is found and that it is a generic file handler.
   EXPECT_EQ(kBarId, dir_result[0].task_descriptor().app_id);
   EXPECT_TRUE(dir_result[0].is_generic_file_handler());
 }
 
+// The basic logic is similar to a test case for FindDriveAppTasks above.
+TEST_F(FileManagerFileTasksComplexTest, FindFileHandlerTask_Verbs) {
+  // kFooId copied from FindFileHandlerTasks test above.
+  const char kFooId[] = "hhgbjpmdppecanaaogonaigmmifgpaph";
+
+  // Foo.app can handle "text/plain" and "text/html".
+  extensions::ExtensionBuilder foo_app;
+  foo_app.SetManifest(
+      extensions::DictionaryBuilder()
+          .Set("name", "Foo")
+          .Set("version", "1.0.0")
+          .Set("manifest_version", 2)
+          .Set("app", extensions::DictionaryBuilder()
+                          .Set("background",
+                               extensions::DictionaryBuilder()
+                                   .Set("scripts", extensions::ListBuilder()
+                                                       .Append("background.js")
+                                                       .Build())
+                                   .Build())
+                          .Build())
+          .Set(
+              "file_handlers",
+              extensions::DictionaryBuilder()
+                  .Set("any",
+                       extensions::DictionaryBuilder()
+                           .Set("types",
+                                extensions::ListBuilder().Append("*").Build())
+                           .Set("verb", "add_to")
+                           .Build())
+                  .Set("any_with_directories",
+                       extensions::DictionaryBuilder()
+                           .SetBoolean("include_directories", true)
+                           .Set("types",
+                                extensions::ListBuilder().Append("*").Build())
+                           .Set("verb", "pack_with")
+                           .Build())
+                  .Set("all_text", extensions::DictionaryBuilder()
+                                       .Set("title", "Text")
+                                       .Set("types", extensions::ListBuilder()
+                                                         .Append("text/plain")
+                                                         .Append("text/html")
+                                                         .Build())
+                                       .Set("verb", "add_to")
+                                       .Build())
+                  .Set("plain_text", extensions::DictionaryBuilder()
+                                         .Set("title", "Plain")
+                                         .Set("types", extensions::ListBuilder()
+                                                           .Append("text/plain")
+                                                           .Build())
+                                         .Set("verb", "open_with")
+                                         .Build())
+                  .Set("html_text_duplicate_verb",
+                       extensions::DictionaryBuilder()
+                           .Set("title", "Html")
+                           .Set("types", extensions::ListBuilder()
+                                             .Append("text/html")
+                                             .Build())
+                           .Set("verb", "add_to")
+                           .Build())
+                  .Set("share_plain_text",
+                       extensions::DictionaryBuilder()
+                           .Set("title", "Share Plain")
+                           .Set("types", extensions::ListBuilder()
+                                             .Append("text/plain")
+                                             .Build())
+                           .Set("verb", "share_with")
+                           .Build())
+                  .Build())
+          .Build());
+  foo_app.SetID(kFooId);
+  extension_service_->AddExtension(foo_app.Build().get());
+
+  // Find app with corresponding verbs for a "text/plain" file.
+  // Foo.app with ADD_TO, OPEN_WITH, PACK_WITH and SHARE_WITH should be found,
+  // but only one ADD_TO that is not a generic handler will be taken into
+  // account, even though there are 2 ADD_TO matches for "text/plain".
+  std::vector<extensions::EntryInfo> entries;
+  entries.push_back(
+      extensions::EntryInfo(drive::util::GetDriveMountPointPath(&test_profile_)
+                                .AppendASCII("foo.txt"),
+                            "text/plain", false));
+
+  std::vector<FullTaskDescriptor> tasks;
+  FindFileHandlerTasks(&test_profile_, entries, &tasks);
+
+  ASSERT_EQ(4U, tasks.size());
+  EXPECT_EQ(kFooId, tasks[0].task_descriptor().app_id);
+  EXPECT_EQ("Foo", tasks[0].task_title());
+  EXPECT_EQ(Verb::VERB_ADD_TO, tasks[0].task_verb());
+  EXPECT_EQ(kFooId, tasks[1].task_descriptor().app_id);
+  EXPECT_EQ("Foo", tasks[1].task_title());
+  EXPECT_EQ(Verb::VERB_OPEN_WITH, tasks[1].task_verb());
+  EXPECT_EQ(kFooId, tasks[2].task_descriptor().app_id);
+  EXPECT_EQ("Foo", tasks[2].task_title());
+  EXPECT_EQ(Verb::VERB_PACK_WITH, tasks[2].task_verb());
+  EXPECT_EQ(kFooId, tasks[3].task_descriptor().app_id);
+  EXPECT_EQ("Foo", tasks[3].task_title());
+  EXPECT_EQ(Verb::VERB_SHARE_WITH, tasks[3].task_verb());
+
+  // Find app with corresponding verbs for a "text/html" file.
+  // Foo.app with ADD_TO and PACK_WITH should be found, but only the first
+  // ADD_TO that is a good match will be taken into account, even though there
+  // are 3 ADD_TO matches for "text/html".
+  entries.clear();
+  entries.push_back(
+      extensions::EntryInfo(drive::util::GetDriveMountPointPath(&test_profile_)
+                                .AppendASCII("foo.html"),
+                            "text/html", false));
+  tasks.clear();
+  FindFileHandlerTasks(&test_profile_, entries, &tasks);
+
+  ASSERT_EQ(2U, tasks.size());
+  EXPECT_EQ(kFooId, tasks[0].task_descriptor().app_id);
+  EXPECT_EQ("Foo", tasks[0].task_title());
+  EXPECT_EQ(Verb::VERB_ADD_TO, tasks[0].task_verb());
+  EXPECT_EQ(kFooId, tasks[1].task_descriptor().app_id);
+  EXPECT_EQ("Foo", tasks[1].task_title());
+  EXPECT_EQ(Verb::VERB_PACK_WITH, tasks[1].task_verb());
+
+  // Find app with corresponding verbs for directories.
+  // Foo.app with only PACK_WITH should be found.
+  entries.clear();
+  entries.push_back(extensions::EntryInfo(
+      drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII("dir"),
+      "", true));
+  tasks.clear();
+  FindFileHandlerTasks(&test_profile_, entries, &tasks);
+
+  ASSERT_EQ(1U, tasks.size());
+  EXPECT_EQ(kFooId, tasks[0].task_descriptor().app_id);
+  EXPECT_EQ("Foo", tasks[0].task_title());
+  EXPECT_EQ(Verb::VERB_PACK_WITH, tasks[0].task_verb());
+}
+
 }  // namespace file_tasks
 }  // namespace file_manager.