Add isGenericFileHandler property to FileTask.

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 <utility>
 
 #include "base/command_line.h"
@@ skipping 47 matching lines @@
 }  // 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 */);
+      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_TRUE(full_descriptor.is_default());
 }
 
 TEST(FileManagerFileTasksTest,
      FullTaskDescriptor_DriveAppWithoutIconAndNotDefault) {
   FullTaskDescriptor full_descriptor(
       TaskDescriptor("app-id",
                      TASK_TYPE_DRIVE_APP,
                      "action-id"),
       "task title",
       GURL(),  // No icon URL.
-      false /* is_default */);
+      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_FALSE(full_descriptor.is_default());
 }
 
 TEST(FileManagerFileTasksTest, MakeTaskID) {
@@ skipping 163 matching lines @@
                                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 */));
+      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 */));
+      false /* is_default */,
+      false /* is_generic_file_handler */));
   PathAndMimeTypeSet path_mime_set;
   path_mime_set.insert(std::make_pair(
       base::FilePath::FromUTF8Unsafe("foo.txt"),
       "text/plain"));
 
   // None of them should be chosen as default, as nothing is set in the
   // preferences.
   ChooseAndSetDefaultTask(pref_service, path_mime_set, &tasks);
   EXPECT_FALSE(tasks[0].is_default());
   EXPECT_FALSE(tasks[1].is_default());
@@ skipping 41 matching lines @@
 
   // 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 */));
+      false /* is_default */,
+      false /* is_generic_file_handler */));
   PathAndMimeTypeSet path_mime_set;
   path_mime_set.insert(std::make_pair(
       base::FilePath::FromUTF8Unsafe("foo.txt"),
       "text/plain"));
 
   // The internal file browser handler should be chosen as default, as it's a
   // fallback file browser handler.
   ChooseAndSetDefaultTask(pref_service, path_mime_set, &tasks);
   EXPECT_TRUE(tasks[0].is_default());
 }
 
+// Test IsGenericFileHandler which returns whether a file handle info is a
+// generic file handler or not.
+TEST(FileManagerFileTasksTest, IsGenericFileHandler) {
+  using FileHandlerInfo = extensions::FileHandlerInfo;
+
+  // extensions: ["*"]
+  FileHandlerInfo file_handler_info_1;
+  file_handler_info_1.extensions.insert("*");
+  EXPECT_TRUE(IsGenericFileHandler(file_handler_info_1));
+
+  // extensions: ["*", "jpg"]
+  FileHandlerInfo file_handler_info_2;
+  file_handler_info_2.extensions.insert("*");
+  file_handler_info_2.extensions.insert("jpg");
+  EXPECT_TRUE(IsGenericFileHandler(file_handler_info_2));
+
+  // extensions: ["jpg"]
+  FileHandlerInfo file_handler_info_3;
+  file_handler_info_3.extensions.insert("jpg");
+  EXPECT_FALSE(IsGenericFileHandler(file_handler_info_3));
+
+  // types: ["*"]
+  FileHandlerInfo file_handler_info_4;
+  file_handler_info_4.types.insert("*");
+  EXPECT_TRUE(IsGenericFileHandler(file_handler_info_4));
+
+  // types: ["*/*"]
+  FileHandlerInfo file_handler_info_5;
+  file_handler_info_5.types.insert("*/*");
+  EXPECT_TRUE(IsGenericFileHandler(file_handler_info_5));
+
+  // types: ["image/*"]
+  FileHandlerInfo file_handler_info_6;
+  file_handler_info_6.types.insert("image/*");
+  // Partial wild card is not generic.
+  EXPECT_FALSE(IsGenericFileHandler(file_handler_info_6));
+
+  // types: ["*", "image/*"]
+  FileHandlerInfo file_handler_info_7;
+  file_handler_info_7.types.insert("*");
+  file_handler_info_7.types.insert("image/*");
+  EXPECT_TRUE(IsGenericFileHandler(file_handler_info_7));
+
+  // extensions: ["*"], types: ["image/*"]
+  FileHandlerInfo file_handler_info_8;
+  file_handler_info_8.extensions.insert("*");
+  file_handler_info_8.types.insert("image/*");
+  EXPECT_TRUE(IsGenericFileHandler(file_handler_info_8));
+}
+
 // Test using the test extension system, which needs lots of setup.
 class FileManagerFileTasksComplexTest : public testing::Test {
  protected:
   FileManagerFileTasksComplexTest()
       : command_line_(CommandLine::NO_PROGRAM),
         extension_service_(NULL) {
     extensions::TestExtensionSystem* test_extension_system =
         static_cast<extensions::TestExtensionSystem*>(
             extensions::ExtensionSystem::Get(&test_profile_));
     extension_service_ = test_extension_system->CreateExtensionService(
@@ skipping 428 matching lines @@
   std::vector<FullTaskDescriptor> tasks;
   FindAllTypesOfTasks(&test_profile_,
                       &drive_app_registry,
                       path_mime_set,
                       file_urls,
                       &tasks);
   ASSERT_EQ(1U, tasks.size());
   EXPECT_EQ(kFileManagerAppId, tasks[0].task_descriptor().app_id);
 }
 
+TEST_F(FileManagerFileTasksComplexTest, FindFileHandlerTask_Generic) {
+  // Since we want to keep the order of the result as foo,bar,baz,qux,
+  // keep the ids in alphabetical order.
+  const char kFooId[] = "hhgbjpmdppecanaaogonaigmmifgpaph";
+  const char kBarId[] = "odlhccgofgkadkkhcmhgnhgahonahoca";
+  const char kBazId[] = "plifkpkakemokpflgbnnigcoldgcbdmc";
+  const char kQuxId[] = "pmifkpkakgkadkkhcmhgnigmmifgpaph";
+
+  // Foo app provides file handler for text/plain and all file types.
+  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"))))
+                      .Set("file_handlers",
+                           extensions::DictionaryBuilder()
+                           .Set("any",
+                                extensions::DictionaryBuilder()
+                                .Set("types", extensions::ListBuilder()
+                                     .Append("*/*")))
+                           .Set("text",
+                                extensions::DictionaryBuilder()
+                                .Set("types", extensions::ListBuilder()
+                                     .Append("text/plain")))));
+  foo_app.SetID(kFooId);
+  extension_service_->AddExtension(foo_app.Build().get());
+
+  // Bar app provides file handler for .txt and not provide generic file
+  // handler.
+  extensions::ExtensionBuilder bar_app;
+  bar_app.SetManifest(extensions::DictionaryBuilder()
+                      .Set("name", "Bar")
+                      .Set("version", "1.0.0")
+                      .Set("manifest_version", 2)
+                      .Set("app", extensions::DictionaryBuilder()
+                           .Set("background", extensions::DictionaryBuilder()
+                                .Set("scripts", extensions::ListBuilder()
+                                    .Append("background.js"))))
+                      .Set("file_handlers",
+                           extensions::DictionaryBuilder()
+                           .Set("text",
+                                extensions::DictionaryBuilder()
+                                .Set("extensions", extensions::ListBuilder()
+                                     .Append("txt")))));
+  bar_app.SetID(kBarId);
+  extension_service_->AddExtension(bar_app.Build().get());
+
+  // Baz app provides file handler for all extensions and images.
+  extensions::ExtensionBuilder baz_app;
+  baz_app.SetManifest(extensions::DictionaryBuilder()
+                      .Set("name", "Baz")
+                      .Set("version", "1.0.0")
+                      .Set("manifest_version", 2)
+                      .Set("app", extensions::DictionaryBuilder()
+                           .Set("background", extensions::DictionaryBuilder()
+                                .Set("scripts", extensions::ListBuilder()
+                                    .Append("background.js"))))
+                      .Set("file_handlers",
+                           extensions::DictionaryBuilder()
+                           .Set("any",
+                                extensions::DictionaryBuilder()
+                                .Set("extensions", extensions::ListBuilder()
+                                     .Append("*")
+                                     .Append("bar")))
+                           .Set("image",
+                                extensions::DictionaryBuilder()
+                                .Set("types", extensions::ListBuilder()
+                                     .Append("image/*")))));
+  baz_app.SetID(kBazId);
+  extension_service_->AddExtension(baz_app.Build().get());
+
+  // Qux app provides file handler for all types.
+  extensions::ExtensionBuilder qux_app;
+  qux_app.SetManifest(extensions::DictionaryBuilder()
+                      .Set("name", "Qux")
+                      .Set("version", "1.0.0")
+                      .Set("manifest_version", 2)
+                      .Set("app", extensions::DictionaryBuilder()
+                           .Set("background", extensions::DictionaryBuilder()
+                                .Set("scripts", extensions::ListBuilder()
+                                    .Append("background.js"))))
+                      .Set("file_handlers",
+                           extensions::DictionaryBuilder()
+                           .Set("any",
+                                extensions::DictionaryBuilder()
+                                .Set("types", extensions::ListBuilder()
+                                     .Append("*")))));
+  qux_app.SetID(kQuxId);
+  extension_service_->AddExtension(qux_app.Build().get());
+
+  // Test case with .txt file
+  PathAndMimeTypeSet txt_path_mime_set;
+  txt_path_mime_set.insert(
+      std::make_pair(
+          drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII(
+              "foo.txt"),
+          "text/plain"));
+  std::vector<FullTaskDescriptor> txt_result;
+  FindFileHandlerTasks(&test_profile_, txt_path_mime_set, &txt_result);
+  EXPECT_EQ(4U, txt_result.size());
+  // Foo app provides a handler for text/plain.
+  EXPECT_EQ("Foo", txt_result[0].task_title());
+  EXPECT_FALSE(txt_result[0].is_generic_file_handler());
+  // Bar app provides a handler for .txt.
+  EXPECT_EQ("Bar", txt_result[1].task_title());
+  EXPECT_FALSE(txt_result[1].is_generic_file_handler());
+  // Baz app provides a handler for all extensions.
+  EXPECT_EQ("Baz", txt_result[2].task_title());
+  EXPECT_TRUE(txt_result[2].is_generic_file_handler());
+  // Qux app provides a handler for all types.
+  EXPECT_EQ("Qux", txt_result[3].task_title());
+  EXPECT_TRUE(txt_result[3].is_generic_file_handler());
+
+  // Test case with .jpg file
+  PathAndMimeTypeSet jpg_path_mime_set;
+  jpg_path_mime_set.insert(
+      std::make_pair(
+          drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII(
+              "foo.jpg"),
+          "image/jpeg"));
+  std::vector<FullTaskDescriptor> jpg_result;
+  FindFileHandlerTasks(&test_profile_, jpg_path_mime_set, &jpg_result);
+  EXPECT_EQ(3U, jpg_result.size());
+  // Foo app provides a handler for all types.
+  EXPECT_EQ("Foo", jpg_result[0].task_title());
+  EXPECT_TRUE(jpg_result[0].is_generic_file_handler());
+  // Baz app provides a handler for image/*. A partial wildcarded handler is
+  // treated as non-generic handler.
+  EXPECT_EQ("Baz", jpg_result[1].task_title());
+  EXPECT_FALSE(jpg_result[1].is_generic_file_handler());
+  // Qux app provides a handler for all types.
+  EXPECT_EQ("Qux", jpg_result[2].task_title());
+  EXPECT_TRUE(jpg_result[2].is_generic_file_handler());
+}
+
 }  // namespace file_tasks
 }  // namespace file_manager.