Move Commands from Extension to CommandsHandler

chrome/common/extensions/extension_unittest.cc

 // Copyright (c) 2012 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.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/extensions/api/commands/commands_handler.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "chrome/common/extensions/command.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/features/feature.h"
+#include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/permissions/api_permission.h"
 #include "chrome/common/extensions/permissions/permission_set.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 "googleurl/src/gurl.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mock_host_resolver.h"
 #include "skia/ext/image_operations.h"
@@ skipping 81 matching lines @@
   std::string error;
   scoped_refptr<Extension> extension = LoadManifestUnchecked("page_action",
       manifest, Extension::INTERNAL, Extension::NO_FLAGS, &error);
   EXPECT_FALSE(extension);
   EXPECT_EQ(expected_error, error);
 }
 
 }
 
 class ExtensionTest : public testing::Test {
+ protected:
+  virtual void SetUp() OVERRIDE {
+    ManifestHandler::Register(extension_manifest_keys::kCommands,
+                              new CommandsHandler);
+  }
 };
 
 // We persist location values in the preferences, so this is a sanity test that
 // someone doesn't accidentally change them.
-TEST(ExtensionTest, LocationValuesTest) {
+TEST_F(ExtensionTest, LocationValuesTest) {
   ASSERT_EQ(0, Extension::INVALID);
   ASSERT_EQ(1, Extension::INTERNAL);
   ASSERT_EQ(2, Extension::EXTERNAL_PREF);
   ASSERT_EQ(3, Extension::EXTERNAL_REGISTRY);
   ASSERT_EQ(4, Extension::LOAD);
   ASSERT_EQ(5, Extension::COMPONENT);
   ASSERT_EQ(6, Extension::EXTERNAL_PREF_DOWNLOAD);
   ASSERT_EQ(7, Extension::EXTERNAL_POLICY_DOWNLOAD);
 }
 
-TEST(ExtensionTest, LocationPriorityTest) {
+TEST_F(ExtensionTest, LocationPriorityTest) {
   for (int i = 0; i < Extension::NUM_LOCATIONS; i++) {
     Extension::Location loc = static_cast<Extension::Location>(i);
 
     // INVALID is not a valid location.
     if (loc == Extension::INVALID)
       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 @@
             Extension::GetHigherPriorityLocation(
                 Extension::EXTERNAL_POLICY_DOWNLOAD,
                 Extension::EXTERNAL_PREF));
 
   ASSERT_EQ(Extension::EXTERNAL_PREF,
             Extension::GetHigherPriorityLocation(
                 Extension::INTERNAL,
                 Extension::EXTERNAL_PREF));
 }
 
-TEST(ExtensionTest, GetResourceURLAndPath) {
+TEST_F(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(ExtensionTest, GetAbsolutePathNoError) {
+TEST_F(ExtensionTest, GetAbsolutePathNoError) {
   scoped_refptr<Extension> extension = LoadManifestStrict("absolute_path",
       "absolute.json");
   EXPECT_TRUE(extension.get());
   std::string err;
   Extension::InstallWarningVector 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(ExtensionTest, LoadPageActionHelper) {
+TEST_F(ExtensionTest, LoadPageActionHelper) {
   scoped_ptr<ActionInfo> action;
 
   // First try with an empty dictionary.
   action = LoadAction("page_action_empty.json");
   ASSERT_TRUE(action != NULL);
 
   // Now setup some values to use in the action.
   const std::string id("MyExtensionActionId");
   const std::string name("MyExtensionActionName");
   std::string img1("image1.png");
@@ skipping 86 matching lines @@
   // Setting popup to "" is the same as having no popup.
   action = LoadAction("page_action_empty_popup.json");
 
   ASSERT_TRUE(NULL != action.get());
   EXPECT_TRUE(action->default_popup_url.is_empty());
   ASSERT_STREQ(
       "",
       action->default_popup_url.spec().c_str());
 }
 
-TEST(ExtensionTest, IdIsValid) {
+TEST_F(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"));
 }
 
-TEST(ExtensionTest, GenerateID) {
+TEST_F(ExtensionTest, GenerateID) {
   const uint8 public_key_info[] = {
     0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
     0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, 0x81,
     0x89, 0x02, 0x81, 0x81, 0x00, 0xb8, 0x7f, 0x2b, 0x20, 0xdc, 0x7c, 0x9b,
     0x0c, 0xdc, 0x51, 0x61, 0x99, 0x0d, 0x36, 0x0f, 0xd4, 0x66, 0x88, 0x08,
     0x55, 0x84, 0xd5, 0x3a, 0xbf, 0x2b, 0xa4, 0x64, 0x85, 0x7b, 0x0c, 0x04,
     0x13, 0x3f, 0x8d, 0xf4, 0xbc, 0x38, 0x0d, 0x49, 0xfe, 0x6b, 0xc4, 0x5a,
     0xb0, 0x40, 0x53, 0x3a, 0xd7, 0x66, 0x09, 0x0f, 0x9e, 0x36, 0x74, 0x30,
     0xda, 0x8a, 0x31, 0x4f, 0x1f, 0x14, 0x50, 0xd7, 0xc7, 0x20, 0x94, 0x17,
     0xde, 0x4e, 0xb9, 0x57, 0x5e, 0x7e, 0x0a, 0xe5, 0xb2, 0x65, 0x7a, 0x89,
     0x4e, 0xb6, 0x47, 0xff, 0x1c, 0xbd, 0xb7, 0x38, 0x13, 0xaf, 0x47, 0x85,
     0x84, 0x32, 0x33, 0xf3, 0x17, 0x49, 0xbf, 0xe9, 0x96, 0xd0, 0xd6, 0x14,
     0x6f, 0x13, 0x8d, 0xc5, 0xfc, 0x2c, 0x72, 0xba, 0xac, 0xea, 0x7e, 0x18,
     0x53, 0x56, 0xa6, 0x83, 0xa2, 0xce, 0x93, 0x93, 0xe7, 0x1f, 0x0f, 0xe6,
     0x0f, 0x02, 0x03, 0x01, 0x00, 0x01
   };
 
   std::string extension_id;
   EXPECT_TRUE(
       Extension::GenerateId(
           std::string(reinterpret_cast<const char*>(&public_key_info[0]),
                       arraysize(public_key_info)),
           &extension_id));
   EXPECT_EQ("melddjfinppjdikinhbgehiennejpfhp", extension_id);
 }
 
 // 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(ExtensionTest, MimeTypeSniffing) {
+TEST_F(ExtensionTest, MimeTypeSniffing) {
   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"), "", &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"), "", &result));
   EXPECT_EQ("application/octet-stream", result);
 }
 
-TEST(ExtensionTest, EffectiveHostPermissions) {
+TEST_F(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(ExtensionTest, SocketPermissions) {
+TEST_F(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 26 matching lines @@
   return skia::ImageOperations::Resize(source,
                                        skia::ImageOperations::RESIZE_LANCZOS3,
                                        size,
                                        size);
 }
 
 static bool SizeEquals(const SkBitmap& bitmap, const gfx::Size& size) {
   return bitmap.width() == size.width() && bitmap.height() == size.height();
 }
 
-TEST(ExtensionTest, ImageCaching) {
+TEST_F(ExtensionTest, ImageCaching) {
   FilePath path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
   path = path.AppendASCII("extensions");
 
   // Initialize the Extension.
   std::string errors;
   DictionaryValue values;
   values.SetString(keys::kName, "test");
   values.SetString(keys::kVersion, "0.1");
   scoped_refptr<Extension> extension(Extension::Create(
@@ skipping 53 matching lines @@
   EXPECT_TRUE(SizeEquals(extension->GetCachedImage(resource, original_size),
                          original_size));
   EXPECT_TRUE(SizeEquals(extension->GetCachedImage(resource, size128),
                          original_size));
   EXPECT_EQ(extension->GetCachedImage(resource, original_size).getPixels(),
             extension->GetCachedImage(resource, size128).getPixels());
 }
 
 // This tests the API permissions with an empty manifest (one that just
 // specifies a name and a version and nothing else).
-TEST(ExtensionTest, ApiPermissions) {
+TEST_F(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(ExtensionTest, GetPermissionMessages_ManyApiPermissions) {
+TEST_F(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(ExtensionTest, GetPermissionMessages_ManyHosts) {
+TEST_F(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(ExtensionTest, GetPermissionMessages_Plugins) {
+TEST_F(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(ExtensionTest, WantsFileAccess) {
+TEST_F(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 50 matching lines @@
   EXPECT_FALSE(extension->wants_file_access());
   EXPECT_FALSE(extension->CanExecuteScriptOnPage(
       file_url, file_url, -1, &extension->content_scripts()[0], NULL));
   extension = LoadManifest("permissions", "content_script_http_scheme.json",
       Extension::ALLOW_FILE_ACCESS);
   EXPECT_FALSE(extension->wants_file_access());
   EXPECT_FALSE(extension->CanExecuteScriptOnPage(
       file_url, file_url, -1, &extension->content_scripts()[0], NULL));
 }
 
-TEST(ExtensionTest, ExtraFlags) {
+TEST_F(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());
 }
 
-TEST(ExtensionTest, BrowserActionSynthesizesCommand) {
+TEST_F(ExtensionTest, BrowserActionSynthesizesCommand) {
   scoped_refptr<Extension> extension;
 
   extension = LoadManifest("api_test/browser_action/synthesized",
                            "manifest.json");
   // An extension with a browser action but no extension command specified
   // should get a command assigned to it.
-  const Command* command = extension->browser_action_command();
+  const extensions::Command* command =
+      CommandsInfo::GetBrowserActionCommand(extension);
   ASSERT_TRUE(command != NULL);
   ASSERT_EQ(ui::VKEY_UNKNOWN, command->accelerator().key_code());
 }
 
 // Base class for testing the CanExecuteScriptOnPage and CanCaptureVisiblePage
 // methods of Extension for extensions with various permissions.
 class ExtensionScriptAndCaptureVisibleTest : public testing::Test {
  protected:
   ExtensionScriptAndCaptureVisibleTest()
       : http_url("http://www.google.com"),
@@ skipping 253 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(ExtensionTest, GenerateId) {
+TEST_F(ExtensionTest, GenerateId) {
   std::string result;
   EXPECT_TRUE(Extension::GenerateId("", &result));
 
   EXPECT_TRUE(Extension::GenerateId("test", &result));
   EXPECT_EQ(result, "jpignaibiiemhngfjkcpokkamffknabf");
 
   EXPECT_TRUE(Extension::GenerateId("_", &result));
   EXPECT_EQ(result, "ncocknphbhhlhkikpnnlmbcnbgdempcd");
 
   EXPECT_TRUE(Extension::GenerateId(
@@ skipping 52 matching lines @@
   EXPECT_EQ("", error);
   return extension;
 }
 
 static const char kValidUpdateUrl1[] =
     "http://clients2.google.com/service/update2/crx";
 static const char kValidUpdateUrl2[] =
     "https://clients2.google.com/service/update2/crx";
 }
 
-TEST(ExtensionTest, GetSyncTypeNormalExtensionNoUpdateUrl) {
+TEST_F(ExtensionTest, GetSyncTypeNormalExtensionNoUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_NE(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
-TEST(ExtensionTest, GetSyncTypeUserScriptValidUpdateUrl) {
+TEST_F(ExtensionTest, GetSyncTypeUserScriptValidUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(USER_SCRIPT, GURL(kValidUpdateUrl1), GURL(),
                             Extension::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_NE(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
-TEST(ExtensionTest, GetSyncTypeUserScriptNoUpdateUrl) {
+TEST_F(ExtensionTest, GetSyncTypeUserScriptNoUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(USER_SCRIPT, GURL(), GURL(),
                             Extension::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
-TEST(ExtensionTest, GetSyncTypeThemeNoUpdateUrl) {
+TEST_F(ExtensionTest, GetSyncTypeThemeNoUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(THEME, GURL(), GURL(),
                             Extension::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
-TEST(ExtensionTest, GetSyncTypeExtensionWithLaunchUrl) {
+TEST_F(ExtensionTest, GetSyncTypeExtensionWithLaunchUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL("http://www.google.com"),
                             Extension::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_NE(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
-TEST(ExtensionTest, GetSyncTypeExtensionExternal) {
+TEST_F(ExtensionTest, GetSyncTypeExtensionExternal) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::EXTERNAL_PREF, 0, FilePath(),
                             Extension::NO_FLAGS));
 
   EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
-TEST(ExtensionTest, GetSyncTypeUserScriptThirdPartyUpdateUrl) {
+TEST_F(ExtensionTest, GetSyncTypeUserScriptThirdPartyUpdateUrl) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(
           USER_SCRIPT, GURL("http://third-party.update_url.com"), GURL(),
           Extension::INTERNAL, 0, FilePath(), Extension::NO_FLAGS));
   EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
-TEST(ExtensionTest, OnlyDisplayAppsInLauncher) {
+TEST_F(ExtensionTest, OnlyDisplayAppsInLauncher) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
 
   EXPECT_FALSE(extension->ShouldDisplayInAppLauncher());
   EXPECT_FALSE(extension->ShouldDisplayInNewTabPage());
 
   scoped_refptr<Extension> app(
       MakeSyncTestExtension(APP, GURL(), GURL("http://www.google.com"),
                             Extension::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_TRUE(app->ShouldDisplayInAppLauncher());
   EXPECT_TRUE(app->ShouldDisplayInNewTabPage());
 }
 
-TEST(ExtensionTest, DisplayInXManifestProperties) {
+TEST_F(ExtensionTest, DisplayInXManifestProperties) {
   DictionaryValue manifest;
   manifest.SetString(keys::kName, "TestComponentApp");
   manifest.SetString(keys::kVersion, "0.0.0.0");
   manifest.SetString(keys::kApp, "true");
   manifest.SetString(keys::kPlatformAppBackgroundPage, "");
 
   std::string error;
   scoped_refptr<Extension> app;
 
   // Default to true.
@@ skipping 28 matching lines @@
   EXPECT_TRUE(app->ShouldDisplayInAppLauncher());
   EXPECT_FALSE(app->ShouldDisplayInNewTabPage());
 
   // Error checking.
   manifest.SetString(keys::kDisplayInNewTabPage, "invalid");
   app = Extension::Create(
       FilePath(), Extension::COMPONENT, manifest, 0, &error);
   EXPECT_EQ(error, std::string(errors::kInvalidDisplayInNewTabPage));
 }
 
-TEST(ExtensionTest, OnlySyncInternal) {
+TEST_F(ExtensionTest, OnlySyncInternal) {
   scoped_refptr<Extension> extension_internal(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::INTERNAL, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_TRUE(extension_internal->IsSyncable());
 
   scoped_refptr<Extension> extension_noninternal(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::COMPONENT, 0, FilePath(),
                             Extension::NO_FLAGS));
   EXPECT_FALSE(extension_noninternal->IsSyncable());
 }
 
-TEST(ExtensionTest, DontSyncDefault) {
+TEST_F(ExtensionTest, DontSyncDefault) {
   scoped_refptr<Extension> extension_default(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::INTERNAL, 0, FilePath(),
                             Extension::WAS_INSTALLED_BY_DEFAULT));
   EXPECT_FALSE(extension_default->IsSyncable());
 }
 
-TEST(ExtensionTest, OptionalOnlyPermission) {
+TEST_F(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",
                                     Extension::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",
                                     Extension::INTERNAL, Extension::NO_FLAGS,
                                     &error);
   EXPECT_TRUE(extension != NULL);
   EXPECT_TRUE(error.empty());
 }
 
 // These last 2 tests don't make sense on Chrome OS, where extension plugins
 // are not allowed.
 #if !defined(OS_CHROMEOS)
-TEST(ExtensionTest, GetSyncTypeExtensionWithPlugin) {
+TEST_F(ExtensionTest, GetSyncTypeExtensionWithPlugin) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::INTERNAL, 1, FilePath(),
                             Extension::NO_FLAGS));
   if (extension)
     EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 
-TEST(ExtensionTest, GetSyncTypeExtensionWithTwoPlugins) {
+TEST_F(ExtensionTest, GetSyncTypeExtensionWithTwoPlugins) {
   scoped_refptr<Extension> extension(
       MakeSyncTestExtension(EXTENSION, GURL(), GURL(),
                             Extension::INTERNAL, 2, FilePath(),
                             Extension::NO_FLAGS));
   if (extension)
     EXPECT_EQ(extension->GetSyncType(), Extension::SYNC_TYPE_NONE);
 }
 #endif // !defined(OS_CHROMEOS)
 
 }  // namespace extensions