Move the check for fileBrowserHandler permission to FileBrowserHandler.

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 554 matching lines @@
 // The basic logic is similar to a test case for FindDriveAppTasks above.
 TEST_F(FileManagerFileTasksComplexTest, FindFileBrowserHandlerTasks) {
   // Copied from FindFileHandlerTasks test above.
   const char kFooId[] = "hhgbjpmdppecanaaogonaigmmifgpaph";
   const char kBarId[] = "odlhccgofgkadkkhcmhgnhgahonahoca";
   const char kEphemeralId[] = "opoomfdlbjcbjinalcjdjfoiikdeaoel";
 
   // Foo.app can handle ".txt" and ".html".
   // This one is an extension, and has "file_browser_handlers"
   extensions::ExtensionBuilder foo_app;
-  foo_app.SetManifest(extensions::DictionaryBuilder()
-                      .Set("name", "Foo")
-                      .Set("version", "1.0.0")
-                      .Set("manifest_version", 2)
-                      .Set("file_browser_handlers",
-                           extensions::ListBuilder()
-                           .Append(extensions::DictionaryBuilder()
-                                   .Set("id", "open")
-                                   .Set("default_title", "open")
-                                   .Set("file_filters",
-                                        extensions::ListBuilder()
-                                        .Append("filesystem:*.txt")
-                                        .Append("filesystem:*.html")))));
+  foo_app.SetManifest(
+      extensions::DictionaryBuilder()
+          .Set("name", "Foo")
+          .Set("version", "1.0.0")
+          .Set("manifest_version", 2)
+          .Set("permissions",
+               extensions::ListBuilder().Append("fileBrowserHandler"))
+          .Set(
+              "file_browser_handlers",
+              extensions::ListBuilder().Append(
+                  extensions::DictionaryBuilder()
+                      .Set("id", "open")
+                      .Set("default_title", "open")
+                      .Set("file_filters", extensions::ListBuilder()
+                                               .Append("filesystem:*.txt")
+                                               .Append("filesystem:*.html")))));
   foo_app.SetID(kFooId);
   extension_service_->AddExtension(foo_app.Build().get());
 
   // Bar.app can only handle ".txt".
   extensions::ExtensionBuilder bar_app;
-  bar_app.SetManifest(extensions::DictionaryBuilder()
-                      .Set("name", "Bar")
-                      .Set("version", "1.0.0")
-                      .Set("manifest_version", 2)
-                      .Set("file_browser_handlers",
-                           extensions::ListBuilder()
-                           .Append(extensions::DictionaryBuilder()
-                                   .Set("id", "open")
-                                   .Set("default_title", "open")
-                                   .Set("file_filters",
-                                        extensions::ListBuilder()
-                                        .Append("filesystem:*.txt")))));
+  bar_app.SetManifest(
+      extensions::DictionaryBuilder()
+          .Set("name", "Bar")
+          .Set("version", "1.0.0")
+          .Set("manifest_version", 2)
+          .Set("permissions",
+               extensions::ListBuilder().Append("fileBrowserHandler"))
+          .Set("file_browser_handlers",
+               extensions::ListBuilder().Append(
+                   extensions::DictionaryBuilder()
+                       .Set("id", "open")
+                       .Set("default_title", "open")
+                       .Set("file_filters", extensions::ListBuilder().Append(
+                                                "filesystem:*.txt")))));
   bar_app.SetID(kBarId);
   extension_service_->AddExtension(bar_app.Build().get());
 
   // Ephemeral.app is an ephemeral app that can handle ".txt".
   // It should not ever be found as ephemeral apps cannot be file browser
   // handlers.
   extensions::ExtensionBuilder ephemeral_app;
   ephemeral_app.SetManifest(
       extensions::DictionaryBuilder()
           .Set("name", "Ephemeral")
           .Set("version", "1.0.0")
           .Set("manifest_version", 2)
+          .Set("permissions",
+               extensions::ListBuilder().Append("fileBrowserHandler"))
           .Set("file_browser_handlers",
                extensions::ListBuilder().Append(
                    extensions::DictionaryBuilder()
                        .Set("id", "open")
                        .Set("default_title", "open")
-                       .Set("file_filters",
-                            extensions::ListBuilder().Append(
-                                "filesystem:*.txt")))));
+                       .Set("file_filters", extensions::ListBuilder().Append(
+                                                "filesystem:*.txt")))));
   ephemeral_app.SetID(kEphemeralId);
   scoped_refptr<extensions::Extension> built_ephemeral_app(
       ephemeral_app.Build());
   extension_service_->AddExtension(built_ephemeral_app.get());
   extensions::ExtensionPrefs* extension_prefs =
       extensions::ExtensionPrefs::Get(&test_profile_);
   extension_prefs->OnExtensionInstalled(built_ephemeral_app.get(),
                                         extensions::Extension::ENABLED,
                                         syncer::StringOrdinal(),
                                         extensions::kInstallFlagIsEphemeral,
@@ skipping 62 matching lines @@
                                 .Set("title", "Text")
                                 .Set("types",
                                      extensions::ListBuilder()
                                      .Append("text/plain")))));
   foo_app.SetID(kFooId);
   extension_service_->AddExtension(foo_app.Build().get());
 
   // Bar.app can only handle ".txt".
   // This is an extension (file browser handler).
   extensions::ExtensionBuilder bar_app;
-  bar_app.SetManifest(extensions::DictionaryBuilder()
-                      .Set("name", "Bar")
-                      .Set("version", "1.0.0")
-                      .Set("manifest_version", 2)
-                      .Set("file_browser_handlers",
-                           extensions::ListBuilder()
-                           .Append(extensions::DictionaryBuilder()
-                                   .Set("id", "open")
-                                   .Set("default_title", "open")
-                                   .Set("file_filters",
-                                        extensions::ListBuilder()
-                                        .Append("filesystem:*.txt")))));
+  bar_app.SetManifest(
+      extensions::DictionaryBuilder()
+          .Set("name", "Bar")
+          .Set("version", "1.0.0")
+          .Set("manifest_version", 2)
+          .Set("permissions",
+               extensions::ListBuilder().Append("fileBrowserHandler"))
+          .Set("file_browser_handlers",
+               extensions::ListBuilder().Append(
+                   extensions::DictionaryBuilder()
+                       .Set("id", "open")
+                       .Set("default_title", "open")
+                       .Set("file_filters", extensions::ListBuilder().Append(
+                                                "filesystem:*.txt")))));
   bar_app.SetID(kBarId);
   extension_service_->AddExtension(bar_app.Build().get());
 
   // Baz.app can handle "text/plain".
   // This is a Drive app.
   scoped_ptr<google_apis::AppResource> baz_app(new google_apis::AppResource);
   baz_app->set_product_id("baz_app_id");
   baz_app->set_application_id(kBazId);
   baz_app->set_name("Baz");
   baz_app->set_object_type("baz_object_type");
@@ skipping 57 matching lines @@
   ScopedVector<google_apis::AppResource> app_resources;
   app_resources.push_back(foo_app.release());
   google_apis::AppList app_list;
   app_list.set_items(app_resources.Pass());
   drive::DriveAppRegistry drive_app_registry(NULL);
   drive_app_registry.UpdateFromAppList(app_list);
 
   // Bar.app can handle ".gdoc" files.
   // This is an extension (file browser handler).
   extensions::ExtensionBuilder bar_app;
-  bar_app.SetManifest(extensions::DictionaryBuilder()
-                      .Set("name", "Bar")
-                      .Set("version", "1.0.0")
-                      .Set("manifest_version", 2)
-                      .Set("file_browser_handlers",
-                           extensions::ListBuilder()
-                           .Append(extensions::DictionaryBuilder()
-                                   .Set("id", "open")
-                                   .Set("default_title", "open")
-                                   .Set("file_filters",
-                                        extensions::ListBuilder()
-                                        .Append("filesystem:*.gdoc")))));
+  bar_app.SetManifest(
+      extensions::DictionaryBuilder()
+          .Set("name", "Bar")
+          .Set("version", "1.0.0")
+          .Set("manifest_version", 2)
+          .Set("permissions",
+               extensions::ListBuilder().Append("fileBrowserHandler"))
+          .Set("file_browser_handlers",
+               extensions::ListBuilder().Append(
+                   extensions::DictionaryBuilder()
+                       .Set("id", "open")
+                       .Set("default_title", "open")
+                       .Set("file_filters", extensions::ListBuilder().Append(
+                                                "filesystem:*.gdoc")))));
   bar_app.SetID(kBarId);
   extension_service_->AddExtension(bar_app.Build().get());
 
   // Files.app can handle ".gdoc" files.
   // The ID "kFileManagerAppId" used here is precisely the one that identifies
   // the Chrome OS Files.app application.
   extensions::ExtensionBuilder files_app;
-  files_app.SetManifest(extensions::DictionaryBuilder()
-                       .Set("name", "Files")
-                       .Set("version", "1.0.0")
-                       .Set("manifest_version", 2)
-                       .Set("file_browser_handlers",
-                            extensions::ListBuilder()
-                            .Append(extensions::DictionaryBuilder()
-                                    .Set("id", "open")
-                                    .Set("default_title", "open")
-                                    .Set("file_filters",
-                                         extensions::ListBuilder()
-                                         .Append("filesystem:*.gdoc")))));
+  files_app.SetManifest(
+      extensions::DictionaryBuilder()
+          .Set("name", "Files")
+          .Set("version", "1.0.0")
+          .Set("manifest_version", 2)
+          .Set("permissions",
+               extensions::ListBuilder().Append("fileBrowserHandler"))
+          .Set("file_browser_handlers",
+               extensions::ListBuilder().Append(
+                   extensions::DictionaryBuilder()
+                       .Set("id", "open")
+                       .Set("default_title", "open")
+                       .Set("file_filters", extensions::ListBuilder().Append(
+                                                "filesystem:*.gdoc")))));
   files_app.SetID(kFileManagerAppId);
   extension_service_->AddExtension(files_app.Build().get());
 
   // Find apps for a ".gdoc file". Only the built-in handler of Files.apps
   // should be found.
   PathAndMimeTypeSet path_mime_set;
   std::vector<GURL> file_urls;
   path_mime_set.insert(
       std::make_pair(
           drive::util::GetDriveMountPointPath(&test_profile_).AppendASCII(
@@ skipping 145 matching lines @@
   // 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.