chrome/browser/chromeos/file_manager/file_tasks_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/file_manager/file_tasks.h"
   6
   7 #include <algorithm>
   8 #include <utility>
   9
  10 #include "base/command_line.h"
  11 #include "base/prefs/pref_registry_simple.h"
  12 #include "base/prefs/testing_pref_service.h"
  13 #include "base/values.h"
  14 #include "chrome/browser/chromeos/drive/file_system_util.h"
  15 #include "chrome/browser/chromeos/file_manager/app_id.h"
  16 #include "chrome/browser/chromeos/login/user_manager.h"
  17 #include "chrome/browser/chromeos/settings/cros_settings.h"
  18 #include "chrome/browser/chromeos/settings/device_settings_service.h"
  19 #include "chrome/browser/drive/drive_app_registry.h"
  20 #include "chrome/browser/extensions/extension_service.h"
  21 #include "chrome/browser/extensions/test_extension_system.h"
  22 #include "chrome/common/pref_names.h"
  23 #include "chrome/test/base/testing_profile.h"
  24 #include "content/public/test/test_browser_thread_bundle.h"
  25 #include "extensions/browser/extension_system.h"
  26 #include "extensions/common/extension_builder.h"
  27 #include "google_apis/drive/drive_api_parser.h"
  28 #include "testing/gtest/include/gtest/gtest.h"
  29 #include "url/gurl.h"
  30
  31 namespace file_manager {
  32 namespace file_tasks {
  33 namespace {
  34
  35 // Registers the default task preferences. Used for testing
  36 // ChooseAndSetDefaultTask().
  37 void RegisterDefaultTaskPreferences(TestingPrefServiceSimple* pref_service) {
  38   DCHECK(pref_service);
  39
  40   pref_service->registry()->RegisterDictionaryPref(
  41       prefs::kDefaultTasksByMimeType);
  42   pref_service->registry()->RegisterDictionaryPref(
  43       prefs::kDefaultTasksBySuffix);
  44 }
  45
  46 // Updates the default task preferences per the given dictionary values. Used
  47 // for testing ChooseAndSetDefaultTask.
  48 void UpdateDefaultTaskPreferences(TestingPrefServiceSimple* pref_service,
  49                                   const base::DictionaryValue& mime_types,
  50                                   const base::DictionaryValue& suffixes) {
  51   DCHECK(pref_service);
  52
  53   pref_service->Set(prefs::kDefaultTasksByMimeType, mime_types);
  54   pref_service->Set(prefs::kDefaultTasksBySuffix, suffixes);
  55 }
  56
  57 }  // namespace
  58
  59 TEST(FileManagerFileTasksTest,
  60      FullTaskDescriptor_NonDriveAppWithIconAndDefault) {
  61   FullTaskDescriptor full_descriptor(
  62       TaskDescriptor("app-id",
  63                      TASK_TYPE_FILE_BROWSER_HANDLER,
  64                      "action-id"),
  65       "task title",
  66       GURL("http://example.com/icon.png"),
  67       true /* is_default */);
  68
  69   const std::string task_id =
  70       TaskDescriptorToId(full_descriptor.task_descriptor());
  71   EXPECT_EQ("app-id|file|action-id", task_id);
  72   EXPECT_EQ("http://example.com/icon.png", full_descriptor.icon_url().spec());
  73   EXPECT_EQ("task title", full_descriptor.task_title());
  74   EXPECT_TRUE(full_descriptor.is_default());
  75 }
  76
  77 TEST(FileManagerFileTasksTest,
  78      FullTaskDescriptor_DriveAppWithoutIconAndNotDefault) {
  79   FullTaskDescriptor full_descriptor(
  80       TaskDescriptor("app-id",
  81                      TASK_TYPE_DRIVE_APP,
  82                      "action-id"),
  83       "task title",
  84       GURL(),  // No icon URL.
  85       false /* is_default */);
  86
  87   const std::string task_id =
  88       TaskDescriptorToId(full_descriptor.task_descriptor());
  89   EXPECT_EQ("app-id|drive|action-id", task_id);
  90   EXPECT_TRUE(full_descriptor.icon_url().is_empty());
  91   EXPECT_EQ("task title", full_descriptor.task_title());
  92   EXPECT_FALSE(full_descriptor.is_default());
  93 }
  94
  95 TEST(FileManagerFileTasksTest, MakeTaskID) {
  96   EXPECT_EQ("app-id|file|action-id",
  97             MakeTaskID("app-id", TASK_TYPE_FILE_BROWSER_HANDLER, "action-id"));
  98   EXPECT_EQ("app-id|app|action-id",
  99             MakeTaskID("app-id", TASK_TYPE_FILE_HANDLER, "action-id"));
 100   EXPECT_EQ("app-id|drive|action-id",
 101             MakeTaskID("app-id", TASK_TYPE_DRIVE_APP, "action-id"));
 102 }
 103
 104 TEST(FileManagerFileTasksTest, MakeDriveAppTaskId) {
 105   EXPECT_EQ("app-id|drive|open-with", MakeDriveAppTaskId("app-id"));
 106 }
 107
 108 TEST(FileManagerFileTasksTest, TaskDescriptorToId) {
 109   EXPECT_EQ("app-id|file|action-id",
 110             TaskDescriptorToId(TaskDescriptor("app-id",
 111                                               TASK_TYPE_FILE_BROWSER_HANDLER,
 112                                               "action-id")));
 113 }
 114
 115 TEST(FileManagerFileTasksTest, ParseTaskID_FileBrowserHandler) {
 116   TaskDescriptor task;
 117   EXPECT_TRUE(ParseTaskID("app-id|file|action-id", &task));
 118   EXPECT_EQ("app-id", task.app_id);
 119   EXPECT_EQ(TASK_TYPE_FILE_BROWSER_HANDLER, task.task_type);
 120   EXPECT_EQ("action-id", task.action_id);
 121 }
 122
 123 TEST(FileManagerFileTasksTest, ParseTaskID_FileHandler) {
 124   TaskDescriptor task;
 125   EXPECT_TRUE(ParseTaskID("app-id|app|action-id", &task));
 126   EXPECT_EQ("app-id", task.app_id);
 127   EXPECT_EQ(TASK_TYPE_FILE_HANDLER, task.task_type);
 128   EXPECT_EQ("action-id", task.action_id);
 129 }
 130
 131 TEST(FileManagerFileTasksTest, ParseTaskID_DriveApp) {
 132   TaskDescriptor task;
 133   EXPECT_TRUE(ParseTaskID("app-id|drive|action-id", &task));
 134   EXPECT_EQ("app-id", task.app_id);
 135   EXPECT_EQ(TASK_TYPE_DRIVE_APP, task.task_type);
 136   EXPECT_EQ("action-id", task.action_id);
 137 }
 138
 139 TEST(FileManagerFileTasksTest, ParseTaskID_Legacy) {
 140   TaskDescriptor task;
 141   // A legacy task ID only has two parts. The task type should be
 142   // TASK_TYPE_FILE_BROWSER_HANDLER.
 143   EXPECT_TRUE(ParseTaskID("app-id|action-id", &task));
 144   EXPECT_EQ("app-id", task.app_id);
 145   EXPECT_EQ(TASK_TYPE_FILE_BROWSER_HANDLER, task.task_type);
 146   EXPECT_EQ("action-id", task.action_id);
 147 }
 148
 149 TEST(FileManagerFileTasksTest, ParseTaskID_LegacyDrive) {
 150   TaskDescriptor task;
 151   // A legacy task ID only has two parts. For Drive app, the app ID is
 152   // prefixed with "drive-app:".
 153   EXPECT_TRUE(ParseTaskID("drive-app:app-id|action-id", &task));
 154   EXPECT_EQ("app-id", task.app_id);
 155   EXPECT_EQ(TASK_TYPE_DRIVE_APP, task.task_type);
 156   EXPECT_EQ("action-id", task.action_id);
 157 }
 158
 159 TEST(FileManagerFileTasksTest, ParseTaskID_Invalid) {
 160   TaskDescriptor task;
 161   EXPECT_FALSE(ParseTaskID("invalid", &task));
 162 }
 163
 164 TEST(FileManagerFileTasksTest, ParseTaskID_UnknownTaskType) {
 165   TaskDescriptor task;
 166   EXPECT_FALSE(ParseTaskID("app-id|unknown|action-id", &task));
 167 }
 168
 169 TEST(FileManagerFileTasksTest, FindDriveAppTasks) {
 170   TestingProfile profile;
 171   // For DriveAppRegistry, which checks CurrentlyOn(BrowserThread::UI).
 172   content::TestBrowserThreadBundle thread_bundle;
 173
 174   // Foo.app can handle "text/plain" and "text/html"
 175   scoped_ptr<google_apis::AppResource> foo_app(new google_apis::AppResource);
 176   foo_app->set_product_id("foo_app_id");
 177   foo_app->set_application_id("foo_app_id");
 178   foo_app->set_name("Foo");
 179   foo_app->set_object_type("foo_object_type");
 180   ScopedVector<std::string> foo_mime_types;
 181   foo_mime_types.push_back(new std::string("text/plain"));
 182   foo_mime_types.push_back(new std::string("text/html"));
 183   foo_app->set_primary_mimetypes(foo_mime_types.Pass());
 184
 185   // Bar.app can only handle "text/plain".
 186   scoped_ptr<google_apis::AppResource> bar_app(new google_apis::AppResource);
 187   bar_app->set_product_id("bar_app_id");
 188   bar_app->set_application_id("bar_app_id");
 189   bar_app->set_name("Bar");
 190   bar_app->set_object_type("bar_object_type");
 191   ScopedVector<std::string> bar_mime_types;
 192   bar_mime_types.push_back(new std::string("text/plain"));
 193   bar_app->set_primary_mimetypes(bar_mime_types.Pass());
 194
 195   // Prepare DriveAppRegistry from Foo.app and Bar.app.
 196   ScopedVector<google_apis::AppResource> app_resources;
 197   app_resources.push_back(foo_app.release());
 198   app_resources.push_back(bar_app.release());
 199   google_apis::AppList app_list;
 200   app_list.set_items(app_resources.Pass());
 201   drive::DriveAppRegistry drive_app_registry(NULL);
 202   drive_app_registry.UpdateFromAppList(app_list);
 203
 204   // Find apps for a "text/plain" file. Foo.app and Bar.app should be found.
 205   PathAndMimeTypeSet path_mime_set;
 206   path_mime_set.insert(
 207       std::make_pair(
 208           drive::util::GetDriveMountPointPath(&profile).AppendASCII("foo.txt"),
 209           "text/plain"));
 210   std::vector<FullTaskDescriptor> tasks;
 211   FindDriveAppTasks(drive_app_registry,
 212                     path_mime_set,
 213                     &tasks);
 214   ASSERT_EQ(2U, tasks.size());
 215   // Sort the app IDs, as the order is not guaranteed.
 216   std::vector<std::string> app_ids;
 217   app_ids.push_back(tasks[0].task_descriptor().app_id);
 218   app_ids.push_back(tasks[1].task_descriptor().app_id);
 219   std::sort(app_ids.begin(), app_ids.end());
 220   // Confirm that both Foo.app and Bar.app are found.
 221   EXPECT_EQ("bar_app_id", app_ids[0]);
 222   EXPECT_EQ("foo_app_id", app_ids[1]);
 223
 224   // Find apps for "text/plain" and "text/html" files. Only Foo.app should be
 225   // found.
 226   path_mime_set.clear();
 227   path_mime_set.insert(
 228       std::make_pair(
 229           drive::util::GetDriveMountPointPath(&profile).AppendASCII("foo.txt"),
 230           "text/plain"));
 231   path_mime_set.insert(
 232       std::make_pair(
 233           drive::util::GetDriveMountPointPath(&profile).AppendASCII("foo.html"),
 234           "text/html"));
 235   tasks.clear();
 236   FindDriveAppTasks(drive_app_registry,
 237                     path_mime_set,
 238                     &tasks);
 239   ASSERT_EQ(1U, tasks.size());
 240   // Confirm that only Foo.app is found.
 241   EXPECT_EQ("foo_app_id", tasks[0].task_descriptor().app_id);
 242
 243   // Add a "text/plain" file not on Drive. No tasks should be found.
 244   path_mime_set.insert(
 245       std::make_pair(base::FilePath::FromUTF8Unsafe("not_on_drive.txt"),
 246                      "text/plain"));
 247   tasks.clear();
 248   FindDriveAppTasks(drive_app_registry,
 249                     path_mime_set,
 250                     &tasks);
 251   // Confirm no tasks are found.
 252   ASSERT_TRUE(tasks.empty());
 253 }
 254
 255 // Test that the right task is chosen from multiple choices per mime types
 256 // and file extensions.
 257 TEST(FileManagerFileTasksTest, ChooseAndSetDefaultTask_MultipleTasks) {
 258   TestingPrefServiceSimple pref_service;
 259   RegisterDefaultTaskPreferences(&pref_service);
 260
 261   // Text.app and Nice.app were found for "foo.txt".
 262   TaskDescriptor text_app_task("text-app-id",
 263                                TASK_TYPE_FILE_HANDLER,
 264                                "action-id");
 265   TaskDescriptor nice_app_task("nice-app-id",
 266                                TASK_TYPE_FILE_HANDLER,
 267                                "action-id");
 268   std::vector<FullTaskDescriptor> tasks;
 269   tasks.push_back(FullTaskDescriptor(
 270       text_app_task,
 271       "Text.app",
 272       GURL("http://example.com/text_app.png"),
 273       false /* is_default */));
 274   tasks.push_back(FullTaskDescriptor(
 275       nice_app_task,
 276       "Nice.app",
 277       GURL("http://example.com/nice_app.png"),
 278       false /* is_default */));
 279   PathAndMimeTypeSet path_mime_set;
 280   path_mime_set.insert(std::make_pair(
 281       base::FilePath::FromUTF8Unsafe("foo.txt"),
 282       "text/plain"));
 283
 284   // None of them should be chosen as default, as nothing is set in the
 285   // preferences.
 286   ChooseAndSetDefaultTask(pref_service, path_mime_set, &tasks);
 287   EXPECT_FALSE(tasks[0].is_default());
 288   EXPECT_FALSE(tasks[1].is_default());
 289
 290   // Set Text.app as default for "text/plain" in the preferences.
 291   base::DictionaryValue empty;
 292   base::DictionaryValue mime_types;
 293   mime_types.SetStringWithoutPathExpansion(
 294       "text/plain",
 295       TaskDescriptorToId(text_app_task));
 296   UpdateDefaultTaskPreferences(&pref_service, mime_types, empty);
 297
 298   // Text.app should be chosen as default.
 299   ChooseAndSetDefaultTask(pref_service, path_mime_set, &tasks);
 300   EXPECT_TRUE(tasks[0].is_default());
 301   EXPECT_FALSE(tasks[1].is_default());
 302
 303   // Change it back to non-default for testing further.
 304   tasks[0].set_is_default(false);
 305
 306   // Clear the preferences and make sure none of them are default.
 307   UpdateDefaultTaskPreferences(&pref_service, empty, empty);
 308   ChooseAndSetDefaultTask(pref_service, path_mime_set, &tasks);
 309   EXPECT_FALSE(tasks[0].is_default());
 310   EXPECT_FALSE(tasks[1].is_default());
 311
 312   // Set Nice.app as default for ".txt" in the preferences.
 313   base::DictionaryValue suffixes;
 314   suffixes.SetStringWithoutPathExpansion(
 315       ".txt",
 316       TaskDescriptorToId(nice_app_task));
 317   UpdateDefaultTaskPreferences(&pref_service, empty, suffixes);
 318
 319   // Now Nice.app should be chosen as default.
 320   ChooseAndSetDefaultTask(pref_service, path_mime_set, &tasks);
 321   EXPECT_FALSE(tasks[0].is_default());
 322   EXPECT_TRUE(tasks[1].is_default());
 323 }
 324
 325 // Test that Files.app's internal file browser handler is chosen as default
 326 // even if nothing is set in the preferences.
 327 TEST(FileManagerFileTasksTest, ChooseAndSetDefaultTask_FallbackFileBrowser) {
 328   TestingPrefServiceSimple pref_service;
 329   RegisterDefaultTaskPreferences(&pref_service);
 330
 331   // Files.app's internal file browser handler was found for "foo.txt".
 332   TaskDescriptor files_app_task(kFileManagerAppId,
 333                                 TASK_TYPE_FILE_BROWSER_HANDLER,
 334                                 "view-in-browser");
 335   std::vector<FullTaskDescriptor> tasks;
 336   tasks.push_back(FullTaskDescriptor(
 337       files_app_task,
 338       "View in browser",
 339       GURL("http://example.com/some_icon.png"),
 340       false /* is_default */));
 341   PathAndMimeTypeSet path_mime_set;
 342   path_mime_set.insert(std::make_pair(
 343       base::FilePath::FromUTF8Unsafe("foo.txt"),
 344       "text/plain"));
 345
 346   // The internal file browser handler should be chosen as default, as it's a
 347   // fallback file browser handler.
 348   ChooseAndSetDefaultTask(pref_service, path_mime_set, &tasks);
 349   EXPECT_TRUE(tasks[0].is_default());
 350 }
 351
 352 // Test using the test extension system, which needs lots of setup.
 353 class FileManagerFileTasksComplexTest : public testing::Test {
 354  protected:
 355   FileManagerFileTasksComplexTest()
 356       : command_line_(CommandLine::NO_PROGRAM),
 357         extension_service_(NULL) {
 358     extensions::TestExtensionSystem* test_extension_system =
 359         static_cast<extensions::TestExtensionSystem*>(
 360             extensions::ExtensionSystem::Get(&test_profile_));
 361     extension_service_ = test_extension_system->CreateExtensionService(
 362         &command_line_,
 363         base::FilePath()  /* install_directory */,
 364         false  /* autoupdate_enabled*/);
 365   }
 366
 367   content::TestBrowserThreadBundle thread_bundle_;
 368   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
 369   chromeos::ScopedTestCrosSettings test_cros_settings_;
 370   chromeos::ScopedTestUserManager test_user_manager_;
 371   TestingProfile test_profile_;
 372   CommandLine command_line_;
 373   ExtensionService* extension_service_;  // Owned by test_profile_;
 374 };
 375
 376 // The basic logic is similar to a test case for FindDriveAppTasks above.
 377 TEST_F(FileManagerFileTasksComplexTest, FindFileHandlerTasks) {
 378   // Random IDs generated by
 379   // % ruby -le 'print (0...32).to_a.map{(?a + rand(16)).chr}.join'
 380   const char kFooId[] = "hhgbjpmdppecanaaogonaigmmifgpaph";
 381   const char kBarId[] = "odlhccgofgkadkkhcmhgnhgahonahoca";
 382
 383   // Foo.app can handle "text/plain" and "text/html".
 384   extensions::ExtensionBuilder foo_app;
 385   foo_app.SetManifest(extensions::DictionaryBuilder()
 386                       .Set("name", "Foo")
 387                       .Set("version", "1.0.0")
 388                       .Set("manifest_version", 2)
 389                       .Set("app",
 390                            extensions::DictionaryBuilder()
 391                            .Set("background",
 392                                 extensions::DictionaryBuilder()
 393                                 .Set("scripts",
 394                                      extensions::ListBuilder()
 395                                      .Append("background.js"))))
 396                       .Set("file_handlers",
 397                            extensions::DictionaryBuilder()
 398                            .Set("text",
 399                                 extensions::DictionaryBuilder()
 400                                 .Set("title", "Text")
 401                                 .Set("types",
 402                                      extensions::ListBuilder()
 403                                      .Append("text/plain")
 404                                      .Append("text/html")))));
 405   foo_app.SetID(kFooId);
 406   extension_service_->AddExtension(foo_app.Build().get());
 407
 408   // Bar.app can only handle "text/plain".
 409   extensions::ExtensionBuilder bar_app;
 410   bar_app.SetManifest(extensions::DictionaryBuilder()
 411                       .Set("name", "Bar")
 412                       .Set("version", "1.0.0")
 413                       .Set("manifest_version", 2)
 414                       .Set("app",
 415                            extensions::DictionaryBuilder()
 416                            .Set("background",
 417                                 extensions::DictionaryBuilder()
 418                                 .Set("scripts",
 419                                      extensions::ListBuilder()
 420                                      .Append("background.js"))))
 421                       .Set("file_handlers",
 422                            extensions::DictionaryBuilder()
 423                            .Set("text",
 424                                 extensions::DictionaryBuilder()
 425                                 .Set("title", "Text")
 426                                 .Set("types",
 427                                      extensions::ListBuilder()
 428                                      .Append("text/plain")))));
 429   bar_app.SetID(kBarId);
 430   extension_service_->AddExtension(bar_app.Build().get());
 431
 432   // Find apps for a "text/plain" file. Foo.app and Bar.app should be found.
 433   PathAndMimeTypeSet path_mime_set;
 434   path_mime_set.insert(
 435       std::make_pair(
 436           drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII(
 437               "foo.txt"),
 438           "text/plain"));
 439
 440   std::vector<FullTaskDescriptor> tasks;
 441   FindFileHandlerTasks(&test_profile_, path_mime_set, &tasks);
 442   ASSERT_EQ(2U, tasks.size());
 443   // Sort the app IDs, as the order is not guaranteed.
 444   std::vector<std::string> app_ids;
 445   app_ids.push_back(tasks[0].task_descriptor().app_id);
 446   app_ids.push_back(tasks[1].task_descriptor().app_id);
 447   std::sort(app_ids.begin(), app_ids.end());
 448   // Confirm that both Foo.app and Bar.app are found.
 449   EXPECT_EQ(kFooId, app_ids[0]);
 450   EXPECT_EQ(kBarId, app_ids[1]);
 451
 452   // Find apps for "text/plain" and "text/html" files. Only Foo.app should be
 453   // found.
 454   path_mime_set.clear();
 455   path_mime_set.insert(
 456       std::make_pair(
 457           drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII(
 458               "foo.txt"),
 459           "text/plain"));
 460   path_mime_set.insert(
 461       std::make_pair(
 462           drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII(
 463               "foo.html"),
 464           "text/html"));
 465   tasks.clear();
 466   FindFileHandlerTasks(&test_profile_, path_mime_set, &tasks);
 467   ASSERT_EQ(1U, tasks.size());
 468   // Confirm that only Foo.app is found.
 469   EXPECT_EQ(kFooId, tasks[0].task_descriptor().app_id);
 470
 471   // Add an "image/png" file. No tasks should be found.
 472   path_mime_set.insert(
 473       std::make_pair(base::FilePath::FromUTF8Unsafe("foo.png"),
 474                      "image/png"));
 475   tasks.clear();
 476   FindFileHandlerTasks(&test_profile_, path_mime_set, &tasks);
 477   // Confirm no tasks are found.
 478   ASSERT_TRUE(tasks.empty());
 479 }
 480
 481 // The basic logic is similar to a test case for FindDriveAppTasks above.
 482 TEST_F(FileManagerFileTasksComplexTest, FindFileBrowserHandlerTasks) {
 483   // Copied from FindFileHandlerTasks test above.
 484   const char kFooId[] = "hhgbjpmdppecanaaogonaigmmifgpaph";
 485   const char kBarId[] = "odlhccgofgkadkkhcmhgnhgahonahoca";
 486
 487   // Foo.app can handle ".txt" and ".html".
 488   // This one is an extension, and has "file_browser_handlers"
 489   extensions::ExtensionBuilder foo_app;
 490   foo_app.SetManifest(extensions::DictionaryBuilder()
 491                       .Set("name", "Foo")
 492                       .Set("version", "1.0.0")
 493                       .Set("manifest_version", 2)
 494                       .Set("file_browser_handlers",
 495                            extensions::ListBuilder()
 496                            .Append(extensions::DictionaryBuilder()
 497                                    .Set("id", "open")
 498                                    .Set("default_title", "open")
 499                                    .Set("file_filters",
 500                                         extensions::ListBuilder()
 501                                         .Append("filesystem:*.txt")
 502                                         .Append("filesystem:*.html")))));
 503   foo_app.SetID(kFooId);
 504   extension_service_->AddExtension(foo_app.Build().get());
 505
 506   // Bar.app can only handle ".txt".
 507   extensions::ExtensionBuilder bar_app;
 508   bar_app.SetManifest(extensions::DictionaryBuilder()
 509                       .Set("name", "Bar")
 510                       .Set("version", "1.0.0")
 511                       .Set("manifest_version", 2)
 512                       .Set("file_browser_handlers",
 513                            extensions::ListBuilder()
 514                            .Append(extensions::DictionaryBuilder()
 515                                    .Set("id", "open")
 516                                    .Set("default_title", "open")
 517                                    .Set("file_filters",
 518                                         extensions::ListBuilder()
 519                                         .Append("filesystem:*.txt")))));
 520   bar_app.SetID(kBarId);
 521   extension_service_->AddExtension(bar_app.Build().get());
 522
 523   // Find apps for a ".txt" file. Foo.app and Bar.app should be found.
 524   std::vector<GURL> file_urls;
 525   file_urls.push_back(GURL("filesystem:chrome-extension://id/dir/foo.txt"));
 526
 527   std::vector<FullTaskDescriptor> tasks;
 528   FindFileBrowserHandlerTasks(&test_profile_, file_urls, &tasks);
 529   ASSERT_EQ(2U, tasks.size());
 530   // Sort the app IDs, as the order is not guaranteed.
 531   std::vector<std::string> app_ids;
 532   app_ids.push_back(tasks[0].task_descriptor().app_id);
 533   app_ids.push_back(tasks[1].task_descriptor().app_id);
 534   std::sort(app_ids.begin(), app_ids.end());
 535   // Confirm that both Foo.app and Bar.app are found.
 536   EXPECT_EQ(kFooId, app_ids[0]);
 537   EXPECT_EQ(kBarId, app_ids[1]);
 538
 539   // Find apps for ".txt" and ".html" files. Only Foo.app should be found.
 540   file_urls.clear();
 541   file_urls.push_back(GURL("filesystem:chrome-extension://id/dir/foo.txt"));
 542   file_urls.push_back(GURL("filesystem:chrome-extension://id/dir/foo.html"));
 543   tasks.clear();
 544   FindFileBrowserHandlerTasks(&test_profile_, file_urls, &tasks);
 545   ASSERT_EQ(1U, tasks.size());
 546   // Confirm that only Foo.app is found.
 547   EXPECT_EQ(kFooId, tasks[0].task_descriptor().app_id);
 548
 549   // Add an ".png" file. No tasks should be found.
 550   file_urls.push_back(GURL("filesystem:chrome-extension://id/dir/foo.png"));
 551   tasks.clear();
 552   FindFileBrowserHandlerTasks(&test_profile_, file_urls, &tasks);
 553   // Confirm no tasks are found.
 554   ASSERT_TRUE(tasks.empty());
 555 }
 556
 557 // Test that all kinds of apps (file handler, file browser handler, and Drive
 558 // app) are returned.
 559 TEST_F(FileManagerFileTasksComplexTest, FindAllTypesOfTasks) {
 560   // kFooId and kBarId copied from FindFileHandlerTasks test above.
 561   const char kFooId[] = "hhgbjpmdppecanaaogonaigmmifgpaph";
 562   const char kBarId[] = "odlhccgofgkadkkhcmhgnhgahonahoca";
 563   const char kBazId[] = "plifkpkakemokpflgbnnigcoldgcbdmc";
 564
 565   // Foo.app can handle "text/plain".
 566   // This is a packaged app (file handler).
 567   extensions::ExtensionBuilder foo_app;
 568   foo_app.SetManifest(extensions::DictionaryBuilder()
 569                       .Set("name", "Foo")
 570                       .Set("version", "1.0.0")
 571                       .Set("manifest_version", 2)
 572                       .Set("app",
 573                            extensions::DictionaryBuilder()
 574                            .Set("background",
 575                                 extensions::DictionaryBuilder()
 576                                 .Set("scripts",
 577                                      extensions::ListBuilder()
 578                                      .Append("background.js"))))
 579                       .Set("file_handlers",
 580                            extensions::DictionaryBuilder()
 581                            .Set("text",
 582                                 extensions::DictionaryBuilder()
 583                                 .Set("title", "Text")
 584                                 .Set("types",
 585                                      extensions::ListBuilder()
 586                                      .Append("text/plain")))));
 587   foo_app.SetID(kFooId);
 588   extension_service_->AddExtension(foo_app.Build().get());
 589
 590   // Bar.app can only handle ".txt".
 591   // This is an extension (file browser handler).
 592   extensions::ExtensionBuilder bar_app;
 593   bar_app.SetManifest(extensions::DictionaryBuilder()
 594                       .Set("name", "Bar")
 595                       .Set("version", "1.0.0")
 596                       .Set("manifest_version", 2)
 597                       .Set("file_browser_handlers",
 598                            extensions::ListBuilder()
 599                            .Append(extensions::DictionaryBuilder()
 600                                    .Set("id", "open")
 601                                    .Set("default_title", "open")
 602                                    .Set("file_filters",
 603                                         extensions::ListBuilder()
 604                                         .Append("filesystem:*.txt")))));
 605   bar_app.SetID(kBarId);
 606   extension_service_->AddExtension(bar_app.Build().get());
 607
 608   // Baz.app can handle "text/plain".
 609   // This is a Drive app.
 610   scoped_ptr<google_apis::AppResource> baz_app(new google_apis::AppResource);
 611   baz_app->set_product_id("baz_app_id");
 612   baz_app->set_application_id(kBazId);
 613   baz_app->set_name("Baz");
 614   baz_app->set_object_type("baz_object_type");
 615   ScopedVector<std::string> baz_mime_types;
 616   baz_mime_types.push_back(new std::string("text/plain"));
 617   baz_app->set_primary_mimetypes(baz_mime_types.Pass());
 618   // Set up DriveAppRegistry.
 619   ScopedVector<google_apis::AppResource> app_resources;
 620   app_resources.push_back(baz_app.release());
 621   google_apis::AppList app_list;
 622   app_list.set_items(app_resources.Pass());
 623   drive::DriveAppRegistry drive_app_registry(NULL);
 624   drive_app_registry.UpdateFromAppList(app_list);
 625
 626   // Find apps for "foo.txt". All apps should be found.
 627   PathAndMimeTypeSet path_mime_set;
 628   std::vector<GURL> file_urls;
 629   path_mime_set.insert(
 630       std::make_pair(
 631           drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII(
 632               "foo.txt"),
 633           "text/plain"));
 634   file_urls.push_back(GURL("filesystem:chrome-extension://id/dir/foo.txt"));
 635
 636   std::vector<FullTaskDescriptor> tasks;
 637   FindAllTypesOfTasks(&test_profile_,
 638                       &drive_app_registry,
 639                       path_mime_set,
 640                       file_urls,
 641                       &tasks);
 642   ASSERT_EQ(3U, tasks.size());
 643
 644   // Sort the app IDs, as the order is not guaranteed.
 645   std::vector<std::string> app_ids;
 646   app_ids.push_back(tasks[0].task_descriptor().app_id);
 647   app_ids.push_back(tasks[1].task_descriptor().app_id);
 648   app_ids.push_back(tasks[2].task_descriptor().app_id);
 649   std::sort(app_ids.begin(), app_ids.end());
 650   // Confirm that all apps are found.
 651   EXPECT_EQ(kFooId, app_ids[0]);
 652   EXPECT_EQ(kBarId, app_ids[1]);
 653   EXPECT_EQ(kBazId, app_ids[2]);
 654 }
 655
 656 TEST_F(FileManagerFileTasksComplexTest, FindAllTypesOfTasks_GoogleDocument) {
 657   // kFooId and kBarId copied from FindFileHandlerTasks test above.
 658   const char kFooId[] = "hhgbjpmdppecanaaogonaigmmifgpaph";
 659   const char kBarId[] = "odlhccgofgkadkkhcmhgnhgahonahoca";
 660
 661   // Foo.app can handle ".gdoc" files.
 662   scoped_ptr<google_apis::AppResource> foo_app(new google_apis::AppResource);
 663   foo_app->set_product_id("foo_app");
 664   foo_app->set_application_id(kFooId);
 665   foo_app->set_name("Foo");
 666   foo_app->set_object_type("foo_object_type");
 667   ScopedVector<std::string> foo_extensions;
 668   foo_extensions.push_back(new std::string("gdoc"));  // Not ".gdoc"
 669   foo_app->set_primary_file_extensions(foo_extensions.Pass());
 670
 671   // Prepare DriveAppRegistry from Foo.app.
 672   ScopedVector<google_apis::AppResource> app_resources;
 673   app_resources.push_back(foo_app.release());
 674   google_apis::AppList app_list;
 675   app_list.set_items(app_resources.Pass());
 676   drive::DriveAppRegistry drive_app_registry(NULL);
 677   drive_app_registry.UpdateFromAppList(app_list);
 678
 679   // Bar.app can handle ".gdoc" files.
 680   // This is an extension (file browser handler).
 681   extensions::ExtensionBuilder bar_app;
 682   bar_app.SetManifest(extensions::DictionaryBuilder()
 683                       .Set("name", "Bar")
 684                       .Set("version", "1.0.0")
 685                       .Set("manifest_version", 2)
 686                       .Set("file_browser_handlers",
 687                            extensions::ListBuilder()
 688                            .Append(extensions::DictionaryBuilder()
 689                                    .Set("id", "open")
 690                                    .Set("default_title", "open")
 691                                    .Set("file_filters",
 692                                         extensions::ListBuilder()
 693                                         .Append("filesystem:*.gdoc")))));
 694   bar_app.SetID(kBarId);
 695   extension_service_->AddExtension(bar_app.Build().get());
 696
 697   // Files.app can handle ".gdoc" files.
 698   // The ID "kFileManagerAppId" used here is precisely the one that identifies
 699   // the Chrome OS Files.app application.
 700   extensions::ExtensionBuilder files_app;
 701   files_app.SetManifest(extensions::DictionaryBuilder()
 702                        .Set("name", "Files")
 703                        .Set("version", "1.0.0")
 704                        .Set("manifest_version", 2)
 705                        .Set("file_browser_handlers",
 706                             extensions::ListBuilder()
 707                             .Append(extensions::DictionaryBuilder()
 708                                     .Set("id", "open")
 709                                     .Set("default_title", "open")
 710                                     .Set("file_filters",
 711                                          extensions::ListBuilder()
 712                                          .Append("filesystem:*.gdoc")))));
 713   files_app.SetID(kFileManagerAppId);
 714   extension_service_->AddExtension(files_app.Build().get());
 715
 716   // Find apps for a ".gdoc file". Only the built-in handler of Files.apps
 717   // should be found.
 718   PathAndMimeTypeSet path_mime_set;
 719   std::vector<GURL> file_urls;
 720   path_mime_set.insert(
 721       std::make_pair(
 722           drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII(
 723               "foo.gdoc"),
 724           "application/vnd.google-apps.document"));
 725   file_urls.push_back(GURL("filesystem:chrome-extension://id/dir/foo.gdoc"));
 726
 727   std::vector<FullTaskDescriptor> tasks;
 728   FindAllTypesOfTasks(&test_profile_,
 729                       &drive_app_registry,
 730                       path_mime_set,
 731                       file_urls,
 732                       &tasks);
 733   ASSERT_EQ(1U, tasks.size());
 734   EXPECT_EQ(kFileManagerAppId, tasks[0].task_descriptor().app_id);
 735 }
 736
 737 }  // namespace file_tasks
 738 }  // namespace file_manager.