Consolidate manifest handler registration.

chrome/common/extensions/extension_unittest.cc

 // Copyright (c) 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/common/extensions/extension_unittest.h"
-
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/extensions/api/plugins/plugins_handler.h"
-#include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/command.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_test_util.h"
 #include "chrome/common/extensions/features/feature.h"
-#include "chrome/common/extensions/incognito_handler.h"
 #include "chrome/common/extensions/manifest.h"
-#include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
 #include "chrome/common/extensions/permissions/api_permission.h"
-#include "chrome/common/extensions/permissions/chrome_api_permissions.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
-#include "chrome/common/extensions/permissions/scoped_testing_permissions_info.h"
 #include "chrome/common/extensions/permissions/socket_permission.h"
 #include "chrome/common/extensions/permissions/usb_device_permission.h"
 #include "chrome/common/url_constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension_resource.h"
 #include "extensions/common/id_util.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/mime_sniffer.h"
 #include "net/dns/mock_host_resolver.h"
 #include "skia/ext/image_operations.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
 using content::SocketPermissionRequest;
 using extension_test_util::LoadManifest;
 using extension_test_util::LoadManifestUnchecked;
 using extension_test_util::LoadManifestStrict;
 
 namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 namespace errors = extension_manifest_errors;
 
 namespace extensions {
 
-ExtensionTest::ExtensionTest() : permissions_info_(ChromeAPIPermissions()) {}
-
-void ExtensionTest::SetUp() {
-  testing::Test::SetUp();
-  (new BackgroundManifestHandler)->Register();
-  // We need the IncognitoHandler registered for all tests, since
-  // Extension uses it in Extension::CheckPlatformAppFeatures() as part of the
-  // creation process.
-  (new IncognitoHandler)->Register();
-}
-
-void ExtensionTest::TearDown() {
-  ManifestHandler::ClearRegistryForTesting();
-  testing::Test::TearDown();
-}
-
 // We persist location values in the preferences, so this is a sanity test that
 // someone doesn't accidentally change them.
-TEST_F(ExtensionTest, LocationValuesTest) {
+TEST(ExtensionTest, LocationValuesTest) {
   ASSERT_EQ(0, Manifest::INVALID_LOCATION);
   ASSERT_EQ(1, Manifest::INTERNAL);
   ASSERT_EQ(2, Manifest::EXTERNAL_PREF);
   ASSERT_EQ(3, Manifest::EXTERNAL_REGISTRY);
   ASSERT_EQ(4, Manifest::UNPACKED);
   ASSERT_EQ(5, Manifest::COMPONENT);
   ASSERT_EQ(6, Manifest::EXTERNAL_PREF_DOWNLOAD);
   ASSERT_EQ(7, Manifest::EXTERNAL_POLICY_DOWNLOAD);
   ASSERT_EQ(8, Manifest::COMMAND_LINE);
 }
 
-TEST_F(ExtensionTest, LocationPriorityTest) {
+TEST(ExtensionTest, LocationPriorityTest) {
   for (int i = 0; i < Manifest::NUM_LOCATIONS; i++) {
     Manifest::Location loc = static_cast<Manifest::Location>(i);
 
     // INVALID is not a valid location.
     if (loc == Manifest::INVALID_LOCATION)
       continue;
 
     // Comparing a location that has no rank will hit a CHECK. Do a
     // compare with every valid location, to be sure each one is covered.
 
@@ skipping 16 matching lines @@
             Manifest::GetHigherPriorityLocation(
                 Manifest::EXTERNAL_POLICY_DOWNLOAD,
                 Manifest::EXTERNAL_PREF));
 
   ASSERT_EQ(Manifest::EXTERNAL_PREF,
             Manifest::GetHigherPriorityLocation(
                 Manifest::INTERNAL,
                 Manifest::EXTERNAL_PREF));
 }
 
-TEST_F(ExtensionTest, GetResourceURLAndPath) {
+TEST(ExtensionTest, GetResourceURLAndPath) {
   scoped_refptr<Extension> extension = LoadManifestStrict("empty_manifest",
       "empty.json");
   EXPECT_TRUE(extension.get());
 
   EXPECT_EQ(extension->url().spec() + "bar/baz.js",
             Extension::GetResourceURL(extension->url(), "bar/baz.js").spec());
   EXPECT_EQ(extension->url().spec() + "baz.js",
             Extension::GetResourceURL(extension->url(),
                                       "bar/../baz.js").spec());
   EXPECT_EQ(extension->url().spec() + "baz.js",
             Extension::GetResourceURL(extension->url(), "../baz.js").spec());
 
   // Test that absolute-looking paths ("/"-prefixed) are pasted correctly.
   EXPECT_EQ(extension->url().spec() + "test.html",
             extension->GetResourceURL("/test.html").spec());
 }
 
-TEST_F(ExtensionTest, GetAbsolutePathNoError) {
+TEST(ExtensionTest, GetAbsolutePathNoError) {
   scoped_refptr<Extension> extension = LoadManifestStrict("absolute_path",
       "absolute.json");
   EXPECT_TRUE(extension.get());
   std::string err;
   std::vector<InstallWarning> warnings;
   EXPECT_TRUE(extension_file_util::ValidateExtension(extension.get(),
                                                      &err, &warnings));
   EXPECT_EQ(0U, warnings.size());
 
   EXPECT_EQ(extension->path().AppendASCII("test.html").value(),
             extension->GetResource("test.html").GetFilePath().value());
   EXPECT_EQ(extension->path().AppendASCII("test.js").value(),
             extension->GetResource("test.js").GetFilePath().value());
 }
 
 
-TEST_F(ExtensionTest, IdIsValid) {
+TEST(ExtensionTest, IdIsValid) {
   EXPECT_TRUE(Extension::IdIsValid("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
   EXPECT_TRUE(Extension::IdIsValid("pppppppppppppppppppppppppppppppp"));
   EXPECT_TRUE(Extension::IdIsValid("abcdefghijklmnopabcdefghijklmnop"));
   EXPECT_TRUE(Extension::IdIsValid("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"));
   EXPECT_FALSE(Extension::IdIsValid("abcdefghijklmnopabcdefghijklmno"));
   EXPECT_FALSE(Extension::IdIsValid("abcdefghijklmnopabcdefghijklmnopa"));
   EXPECT_FALSE(Extension::IdIsValid("0123456789abcdef0123456789abcdef"));
   EXPECT_FALSE(Extension::IdIsValid("abcdefghijklmnopabcdefghijklmnoq"));
   EXPECT_FALSE(Extension::IdIsValid("abcdefghijklmnopabcdefghijklmno0"));
 }
 
 
 // This test ensures that the mimetype sniffing code stays in sync with the
 // actual crx files that we test other parts of the system with.
-TEST_F(ExtensionTest, MimeTypeSniffing) {
+TEST(ExtensionTest, MimeTypeSniffing) {
   base::FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions").AppendASCII("good.crx");
 
   std::string data;
   ASSERT_TRUE(file_util::ReadFileToString(path, &data));
 
   std::string result;
   EXPECT_TRUE(net::SniffMimeType(data.c_str(),
                                  data.size(),
                                  GURL("http://www.example.com/foo.crx"),
                                  std::string(),
                                  &result));
   EXPECT_EQ(std::string(Extension::kMimeType), result);
 
   data.clear();
   result.clear();
   path = path.DirName().AppendASCII("bad_magic.crx");
   ASSERT_TRUE(file_util::ReadFileToString(path, &data));
   EXPECT_TRUE(net::SniffMimeType(data.c_str(),
                                  data.size(),
                                  GURL("http://www.example.com/foo.crx"),
                                  std::string(),
                                  &result));
   EXPECT_EQ("application/octet-stream", result);
 }
 
-TEST_F(ExtensionTest, EffectiveHostPermissions) {
-  (new ContentScriptsHandler)->Register();
+TEST(ExtensionTest, EffectiveHostPermissions) {
   scoped_refptr<Extension> extension;
   URLPatternSet hosts;
 
   extension = LoadManifest("effective_host_permissions", "empty.json");
   EXPECT_EQ(0u, extension->GetEffectiveHostPermissions().patterns().size());
   EXPECT_FALSE(hosts.MatchesURL(GURL("http://www.google.com")));
   EXPECT_FALSE(extension->HasEffectiveAccessToAllHosts());
 
   extension = LoadManifest("effective_host_permissions", "one_host.json");
   hosts = extension->GetEffectiveHostPermissions();
@@ skipping 56 matching lines @@
 
 static bool CheckSocketPermission(scoped_refptr<Extension> extension,
     SocketPermissionRequest::OperationType type,
     const char* host,
     int port) {
   SocketPermission::CheckParam param(type, host, port);
   return extension->CheckAPIPermissionWithParam(
       APIPermission::kSocket, &param);
 }
 
-TEST_F(ExtensionTest, SocketPermissions) {
+TEST(ExtensionTest, SocketPermissions) {
   // Set feature current channel to appropriate value.
   Feature::ScopedCurrentChannel scoped_channel(
       chrome::VersionInfo::CHANNEL_DEV);
   scoped_refptr<Extension> extension;
   std::string error;
 
   extension = LoadManifest("socket_permissions", "empty.json");
   EXPECT_FALSE(CheckSocketPermission(extension,
       SocketPermissionRequest::TCP_CONNECT, "www.example.com", 80));
 
@@ skipping 16 matching lines @@
   EXPECT_FALSE(CheckSocketPermission(
         extension, SocketPermissionRequest::UDP_SEND_TO, "example.com", 1900));
   EXPECT_TRUE(CheckSocketPermission(
         extension,
         SocketPermissionRequest::UDP_SEND_TO,
         "239.255.255.250", 1900));
 }
 
 // This tests the API permissions with an empty manifest (one that just
 // specifies a name and a version and nothing else).
-TEST_F(ExtensionTest, ApiPermissions) {
+TEST(ExtensionTest, ApiPermissions) {
   const struct {
     const char* permission_name;
     bool expect_success;
   } kTests[] = {
     // Negative test.
     { "non_existing_permission", false },
     // Test default module/package permission.
     { "browserAction",  true },
     { "devtools",       true },
     { "extension",      true },
@@ skipping 24 matching lines @@
   scoped_refptr<Extension> extension;
   extension = LoadManifest("empty_manifest", "empty.json");
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
     EXPECT_EQ(kTests[i].expect_success,
               extension->HasAPIPermission(kTests[i].permission_name))
                   << "Permission being tested: " << kTests[i].permission_name;
   }
 }
 
-TEST_F(ExtensionTest, GetPermissionMessages_ManyApiPermissions) {
+TEST(ExtensionTest, GetPermissionMessages_ManyApiPermissions) {
   scoped_refptr<Extension> extension;
   extension = LoadManifest("permissions", "many-apis.json");
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
   ASSERT_EQ(6u, warnings.size());
   EXPECT_EQ("Access your data on api.flickr.com",
             UTF16ToUTF8(warnings[0]));
   EXPECT_EQ("Read and modify your bookmarks", UTF16ToUTF8(warnings[1]));
   EXPECT_EQ("Detect your physical location", UTF16ToUTF8(warnings[2]));
   EXPECT_EQ("Read and modify your browsing history", UTF16ToUTF8(warnings[3]));
   EXPECT_EQ("Access your tabs and browsing activity", UTF16ToUTF8(warnings[4]));
   EXPECT_EQ("Manage your apps, extensions, and themes",
             UTF16ToUTF8(warnings[5]));
 }
 
-TEST_F(ExtensionTest, GetPermissionMessages_LocationApiPermission) {
+TEST(ExtensionTest, GetPermissionMessages_LocationApiPermission) {
   scoped_refptr<Extension> extension;
   extension = LoadManifest("permissions",
                            "location-api.json",
                            Manifest::COMPONENT,
                            Extension::NO_FLAGS);
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Detect your physical location", UTF16ToUTF8(warnings[0]));
 }
 
-TEST_F(ExtensionTest, GetPermissionMessages_ManyHosts) {
-  (new ContentScriptsHandler)->Register();
+TEST(ExtensionTest, GetPermissionMessages_ManyHosts) {
   scoped_refptr<Extension> extension;
   extension = LoadManifest("permissions", "many-hosts.json");
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Access your data on encrypted.google.com and www.google.com",
             UTF16ToUTF8(warnings[0]));
 }
 
-TEST_F(ExtensionTest, GetPermissionMessages_Plugins) {
-  (new PluginsHandler)->Register();
+TEST(ExtensionTest, GetPermissionMessages_Plugins) {
   scoped_refptr<Extension> extension;
   extension = LoadManifest("permissions", "plugins.json");
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
   // We don't parse the plugins key on Chrome OS, so it should not ask for any
   // permissions.
 #if defined(OS_CHROMEOS)
   ASSERT_EQ(0u, warnings.size());
 #else
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Access all data on your computer and the websites you visit",
             UTF16ToUTF8(warnings[0]));
 #endif
 }
 
-TEST_F(ExtensionTest, WantsFileAccess) {
-  (new ContentScriptsHandler)->Register();
+TEST(ExtensionTest, WantsFileAccess) {
   scoped_refptr<Extension> extension;
   GURL file_url("file:///etc/passwd");
 
   // <all_urls> permission
   extension = LoadManifest("permissions", "permissions_all_urls.json");
   EXPECT_TRUE(extension->wants_file_access());
   EXPECT_FALSE(extension->CanExecuteScriptOnPage(
       file_url, file_url, -1, NULL, NULL));
   extension = LoadManifest(
       "permissions", "permissions_all_urls.json", Extension::ALLOW_FILE_ACCESS);
@@ skipping 74 matching lines @@
       Extension::ALLOW_FILE_ACCESS);
   EXPECT_FALSE(extension->wants_file_access());
   EXPECT_FALSE(extension->CanExecuteScriptOnPage(
       file_url,
       file_url,
       -1,
       &ContentScriptsInfo::GetContentScripts(extension)[0],
       NULL));
 }
 
-TEST_F(ExtensionTest, ExtraFlags) {
+TEST(ExtensionTest, ExtraFlags) {
   scoped_refptr<Extension> extension;
   extension = LoadManifest("app", "manifest.json", Extension::FROM_WEBSTORE);
   EXPECT_TRUE(extension->from_webstore());
 
   extension = LoadManifest("app", "manifest.json", Extension::FROM_BOOKMARK);
   EXPECT_TRUE(extension->from_bookmark());
 
   extension = LoadManifest("app", "manifest.json", Extension::NO_FLAGS);
   EXPECT_FALSE(extension->from_bookmark());
   EXPECT_FALSE(extension->from_webstore());
@@ skipping 358 matching lines @@
   EXPECT_TRUE(AllowedExclusivelyOnTab(extension, no_urls, 2));
 
   extension->ClearTabSpecificPermissions(1);
   EXPECT_FALSE(extension->GetTabSpecificPermissions(1).get());
 
   EXPECT_TRUE(AllowedExclusivelyOnTab(extension, no_urls, 0));
   EXPECT_TRUE(AllowedExclusivelyOnTab(extension, no_urls, 1));
   EXPECT_TRUE(AllowedExclusivelyOnTab(extension, no_urls, 2));
 }
 
-TEST_F(ExtensionTest, OptionalOnlyPermission) {
+TEST(ExtensionTest, OptionalOnlyPermission) {
   // Set feature current channel to dev because the only permission that must
   // be optional (usbDevices) is only available on dev channel.
   Feature::ScopedCurrentChannel scoped_channel(
       chrome::VersionInfo::CHANNEL_DEV);
 
   scoped_refptr<Extension> extension;
   std::string error;
   extension = LoadManifestUnchecked("optional_only_permission",
                                     "manifest1.json",
                                     Manifest::INTERNAL, Extension::NO_FLAGS,
                                     &error);
   EXPECT_TRUE(extension == NULL);
   ASSERT_EQ(ErrorUtils::FormatErrorMessage(
         errors::kPermissionMustBeOptional, "usbDevices"), error);
 
   error.clear();
   extension = LoadManifestUnchecked("optional_only_permission",
                                     "manifest2.json",
                                     Manifest::INTERNAL, Extension::NO_FLAGS,
                                     &error);
   EXPECT_TRUE(extension != NULL);
   EXPECT_TRUE(error.empty());
 }
 
 }  // namespace extensions