Add a centralized mechanism for whitelisting access to extension permissions.

chrome/common/extensions/extension_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 "chrome/common/extensions/extension_permission_set.h"
 
 #include "base/json/json_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/extensions/extension.h"
+#include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/extension_error_utils.h"
+#include "chrome/common/extensions/extension_permission_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace errors = extension_manifest_errors;
+namespace keys = extension_manifest_keys;
+namespace values = extension_manifest_values;
 namespace {
 
 static scoped_refptr<Extension> LoadManifest(const std::string& dir,
                                              const std::string& test_file,
                                              int extra_flags) {
   FilePath path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
   path = path.AppendASCII("extensions")
              .AppendASCII(dir)
              .AppendASCII(test_file);
@@ skipping 12 matching lines @@
       Extension::STRICT_ERROR_CHECKS | extra_flags, &error);
   EXPECT_TRUE(extension) << error;
   return extension;
 }
 
 static scoped_refptr<Extension> LoadManifest(const std::string& dir,
                                              const std::string& test_file) {
   return LoadManifest(dir, test_file, Extension::NO_FLAGS);
 }
 
+static scoped_refptr<Extension> LoadManifestFromValue(
+    DictionaryValue* manifest,
+    Extension::Location location,
+    std::string* error) {
+  return Extension::Create(FilePath(), location, *manifest,
+                           Extension::STRICT_ERROR_CHECKS, error);
+}
+
+static void LoadManifestAndExpectError(DictionaryValue* manifest,
+                                       Extension::Location location,
+                                       const std::string& permission) {
+  std::string error;
+  scoped_refptr<Extension> extension =
+      LoadManifestFromValue(manifest, location, &error);
+
+  std::string expected_error = ExtensionErrorUtils::FormatErrorMessage(
+      errors::kPermissionNotAllowed, permission);
+  EXPECT_FALSE(extension);
+  EXPECT_EQ(expected_error, error);
+}
+
 void CompareLists(const std::vector<std::string>& expected,
                   const std::vector<std::string>& actual) {
   ASSERT_EQ(expected.size(), actual.size());
 
   for (size_t i = 0; i < expected.size(); ++i) {
     EXPECT_EQ(expected[i], actual[i]);
   }
 }
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
 } // namespace
 
-class ExtensionAPIPermissionTest : public testing::Test {
+class ExtensionPermissionsTest : public testing::Test {
 };
 
-class ExtensionPermissionSetTest : public testing::Test {
-};
-
-
 // Tests GetByID.
-TEST(ExtensionPermissionsInfoTest, GetByID) {
+TEST(ExtensionPermissionsTest, GetByID) {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   ExtensionAPIPermissionSet ids = info->GetAll();
   for (ExtensionAPIPermissionSet::iterator i = ids.begin();
        i != ids.end(); ++i) {
     EXPECT_EQ(*i, info->GetByID(*i)->id());
   }
 }
 
 // Tests that GetByName works with normal permission names and aliases.
-TEST(ExtensionPermissionsInfoTest, GetByName) {
+TEST(ExtensionPermissionsTest, GetByName) {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   EXPECT_EQ(ExtensionAPIPermission::kTab, info->GetByName("tabs")->id());
   EXPECT_EQ(ExtensionAPIPermission::kManagement,
             info->GetByName("management")->id());
   EXPECT_FALSE(info->GetByName("alsdkfjasldkfj"));
 }
 
-TEST(ExtensionPermissionsInfoTest, GetAll) {
+TEST(ExtensionPermissionsTest, GetAll) {
   size_t count = 0;
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   ExtensionAPIPermissionSet apis = info->GetAll();
   for (ExtensionAPIPermissionSet::iterator api = apis.begin();
        api != apis.end(); ++api) {
     // Make sure only the valid permission IDs get returned.
     EXPECT_NE(ExtensionAPIPermission::kInvalid, *api);
     EXPECT_NE(ExtensionAPIPermission::kUnknown, *api);
     count++;
   }
   EXPECT_EQ(count, info->get_permission_count());
 }
 
-TEST(ExtensionPermissionInfoTest, GetAllByName) {
+TEST(ExtensionPermissionsTest, 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");
 
   ExtensionAPIPermissionSet expected;
   expected.insert(ExtensionAPIPermission::kBackground);
   expected.insert(ExtensionAPIPermission::kManagement);
   expected.insert(ExtensionAPIPermission::kTab);
 
   EXPECT_EQ(expected,
             ExtensionPermissionsInfo::GetInstance()->GetAllByName(names));
 }
 
 // Tests that the aliases are properly mapped.
-TEST(ExtensionAPIPermissionTest, Aliases) {
+TEST(ExtensionPermissionsTest, Aliases) {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   // tabs: tabs, windows
   std::string tabs_name = "tabs";
   EXPECT_EQ(tabs_name, info->GetByID(ExtensionAPIPermission::kTab)->name());
   EXPECT_EQ(ExtensionAPIPermission::kTab, info->GetByName("tabs")->id());
   EXPECT_EQ(ExtensionAPIPermission::kTab, info->GetByName("windows")->id());
 
   // unlimitedStorage: unlimitedStorage, unlimited_storage
   std::string storage_name = "unlimitedStorage";
   EXPECT_EQ(storage_name, info->GetByID(
       ExtensionAPIPermission::kUnlimitedStorage)->name());
   EXPECT_EQ(ExtensionAPIPermission::kUnlimitedStorage,
             info->GetByName("unlimitedStorage")->id());
   EXPECT_EQ(ExtensionAPIPermission::kUnlimitedStorage,
             info->GetByName("unlimited_storage")->id());
 }
 
-TEST(ExtensionAPIPermissionTest, HostedAppPermissions) {
+TEST(ExtensionPermissionsTest, HostedAppPermissions) {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   ExtensionAPIPermissionSet hosted_perms;
   hosted_perms.insert(ExtensionAPIPermission::kAppNotifications);
   hosted_perms.insert(ExtensionAPIPermission::kBackground);
   hosted_perms.insert(ExtensionAPIPermission::kClipboardRead);
   hosted_perms.insert(ExtensionAPIPermission::kClipboardWrite);
   hosted_perms.insert(ExtensionAPIPermission::kChromeAuthPrivate);
   hosted_perms.insert(ExtensionAPIPermission::kChromePrivate);
   hosted_perms.insert(ExtensionAPIPermission::kExperimental);
   hosted_perms.insert(ExtensionAPIPermission::kGeolocation);
   hosted_perms.insert(ExtensionAPIPermission::kNotification);
   hosted_perms.insert(ExtensionAPIPermission::kUnlimitedStorage);
   hosted_perms.insert(ExtensionAPIPermission::kWebstorePrivate);
 
+  DictionaryValue source;
+  source.SetString(keys::kName, "permission hosted app test");
+  source.SetString(keys::kVersion, "1");
+  source.SetInteger(keys::kManifestVersion, 2);
+  ListValue* urls = new ListValue();
+  urls->Append(Value::CreateStringValue("http://localhost/test.html"));
+  source.Set(keys::kWebURLs, urls);
+  source.SetString(keys::kLaunchWebURL, "http://localhost/test.html");
+
   ExtensionAPIPermissionSet perms = info->GetAll();
   size_t count = 0;
   for (ExtensionAPIPermissionSet::iterator i = perms.begin();
        i != perms.end(); ++i) {
-    count += hosted_perms.count(*i);
-    EXPECT_EQ(hosted_perms.count(*i) > 0,
-              info->GetByID(*i)->supports_hosted_apps());
+    ExtensionAPIPermission* permission = info->GetByID(*i);
+    if (permission->supports_hosted_apps()) {
+      count++;
+      EXPECT_TRUE(hosted_perms.count(*i));
+      continue;
+    }
+
+    scoped_ptr<DictionaryValue> manifest(source.DeepCopy());
+    ListValue* permissions = new ListValue();
+    permissions->Append(Value::CreateStringValue(permission->name()));
+    manifest->Set(keys::kPermissions, permissions);
+
+    // This error may be generated for other reasons too, like if the permission
+    // has a whitelist.
+    LoadManifestAndExpectError(
+        manifest.get(), Extension::INTERNAL, permission->name());
   }
 
   EXPECT_EQ(hosted_perms.size(), count);
 }
 
-TEST(ExtensionAPIPermissionTest, PlatformAppPermissions) {
+TEST(ExtensionPermissionsTest, PlatformAppPermissions) {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   ExtensionAPIPermissionSet blacklist;
   blacklist.insert(ExtensionAPIPermission::kAppNotifications);
   blacklist.insert(ExtensionAPIPermission::kChromeAuthPrivate);
   blacklist.insert(ExtensionAPIPermission::kChromePrivate);
   blacklist.insert(ExtensionAPIPermission::kCookie);
   blacklist.insert(ExtensionAPIPermission::kTab);
   blacklist.insert(ExtensionAPIPermission::kWebNavigation);
   blacklist.insert(ExtensionAPIPermission::kWebRequest);
   blacklist.insert(ExtensionAPIPermission::kWebRequestBlocking);
   blacklist.insert(ExtensionAPIPermission::kWebSocketProxyPrivate);
   blacklist.insert(ExtensionAPIPermission::kWebstorePrivate);
 
+  DictionaryValue source;
+  source.SetString(keys::kName, "permission platform app test");
+  source.SetString(keys::kVersion, "1");
+  source.SetInteger(keys::kManifestVersion, 2);
+  source.SetBoolean(keys::kPlatformApp, true);
+  source.SetString(keys::kLaunchLocalPath, "test.html");
+  source.SetString(keys::kLaunchContainer, values::kLaunchContainerShell);
+
   ExtensionAPIPermissionSet perms = info->GetAll();
   size_t count = 0;
   for (ExtensionAPIPermissionSet::iterator i = perms.begin();
        i != perms.end(); ++i) {
-    count += blacklist.count(*i);
-    EXPECT_EQ(blacklist.count(*i) > 0,
-              !info->GetByID(*i)->supports_platform_apps());
+    ExtensionAPIPermission* permission = info->GetByID(*i);
+    if (permission->supports_platform_apps())
+      continue;
+
+    count++;
+    EXPECT_TRUE(blacklist.count(*i));
+
+    scoped_ptr<DictionaryValue> manifest(source.DeepCopy());
+    ListValue* permissions = new ListValue();
+    permissions->Append(Value::CreateStringValue(permission->name()));
+    manifest->Set(keys::kPermissions, permissions);
+
+    // This error may be generated for other reasons too, like if the permission
+    // has a whitelist.
+    LoadManifestAndExpectError(
+        manifest.get(), Extension::INTERNAL, permission->name());
   }
 
   EXPECT_EQ(blacklist.size(), count);
 }
 
-TEST(ExtensionAPIPermissionTest, ComponentOnlyPermissions) {
+TEST(ExtensionPermissionsTest, ComponentOnlyPermissions) {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   ExtensionAPIPermissionSet private_perms;
-  private_perms.insert(ExtensionAPIPermission::kChromeAuthPrivate);
   private_perms.insert(ExtensionAPIPermission::kChromeosInfoPrivate);
   private_perms.insert(ExtensionAPIPermission::kFileBrowserPrivate);
   private_perms.insert(ExtensionAPIPermission::kMediaPlayerPrivate);
   private_perms.insert(ExtensionAPIPermission::kMetricsPrivate);
   private_perms.insert(ExtensionAPIPermission::kSystemPrivate);
-  private_perms.insert(ExtensionAPIPermission::kWebstorePrivate);
+
+  DictionaryValue source;
+  source.SetString(keys::kName, "component only permission test");
+  source.SetString(keys::kVersion, "1");
+  source.SetInteger(keys::kManifestVersion, 2);
 
   ExtensionAPIPermissionSet perms = info->GetAll();
-  int count = 0;
+  size_t count = 0;
   for (ExtensionAPIPermissionSet::iterator i = perms.begin();
        i != perms.end(); ++i) {
-    count += private_perms.count(*i);
-    EXPECT_EQ(private_perms.count(*i) > 0,
-              info->GetByID(*i)->is_component_only());
+    ExtensionAPIPermission* permission = info->GetByID(*i);
+
+    scoped_ptr<DictionaryValue> manifest(source.DeepCopy());
+    ListValue* permissions = new ListValue();
+    permissions->Append(Value::CreateStringValue(permission->name()));
+    manifest->Set(keys::kPermissions, permissions);
+
+    // COMPONENT extensions can access any permission.
+    std::string error;
+    scoped_refptr<Extension> extension = LoadManifestFromValue(
+        manifest.get(), Extension::COMPONENT, &error);
+    EXPECT_TRUE(extension);
+
+    if (!permission->is_component_only())
+      continue;
+
+    count++;
+    EXPECT_TRUE(private_perms.count(*i));
+
+    // But INTERNAL extensions can't access component only permissions.
+    LoadManifestAndExpectError(
+        manifest.get(), Extension::INTERNAL, permission->name());
   }
 
-  EXPECT_EQ(7, count);
+  EXPECT_EQ(private_perms.size(), count);
 }
 
-TEST(ExtensionPermissionSetTest, EffectiveHostPermissions) {
+// Tests that permission whitelists are enforced.
+TEST(ExtensionPermissionsTest, Whitelists) {
+  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+  ExtensionAPIPermissionSet ids = info->GetAll();
+
+  ExtensionAPIPermissionSet expected_whitelists;
+  expected_whitelists.insert(ExtensionAPIPermission::kChromeAuthPrivate);
+  expected_whitelists.insert(ExtensionAPIPermission::kChromePrivate);
+  expected_whitelists.insert(ExtensionAPIPermission::kInputMethodPrivate);
+  expected_whitelists.insert(ExtensionAPIPermission::kTerminalPrivate);
+  expected_whitelists.insert(ExtensionAPIPermission::kWebSocketProxyPrivate);
+  expected_whitelists.insert(ExtensionAPIPermission::kWebstorePrivate);
+
+  DictionaryValue source;
+  source.SetString(keys::kName, "permission whitelist test");
+  source.SetString(keys::kVersion, "1");
+  source.SetInteger(keys::kManifestVersion, 2);
+
+  size_t whitelists = 0;
+  for (ExtensionAPIPermissionSet::iterator i = ids.begin();
+       i != ids.end(); ++i) {
+    ExtensionAPIPermission* permission = info->GetByID(*i);
+    if (!permission->HasWhitelist())
+      continue;
+
+    whitelists++;
+    EXPECT_TRUE(expected_whitelists.count(*i));
+
+    scoped_ptr<DictionaryValue> manifest(source.DeepCopy());
+    ListValue* permissions = new ListValue();
+    permissions->Append(Value::CreateStringValue(permission->name()));
+    manifest->Set(keys::kPermissions, permissions);
+
+    LoadManifestAndExpectError(
+        manifest.get(), Extension::INTERNAL, permission->name());
+  }
+
+  EXPECT_EQ(expected_whitelists.size(), whitelists);
+}
+
+TEST(ExtensionPermissionsTest, EffectiveHostPermissions) {
   scoped_refptr<Extension> extension;
   scoped_refptr<const ExtensionPermissionSet> 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(ExtensionPermissionSetTest, ExplicitAccessToOrigin) {
+TEST(ExtensionPermissionsTest, ExplicitAccessToOrigin) {
   ExtensionAPIPermissionSet 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<ExtensionPermissionSet> perm_set = new ExtensionPermissionSet(
       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(ExtensionPermissionSetTest, CreateUnion) {
+TEST(ExtensionPermissionsTest, CreateUnion) {
   ExtensionAPIPermissionSet apis1;
   ExtensionAPIPermissionSet apis2;
   ExtensionAPIPermissionSet expected_apis;
 
   URLPatternSet explicit_hosts1;
   URLPatternSet explicit_hosts2;
   URLPatternSet expected_explicit_hosts;
 
   URLPatternSet scriptable_hosts1;
   URLPatternSet scriptable_hosts2;
@@ skipping 60 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(ExtensionPermissionSetTest, CreateIntersection) {
+TEST(ExtensionPermissionsTest, CreateIntersection) {
   ExtensionAPIPermissionSet apis1;
   ExtensionAPIPermissionSet apis2;
   ExtensionAPIPermissionSet expected_apis;
 
   URLPatternSet explicit_hosts1;
   URLPatternSet explicit_hosts2;
   URLPatternSet expected_explicit_hosts;
 
   URLPatternSet scriptable_hosts1;
   URLPatternSet scriptable_hosts2;
@@ skipping 55 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(ExtensionPermissionSetTest, CreateDifference) {
+TEST(ExtensionPermissionsTest, CreateDifference) {
   ExtensionAPIPermissionSet apis1;
   ExtensionAPIPermissionSet apis2;
   ExtensionAPIPermissionSet expected_apis;
 
   URLPatternSet explicit_hosts1;
   URLPatternSet explicit_hosts2;
   URLPatternSet expected_explicit_hosts;
 
   URLPatternSet scriptable_hosts1;
   URLPatternSet scriptable_hosts2;
@@ skipping 43 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 = ExtensionPermissionSet::CreateIntersection(new_set.get(), set2.get());
   EXPECT_TRUE(set1->IsEmpty());
 }
 
-TEST(ExtensionPermissionSetTest, HasLessPrivilegesThan) {
+TEST(ExtensionPermissionsTest, HasLessPrivilegesThan) {
   const struct {
     const char* base_name;
     // Increase these sizes if you have more than 10.
     const char* granted_apis[10];
     const char* granted_hosts[10];
     bool full_access;
     bool expect_increase;
   } kTests[] = {
     { "allhosts1", {NULL}, {"http://*/", NULL}, false,
       false },  // all -> all
@@ skipping 72 matching lines @@
     scoped_refptr<const ExtensionPermissionSet> old_p(
         old_extension->GetActivePermissions());
     scoped_refptr<const ExtensionPermissionSet> new_p(
         new_extension->GetActivePermissions());
 
     EXPECT_EQ(kTests[i].expect_increase,
               old_p->HasLessPrivilegesThan(new_p)) << kTests[i].base_name;
   }
 }
 
-TEST(ExtensionPermissionSetTest, PermissionMessages) {
+TEST(ExtensionPermissionsTest, PermissionMessages) {
   // Ensure that all permissions that needs to show install UI actually have
   // strings associated with them.
   ExtensionAPIPermissionSet skip;
 
   // These are considered "nuisance" or "trivial" permissions that don't need
   // a prompt.
   skip.insert(ExtensionAPIPermission::kAppNotifications);
   skip.insert(ExtensionAPIPermission::kContextMenus);
   skip.insert(ExtensionAPIPermission::kIdle);
   skip.insert(ExtensionAPIPermission::kNotification);
@@ skipping 54 matching lines @@
       EXPECT_EQ(ExtensionPermissionMessage::kNone, permission->message_id())
           << "unexpected message_id for " << permission->name();
     } else {
       EXPECT_NE(ExtensionPermissionMessage::kNone, permission->message_id())
           << "missing message_id for " << permission->name();
     }
   }
 }
 
 // Tests the default permissions (empty API permission set).
-TEST(ExtensionPermissionSetTest, DefaultFunctionAccess) {
+TEST(ExtensionPermissionsTest, 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 47 matching lines @@
     { "tabs",           true},
   };
 
   scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTests); ++i) {
     EXPECT_EQ(kTests[i].expect_success,
               empty->HasAnyAccessToAPI(kTests[i].api_name));
   }
 }
 
-TEST(ExtensionPermissionSetTest, GetWarningMessages_ManyHosts) {
+TEST(ExtensionPermissionsTest, GetWarningMessages_ManyHosts) {
   scoped_refptr<Extension> extension;
 
   extension = LoadManifest("permissions", "many-hosts.json");
   std::vector<string16> warnings =
       extension->GetActivePermissions()->GetWarningMessages();
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Your data on encrypted.google.com and www.google.com",
             UTF16ToUTF8(warnings[0]));
 }
 
-TEST(ExtensionPermissionSetTest, GetWarningMessages_Plugins) {
+TEST(ExtensionPermissionsTest, GetWarningMessages_Plugins) {
   scoped_refptr<Extension> extension;
   scoped_refptr<ExtensionPermissionSet> permissions;
 
   extension = LoadManifest("permissions", "plugins.json");
   std::vector<string16> warnings =
       extension->GetActivePermissions()->GetWarningMessages();
   // 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("All data on your computer and the websites you visit",
             UTF16ToUTF8(warnings[0]));
 #endif
 }
 
-TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay) {
+TEST(ExtensionPermissionsTest, GetDistinctHostsForDisplay) {
   scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet 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 ExtensionPermissionSet(
         empty_perms, explicit_hosts, scriptable_hosts);
     EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
   }
 }
 
-TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay_ComIsBestRcd) {
+TEST(ExtensionPermissionsTest, GetDistinctHostsForDisplay_ComIsBestRcd) {
   scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet 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 ExtensionPermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
-TEST(ExtensionPermissionSetTest, GetDistinctHostsForDisplay_NetIs2ndBestRcd) {
+TEST(ExtensionPermissionsTest, GetDistinctHostsForDisplay_NetIs2ndBestRcd) {
   scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet 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 ExtensionPermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
-TEST(ExtensionPermissionSetTest,
+TEST(ExtensionPermissionsTest,
      GetDistinctHostsForDisplay_OrgIs3rdBestRcd) {
   scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet 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 ExtensionPermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
-TEST(ExtensionPermissionSetTest,
+TEST(ExtensionPermissionsTest,
      GetDistinctHostsForDisplay_FirstInListIs4thBestRcd) {
   scoped_refptr<ExtensionPermissionSet> perm_set;
   ExtensionAPIPermissionSet 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 ExtensionPermissionSet(
       empty_perms, explicit_hosts, scriptable_hosts);
   EXPECT_EQ(expected, perm_set->GetDistinctHostsForDisplay());
 }
 
-TEST(ExtensionPermissionSetTest, HasLessHostPrivilegesThan) {
+TEST(ExtensionPermissionsTest, HasLessHostPrivilegesThan) {
   URLPatternSet elist1;
   URLPatternSet elist2;
   URLPatternSet slist1;
   URLPatternSet slist2;
   scoped_refptr<ExtensionPermissionSet> set1;
   scoped_refptr<ExtensionPermissionSet> set2;
   ExtensionAPIPermissionSet 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 ExtensionPermissionSet(empty_perms, elist2, slist2);
   EXPECT_TRUE(set1->HasLessHostPrivilegesThan(set2.get()));
   EXPECT_TRUE(set2->HasLessHostPrivilegesThan(set1.get()));
 }
 
-TEST(ExtensionPermissionSetTest, GetAPIsAsStrings) {
+TEST(ExtensionPermissionsTest, GetAPIsAsStrings) {
   ExtensionAPIPermissionSet apis;
   URLPatternSet empty_set;
 
   apis.insert(ExtensionAPIPermission::kProxy);
   apis.insert(ExtensionAPIPermission::kBackground);
   apis.insert(ExtensionAPIPermission::kNotification);
   apis.insert(ExtensionAPIPermission::kTab);
 
   scoped_refptr<ExtensionPermissionSet> perm_set = new ExtensionPermissionSet(
       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,
             ExtensionPermissionsInfo::GetInstance()->GetAllByName(api_names));
 }
 
-TEST(ExtensionPermissionSetTest, IsEmpty) {
+TEST(ExtensionPermissionsTest, IsEmpty) {
   ExtensionAPIPermissionSet empty_apis;
   URLPatternSet empty_extent;
 
   scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
   EXPECT_TRUE(empty->IsEmpty());
   scoped_refptr<ExtensionPermissionSet> perm_set;
 
   perm_set = new ExtensionPermissionSet(empty_apis, empty_extent, empty_extent);
   EXPECT_TRUE(perm_set->IsEmpty());
 
   ExtensionAPIPermissionSet non_empty_apis;
   non_empty_apis.insert(ExtensionAPIPermission::kBackground);
   perm_set = new ExtensionPermissionSet(
       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 ExtensionPermissionSet(
       empty_apis, non_empty_extent, empty_extent);
   EXPECT_FALSE(perm_set->IsEmpty());
 
   perm_set = new ExtensionPermissionSet(
       empty_apis, empty_extent, non_empty_extent);
   EXPECT_FALSE(perm_set->IsEmpty());
 }