Consolidate manifest handler registration.

chrome/common/extensions/permissions/permission_set_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 "base/command_line.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/path_service.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/extension.h"
 #include "chrome/common/extensions/extension_test_util.h"
-#include "chrome/common/extensions/extension_unittest.h"
 #include "chrome/common/extensions/features/feature.h"
-#include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/extensions/permissions/socket_permission.h"
 #include "extensions/common/error_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extension_test_util::LoadManifest;
 
 namespace extensions {
 
@@ skipping 14 matching lines @@
   return warnings.size();
 }
 
 bool Contains(const std::vector<string16>& warnings,
               const std::string& warning) {
   return IndexOf(warnings, warning) != warnings.size();
 }
 
 }  // namespace
 
-class PermissionsTest : public ExtensionTest {
- protected:
-  virtual void SetUp() OVERRIDE {
-    ExtensionTest::SetUp();
-    (new ContentScriptsHandler)->Register();
-    (new PluginsHandler)->Register();
-  }
-
-  virtual void TearDown() OVERRIDE {
-    ExtensionTest::TearDown();
-  }
-};
-
 // Tests GetByID.
-TEST_F(PermissionsTest, GetByID) {
+TEST(PermissionsTest, GetByID) {
   PermissionsInfo* info = PermissionsInfo::GetInstance();
   APIPermissionSet apis = info->GetAll();
   for (APIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
     EXPECT_EQ(i->id(), i->info()->id());
   }
 }
 
 // Tests that GetByName works with normal permission names and aliases.
-TEST_F(PermissionsTest, GetByName) {
+TEST(PermissionsTest, GetByName) {
   PermissionsInfo* info = PermissionsInfo::GetInstance();
   EXPECT_EQ(APIPermission::kTab, info->GetByName("tabs")->id());
   EXPECT_EQ(APIPermission::kManagement,
             info->GetByName("management")->id());
   EXPECT_FALSE(info->GetByName("alsdkfjasldkfj"));
 }
 
-TEST_F(PermissionsTest, GetAll) {
+TEST(PermissionsTest, GetAll) {
   size_t count = 0;
   PermissionsInfo* info = PermissionsInfo::GetInstance();
   APIPermissionSet apis = info->GetAll();
   for (APIPermissionSet::const_iterator api = apis.begin();
        api != apis.end(); ++api) {
     // Make sure only the valid permission IDs get returned.
     EXPECT_NE(APIPermission::kInvalid, api->id());
     EXPECT_NE(APIPermission::kUnknown, api->id());
     count++;
   }
   EXPECT_EQ(count, info->get_permission_count());
 }
 
-TEST_F(PermissionsTest, GetAllByName) {
+TEST(PermissionsTest, GetAllByName) {
   std::set<std::string> names;
   names.insert("background");
   names.insert("management");
 
   // This is an alias of kTab
   names.insert("windows");
 
   // This unknown name should get dropped.
   names.insert("sdlkfjasdlkfj");
 
   APIPermissionSet expected;
   expected.insert(APIPermission::kBackground);
   expected.insert(APIPermission::kManagement);
   expected.insert(APIPermission::kTab);
 
   EXPECT_EQ(expected,
             PermissionsInfo::GetInstance()->GetAllByName(names));
 }
 
 // Tests that the aliases are properly mapped.
-TEST_F(PermissionsTest, Aliases) {
+TEST(PermissionsTest, Aliases) {
   PermissionsInfo* info = PermissionsInfo::GetInstance();
   // tabs: tabs, windows
   std::string tabs_name = "tabs";
   EXPECT_EQ(tabs_name, info->GetByID(APIPermission::kTab)->name());
   EXPECT_EQ(APIPermission::kTab, info->GetByName("tabs")->id());
   EXPECT_EQ(APIPermission::kTab, info->GetByName("windows")->id());
 
   // unlimitedStorage: unlimitedStorage, unlimited_storage
   std::string storage_name = "unlimitedStorage";
   EXPECT_EQ(storage_name, info->GetByID(
       APIPermission::kUnlimitedStorage)->name());
   EXPECT_EQ(APIPermission::kUnlimitedStorage,
             info->GetByName("unlimitedStorage")->id());
   EXPECT_EQ(APIPermission::kUnlimitedStorage,
             info->GetByName("unlimited_storage")->id());
 }
 
-TEST_F(PermissionsTest, EffectiveHostPermissions) {
+TEST(PermissionsTest, EffectiveHostPermissions) {
   scoped_refptr<Extension> extension;
   scoped_refptr<const PermissionSet> permissions;
 
   extension = LoadManifest("effective_host_permissions", "empty.json");
   permissions = extension->GetActivePermissions();
   EXPECT_EQ(0u, extension->GetEffectiveHostPermissions().patterns().size());
   EXPECT_FALSE(permissions->HasEffectiveAccessToURL(
       GURL("http://www.google.com")));
   EXPECT_FALSE(permissions->HasEffectiveAccessToAllHosts());
 
@@ skipping 55 matching lines @@
 
   extension = LoadManifest("effective_host_permissions", "all_hosts3.json");
   permissions = extension->GetActivePermissions();
   EXPECT_FALSE(permissions->HasEffectiveAccessToURL(GURL("http://test/")));
   EXPECT_TRUE(permissions->HasEffectiveAccessToURL(GURL("https://test/")));
   EXPECT_TRUE(
       permissions->HasEffectiveAccessToURL(GURL("http://www.google.com")));
   EXPECT_TRUE(permissions->HasEffectiveAccessToAllHosts());
 }
 
-TEST_F(PermissionsTest, ExplicitAccessToOrigin) {
+TEST(PermissionsTest, ExplicitAccessToOrigin) {
   APIPermissionSet apis;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
 
   AddPattern(&explicit_hosts, "http://*.google.com/*");
   // The explicit host paths should get set to /*.
   AddPattern(&explicit_hosts, "http://www.example.com/a/particular/path/*");
 
   scoped_refptr<PermissionSet> perm_set = new PermissionSet(
       apis, explicit_hosts, scriptable_hosts);
   ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
       GURL("http://www.google.com/")));
   ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
       GURL("http://test.google.com/")));
   ASSERT_TRUE(perm_set->HasExplicitAccessToOrigin(
       GURL("http://www.example.com")));
   ASSERT_TRUE(perm_set->HasEffectiveAccessToURL(
       GURL("http://www.example.com")));
   ASSERT_FALSE(perm_set->HasExplicitAccessToOrigin(
       GURL("http://test.example.com")));
 }
 
-TEST_F(PermissionsTest, CreateUnion) {
+TEST(PermissionsTest, CreateUnion) {
   APIPermission* permission = NULL;
 
   APIPermissionSet apis1;
   APIPermissionSet apis2;
   APIPermissionSet expected_apis;
 
   URLPatternSet explicit_hosts1;
   URLPatternSet explicit_hosts2;
   URLPatternSet expected_explicit_hosts;
 
@@ skipping 103 matching lines @@
   EXPECT_TRUE(union_set->Contains(*set2));
 
   EXPECT_TRUE(union_set->HasEffectiveFullAccess());
   EXPECT_TRUE(union_set->HasEffectiveAccessToAllHosts());
   EXPECT_EQ(expected_apis, union_set->apis());
   EXPECT_EQ(expected_explicit_hosts, union_set->explicit_hosts());
   EXPECT_EQ(expected_scriptable_hosts, union_set->scriptable_hosts());
   EXPECT_EQ(effective_hosts, union_set->effective_hosts());
 }
 
-TEST_F(PermissionsTest, CreateIntersection) {
+TEST(PermissionsTest, CreateIntersection) {
   APIPermission* permission = NULL;
 
   APIPermissionSet apis1;
   APIPermissionSet apis2;
   APIPermissionSet expected_apis;
 
   URLPatternSet explicit_hosts1;
   URLPatternSet explicit_hosts2;
   URLPatternSet expected_explicit_hosts;
 
@@ skipping 93 matching lines @@
   EXPECT_FALSE(new_set->Contains(*set2));
 
   EXPECT_FALSE(new_set->HasEffectiveFullAccess());
   EXPECT_FALSE(new_set->HasEffectiveAccessToAllHosts());
   EXPECT_EQ(expected_apis, new_set->apis());
   EXPECT_EQ(expected_explicit_hosts, new_set->explicit_hosts());
   EXPECT_EQ(expected_scriptable_hosts, new_set->scriptable_hosts());
   EXPECT_EQ(effective_hosts, new_set->effective_hosts());
 }
 
-TEST_F(PermissionsTest, CreateDifference) {
+TEST(PermissionsTest, CreateDifference) {
   APIPermission* permission = NULL;
 
   APIPermissionSet apis1;
   APIPermissionSet apis2;
   APIPermissionSet expected_apis;
 
   URLPatternSet explicit_hosts1;
   URLPatternSet explicit_hosts2;
   URLPatternSet expected_explicit_hosts;
 
@@ skipping 80 matching lines @@
   EXPECT_EQ(expected_apis, new_set->apis());
   EXPECT_EQ(expected_explicit_hosts, new_set->explicit_hosts());
   EXPECT_EQ(expected_scriptable_hosts, new_set->scriptable_hosts());
   EXPECT_EQ(effective_hosts, new_set->effective_hosts());
 
   // |set3| = |set1| - |set2| --> |set3| intersect |set2| == empty_set
   set1 = PermissionSet::CreateIntersection(new_set.get(), set2.get());
   EXPECT_TRUE(set1->IsEmpty());
 }
 
-TEST_F(PermissionsTest, HasLessPrivilegesThan) {
+TEST(PermissionsTest, HasLessPrivilegesThan) {
   const struct {
     const char* base_name;
     bool expect_increase;
   } kTests[] = {
     { "allhosts1", false },  // all -> all
     { "allhosts2", false },  // all -> one
     { "allhosts3", true },  // one -> all
     { "hosts1", false },  // http://a,http://b -> http://a,http://b
     { "hosts2", true },  // http://a,http://b -> https://a,http://*.b
     { "hosts3", false },  // http://a,http://b -> http://a
@@ skipping 30 matching lines @@
     scoped_refptr<const PermissionSet> old_p(
         old_extension->GetActivePermissions());
     scoped_refptr<const PermissionSet> new_p(
         new_extension->GetActivePermissions());
 
     EXPECT_EQ(kTests[i].expect_increase,
               old_p->HasLessPrivilegesThan(new_p)) << kTests[i].base_name;
   }
 }
 
-TEST_F(PermissionsTest, PermissionMessages) {
+TEST(PermissionsTest, PermissionMessages) {
   // Ensure that all permissions that needs to show install UI actually have
   // strings associated with them.
   APIPermissionSet skip;
 
   // These are considered "nuisance" or "trivial" permissions that don't need
   // a prompt.
   skip.insert(APIPermission::kActiveTab);
   skip.insert(APIPermission::kAdView);
   skip.insert(APIPermission::kAlarms);
   skip.insert(APIPermission::kAppCurrentWindowInternal);
@@ skipping 101 matching lines @@
       EXPECT_EQ(PermissionMessage::kNone, permission_info->message_id())
           << "unexpected message_id for " << permission_info->name();
     } else {
       EXPECT_NE(PermissionMessage::kNone, permission_info->message_id())
           << "missing message_id for " << permission_info->name();
     }
   }
 }
 
 // Tests the default permissions (empty API permission set).
-TEST_F(PermissionsTest, DefaultFunctionAccess) {
+TEST(PermissionsTest, DefaultFunctionAccess) {
   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 18 matching lines @@
 
   scoped_refptr<PermissionSet> empty = new PermissionSet();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
     EXPECT_EQ(kTests[i].expect_success,
               empty->HasAccessToFunction(kTests[i].permission_name, true))
                   << "Permission being tested: " << kTests[i].permission_name;
   }
 }
 
 // Tests the default permissions (empty API permission set).
-TEST_F(PermissionsTest, DefaultAnyAPIAccess) {
+TEST(PermissionsTest, DefaultAnyAPIAccess) {
   const struct {
     const char* api_name;
     bool expect_success;
   } kTests[] = {
     // Negative test.
     { "non_existing_permission", false },
     // Test default module/package permission.
     { "browserAction",  true },
     { "devtools",       true },
     { "extension",      true },
@@ skipping 10 matching lines @@
     { "tabs",           true},
   };
 
   scoped_refptr<PermissionSet> empty = new PermissionSet();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
     EXPECT_EQ(kTests[i].expect_success,
               empty->HasAnyAccessToAPI(kTests[i].api_name));
   }
 }
 
-TEST_F(PermissionsTest, GetWarningMessages_ManyHosts) {
+TEST(PermissionsTest, GetWarningMessages_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(PermissionsTest, GetWarningMessages_Plugins) {
+TEST(PermissionsTest, GetWarningMessages_Plugins) {
   scoped_refptr<Extension> extension;
   scoped_refptr<PermissionSet> permissions;
 
   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(PermissionsTest, GetWarningMessages_AudioVideo) {
+TEST(PermissionsTest, GetWarningMessages_AudioVideo) {
   // Both audio and video present.
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "audio-video.json");
   PermissionSet* set =
       const_cast<PermissionSet*>(
           extension->GetActivePermissions().get());
   std::vector<string16> warnings =
       set->GetWarningMessages(extension->GetType());
   EXPECT_FALSE(Contains(warnings, "Use your microphone"));
   EXPECT_FALSE(Contains(warnings, "Use your camera"));
@@ skipping 12 matching lines @@
   // Just video present.
   set->apis_.erase(APIPermission::kAudioCapture);
   set->apis_.insert(APIPermission::kVideoCapture);
   warnings = set->GetWarningMessages(extension->GetType());
   EXPECT_EQ(combined_size, warnings.size());
   EXPECT_FALSE(Contains(warnings, "Use your microphone"));
   EXPECT_FALSE(Contains(warnings, "Use your microphone and camera"));
   EXPECT_TRUE(Contains(warnings, "Use your camera"));
 }
 
-TEST_F(PermissionsTest, GetWarningMessages_Serial) {
+TEST(PermissionsTest, GetWarningMessages_Serial) {
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "serial.json");
 
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSerial));
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
   EXPECT_TRUE(Contains(warnings,
                        "Use serial devices attached to your computer"));
   ASSERT_EQ(1u, warnings.size());
 }
 
-TEST_F(PermissionsTest, GetWarningMessages_Socket_AnyHost) {
+TEST(PermissionsTest, GetWarningMessages_Socket_AnyHost) {
   Feature::ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
 
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "socket_any_host.json");
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSocket));
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
   EXPECT_EQ(1u, warnings.size());
   EXPECT_TRUE(Contains(warnings, "Exchange data with any computer "
                                  "on the local network or internet"));
 }
 
-TEST_F(PermissionsTest, GetWarningMessages_Socket_OneDomainTwoHostnames) {
+TEST(PermissionsTest, GetWarningMessages_Socket_OneDomainTwoHostnames) {
   Feature::ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
 
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "socket_one_domain_two_hostnames.json");
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSocket));
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
 
   // Verify the warnings, including support for unicode characters, the fact
   // that domain host warnings come before specific host warnings, and the fact
   // that domains and hostnames are in alphabetical order regardless of the
   // order in the manifest file.
   EXPECT_EQ(2u, warnings.size());
   if (warnings.size() > 0)
     EXPECT_EQ(warnings[0],
               UTF8ToUTF16("Exchange data with any computer in the domain "
                           "example.org"));
   if (warnings.size() > 1)
     EXPECT_EQ(warnings[1],
               UTF8ToUTF16("Exchange data with the computers named: "
                           "b\xC3\xA5r.example.com foo.example.com"));
                           // "\xC3\xA5" = UTF-8 for lowercase A with ring above
 }
 
-TEST_F(PermissionsTest, GetWarningMessages_Socket_TwoDomainsOneHostname) {
+TEST(PermissionsTest, GetWarningMessages_Socket_TwoDomainsOneHostname) {
   Feature::ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
 
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "socket_two_domains_one_hostname.json");
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSocket));
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
 
   // Verify the warnings, including the fact that domain host warnings come
   // before specific host warnings and the fact that domains and hostnames are
   // in alphabetical order regardless of the order in the manifest file.
   EXPECT_EQ(2u, warnings.size());
   if (warnings.size() > 0)
     EXPECT_EQ(warnings[0],
               UTF8ToUTF16("Exchange data with any computer in the domains: "
                            "example.com foo.example.org"));
   if (warnings.size() > 1)
     EXPECT_EQ(warnings[1],
               UTF8ToUTF16("Exchange data with the computer named "
                            "bar.example.org"));
 }
 
-TEST_F(PermissionsTest, GetWarningMessages_PlatformApppHosts) {
+TEST(PermissionsTest, GetWarningMessages_PlatformApppHosts) {
   scoped_refptr<Extension> extension;
 
   extension = LoadManifest("permissions", "platform_app_hosts.json");
   EXPECT_TRUE(extension->is_platform_app());
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
   ASSERT_EQ(0u, warnings.size());
 
   extension = LoadManifest("permissions", "platform_app_all_urls.json");
   EXPECT_TRUE(extension->is_platform_app());
   warnings = extension->GetPermissionMessageStrings();
   ASSERT_EQ(0u, warnings.size());
 }
 
-TEST_F(PermissionsTest, GetDistinctHostsForDisplay) {
+TEST(PermissionsTest, GetDistinctHostsForDisplay) {
   scoped_refptr<PermissionSet> perm_set;
   APIPermissionSet empty_perms;
   std::set<std::string> expected;
   expected.insert("www.foo.com");
   expected.insert("www.bar.com");
   expected.insert("www.baz.com");
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
 
   {
@@ skipping 135 matching lines @@
 
     explicit_hosts.AddPattern(
         URLPattern(URLPattern::SCHEME_FILE, "file:///*"));
 
     perm_set = new PermissionSet(
         empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 }
 
-TEST_F(PermissionsTest, GetDistinctHostsForDisplay_ComIsBestRcd) {
+TEST(PermissionsTest, GetDistinctHostsForDisplay_ComIsBestRcd) {
   scoped_refptr<PermissionSet> perm_set;
   APIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.org/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.net/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.com/path"));
 
   std::set<std::string> expected;
   expected.insert("www.foo.com");
   perm_set = new PermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
-TEST_F(PermissionsTest, GetDistinctHostsForDisplay_NetIs2ndBestRcd) {
+TEST(PermissionsTest, GetDistinctHostsForDisplay_NetIs2ndBestRcd) {
   scoped_refptr<PermissionSet> perm_set;
   APIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.org/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.net/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
   // No http://www.foo.com/path
 
   std::set<std::string> expected;
   expected.insert("www.foo.net");
   perm_set = new PermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
-TEST_F(PermissionsTest,
+TEST(PermissionsTest,
      GetDistinctHostsForDisplay_OrgIs3rdBestRcd) {
   scoped_refptr<PermissionSet> perm_set;
   APIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.org/path"));
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
   // No http://www.foo.net/path
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
   // No http://www.foo.com/path
 
   std::set<std::string> expected;
   expected.insert("www.foo.org");
   perm_set = new PermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
-TEST_F(PermissionsTest,
+TEST(PermissionsTest,
      GetDistinctHostsForDisplay_FirstInListIs4thBestRcd) {
   scoped_refptr<PermissionSet> perm_set;
   APIPermissionSet empty_perms;
   URLPatternSet explicit_hosts;
   URLPatternSet scriptable_hosts;
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.ca/path"));
   // No http://www.foo.org/path
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.co.uk/path"));
   // No http://www.foo.net/path
   explicit_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.foo.jp/path"));
   // No http://www.foo.com/path
 
   std::set<std::string> expected;
   expected.insert("www.foo.ca");
   perm_set = new PermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
-TEST_F(PermissionsTest, HasLessHostPrivilegesThan) {
+TEST(PermissionsTest, HasLessHostPrivilegesThan) {
   URLPatternSet elist1;
   URLPatternSet elist2;
   URLPatternSet slist1;
   URLPatternSet slist2;
   scoped_refptr<PermissionSet> set1;
   scoped_refptr<PermissionSet> set2;
   APIPermissionSet empty_perms;
   elist1.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com.hk/path"));
   elist1.AddPattern(
@@ skipping 48 matching lines @@
 
   // Test that different subdomains count as different hosts.
   elist2.ClearPatterns();
   elist2.AddPattern(
       URLPattern(URLPattern::SCHEME_HTTP, "http://mail.google.com/*"));
   set2 = new PermissionSet(empty_perms, elist2, slist2);
   EXPECT_TRUE(set1->HasLessHostPrivilegesThan(set2.get()));
   EXPECT_TRUE(set2->HasLessHostPrivilegesThan(set1.get()));
 }
 
-TEST_F(PermissionsTest, GetAPIsAsStrings) {
+TEST(PermissionsTest, GetAPIsAsStrings) {
   APIPermissionSet apis;
   URLPatternSet empty_set;
 
   apis.insert(APIPermission::kProxy);
   apis.insert(APIPermission::kBackground);
   apis.insert(APIPermission::kNotification);
   apis.insert(APIPermission::kTab);
 
   scoped_refptr<PermissionSet> perm_set = new PermissionSet(
       apis, empty_set, empty_set);
   std::set<std::string> api_names = perm_set->GetAPIsAsStrings();
 
   // The result is correct if it has the same number of elements
   // and we can convert it back to the id set.
   EXPECT_EQ(4u, api_names.size());
   EXPECT_EQ(apis,
             PermissionsInfo::GetInstance()->GetAllByName(api_names));
 }
 
-TEST_F(PermissionsTest, IsEmpty) {
+TEST(PermissionsTest, IsEmpty) {
   APIPermissionSet empty_apis;
   URLPatternSet empty_extent;
 
   scoped_refptr<PermissionSet> empty = new PermissionSet();
   EXPECT_TRUE(empty->IsEmpty());
   scoped_refptr<PermissionSet> perm_set;
 
   perm_set = new PermissionSet(empty_apis, empty_extent, empty_extent);
   EXPECT_TRUE(perm_set->IsEmpty());
 
   APIPermissionSet non_empty_apis;
   non_empty_apis.insert(APIPermission::kBackground);
   perm_set = new PermissionSet(
       non_empty_apis, empty_extent, empty_extent);
   EXPECT_FALSE(perm_set->IsEmpty());
 
   // Try non standard host
   URLPatternSet non_empty_extent;
   AddPattern(&non_empty_extent, "http://www.google.com/*");
 
   perm_set = new PermissionSet(
       empty_apis, non_empty_extent, empty_extent);
   EXPECT_FALSE(perm_set->IsEmpty());
 
   perm_set = new PermissionSet(
       empty_apis, empty_extent, non_empty_extent);
   EXPECT_FALSE(perm_set->IsEmpty());
 }
 
-TEST_F(PermissionsTest, ImpliedPermissions) {
+TEST(PermissionsTest, ImpliedPermissions) {
   URLPatternSet empty_extent;
   APIPermissionSet apis;
   apis.insert(APIPermission::kWebRequest);
   apis.insert(APIPermission::kFileBrowserHandler);
   EXPECT_EQ(2U, apis.size());
 
   scoped_refptr<PermissionSet> perm_set;
   perm_set = new PermissionSet(apis, empty_extent, empty_extent);
   EXPECT_EQ(4U, perm_set->apis().size());
 }
 
-TEST_F(PermissionsTest, SyncFileSystemPermission) {
+TEST(PermissionsTest, SyncFileSystemPermission) {
   scoped_refptr<Extension> extension = LoadManifest(
       "permissions", "sync_file_system.json");
   APIPermissionSet apis;
   apis.insert(APIPermission::kSyncFileSystem);
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSyncFileSystem));
   std::vector<string16> warnings = extension->GetPermissionMessageStrings();
   EXPECT_TRUE(Contains(warnings, "Store data in your Google Drive account"));
   ASSERT_EQ(1u, warnings.size());
 }
 
 }  // namespace extensions