Extensions: Switch to new permission message system, part II

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/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_test_util.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "chrome/common/extensions/permissions/chrome_permission_message_provider.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
@@ skipping 23 matching lines @@
 size_t IndexOf(const PermissionMessageStrings& warnings,
                const std::string& warning) {
   for (size_t i = 0; i < warnings.size(); ++i) {
     if (warnings[i].message == base::ASCIIToUTF16(warning))
       return i;
   }
 
   return warnings.size();
 }
 
+PermissionIDSet MakePermissionIDSet(APIPermission::ID id1,
+                                    APIPermission::ID id2) {
+  PermissionIDSet set;
+  set.insert(id1);
+  set.insert(id2);
+  return set;
+}
+
+PermissionIDSet MakePermissionIDSet(const APIPermissionSet& permissions) {
+  PermissionIDSet set;
+  for (const APIPermission* permission : permissions)
+    set.insert(permission->id());
+  return set;
+}
+
+std::string LegacyPermissionIDsToString(const PermissionMessageIDs& ids) {
+  std::vector<std::string> strs;
+  for (const PermissionMessage::ID& id : ids)
+    strs.push_back(base::IntToString(id));
+  return base::StringPrintf("[ %s ]", JoinString(strs, ", ").c_str());
+}
+
+std::string PermissionIDsToString(const PermissionIDSet& ids) {
+  std::vector<std::string> strs;
+  for (const PermissionID& id : ids)
+    strs.push_back(base::IntToString(id.id()));
+  return base::StringPrintf("[ %s ]", JoinString(strs, ", ").c_str());
+}
+
+std::string CoalescedPermissionIDsToString(
+    const CoalescedPermissionMessages& msgs) {
+  std::vector<std::string> strs;
+  for (const CoalescedPermissionMessage& msg : msgs)
+    strs.push_back(PermissionIDsToString(msg.permissions()));
+  return JoinString(strs, " ");
+}
+
+// Check that the given |permissions| produce a single warning message,
+// identified by |expected_legacy_id| in the old system, and by the set of
+// |expected_ids| in the new system.
+testing::AssertionResult PermissionSetProducesMessage(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type,
+    PermissionMessage::ID expected_legacy_id,
+    const PermissionIDSet& expected_ids) {
+  const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
+  PermissionMessageIDs legacy_ids =
+      provider->GetLegacyPermissionMessageIDs(permissions, extension_type);
+  if (legacy_ids.size() != 1 || expected_legacy_id != legacy_ids[0]) {
+    return testing::AssertionFailure()
+           << "Expected single legacy permission ID " << expected_legacy_id
+           << " but got " << LegacyPermissionIDsToString(legacy_ids);
+  }
+
+  CoalescedPermissionMessages msgs = provider->GetCoalescedPermissionMessages(
+      provider->GetAllPermissionIDs(permissions, extension_type));
+  if (msgs.size() != 1) {
+    return testing::AssertionFailure()
+           << "Expected single permission message with IDs "
+           << PermissionIDsToString(expected_ids) << " but got " << msgs.size()
+           << " messages: " << CoalescedPermissionIDsToString(msgs);
+  }
+  if (!msgs.front().permissions().Equals(expected_ids)) {
+    return testing::AssertionFailure()
+           << "Expected permission IDs " << PermissionIDsToString(expected_ids)
+           << " but got " << PermissionIDsToString(msgs.front().permissions());
+  }
+
+  return testing::AssertionSuccess();
+}
+
 }  // namespace
 
 // Tests 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());
   }
@@ skipping 731 matching lines @@
   }
 }
 
 TEST(PermissionsTest, FileSystemPermissionMessages) {
   APIPermissionSet api_permissions;
   api_permissions.insert(APIPermission::kFileSystemWrite);
   api_permissions.insert(APIPermission::kFileSystemDirectory);
   scoped_refptr<PermissionSet> permissions(
       new PermissionSet(api_permissions, ManifestPermissionSet(),
                         URLPatternSet(), URLPatternSet()));
-  PermissionMessageIDs ids =
-      PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
-          permissions.get(), Manifest::TYPE_PLATFORM_APP);
-  ASSERT_EQ(1u, ids.size());
-  EXPECT_EQ(PermissionMessage::kFileSystemDirectory, ids[0]);
+  EXPECT_TRUE(PermissionSetProducesMessage(
+      permissions.get(), Manifest::TYPE_PLATFORM_APP,
+      PermissionMessage::kFileSystemDirectory,
+      MakePermissionIDSet(api_permissions)));
 }
 
 // The file system permissions have a special-case hack to show a warning for
 // write and directory at the same time.
 // TODO(sammc): Remove this. See http://crbug.com/284849.
 TEST(PermissionsTest, FileSystemImplicitPermissions) {
   APIPermissionSet apis;
   apis.insert(APIPermission::kFileSystemWrite);
   apis.AddImpliedPermissions();
 
@@ skipping 22 matching lines @@
 }
 
 TEST(PermissionsTest, HiddenFileSystemPermissionMessages) {
   APIPermissionSet api_permissions;
   api_permissions.insert(APIPermission::kFileSystemWrite);
   api_permissions.insert(APIPermission::kFileSystemDirectory);
   api_permissions.insert(APIPermission::kFileSystemWriteDirectory);
   scoped_refptr<PermissionSet> permissions(
       new PermissionSet(api_permissions, ManifestPermissionSet(),
                         URLPatternSet(), URLPatternSet()));
-  PermissionMessageIDs ids =
-      PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
-          permissions.get(), Manifest::TYPE_PLATFORM_APP);
-  ASSERT_EQ(1u, ids.size());
-  EXPECT_EQ(PermissionMessage::kFileSystemWriteDirectory, ids[0]);
+  EXPECT_TRUE(PermissionSetProducesMessage(
+      permissions.get(), Manifest::TYPE_PLATFORM_APP,
+      PermissionMessage::kFileSystemWriteDirectory,
+      MakePermissionIDSet(api_permissions)));
 }
 
 TEST(PermissionsTest, SuppressedPermissionMessages) {
   {
     // Tabs warning suppresses favicon warning.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kTab);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI,
                                 "chrome://favicon/"));
     scoped_refptr<PermissionSet> permissions(
         new PermissionSet(api_permissions, ManifestPermissionSet(),
                           hosts, URLPatternSet()));
-    PermissionMessageIDs ids =
-        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
-            permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, ids.size());
-    EXPECT_EQ(PermissionMessage::kTabs, ids[0]);
+    EXPECT_TRUE(PermissionSetProducesMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION, PermissionMessage::kTabs,
+        MakePermissionIDSet(APIPermission::kTab, APIPermission::kFavicon)));
   }
   {
     // History warning suppresses favicon warning.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kHistory);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI,
                                 "chrome://favicon/"));
     scoped_refptr<PermissionSet> permissions(
         new PermissionSet(api_permissions, ManifestPermissionSet(),
                           hosts, URLPatternSet()));
-    PermissionMessageIDs ids =
-        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
-            permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, ids.size());
-    EXPECT_EQ(PermissionMessage::kBrowsingHistory, ids[0]);
+    EXPECT_TRUE(PermissionSetProducesMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION,
+        PermissionMessage::kBrowsingHistory,
+        MakePermissionIDSet(APIPermission::kHistory, APIPermission::kFavicon)));
   }
   {
     // All sites warning suppresses tabs warning.
     APIPermissionSet api_permissions;
+    api_permissions.insert(APIPermission::kTab);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
-    api_permissions.insert(APIPermission::kTab);
     scoped_refptr<PermissionSet> permissions(new PermissionSet(
         api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
-    PermissionMessageIDs ids =
-        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
-            permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, ids.size());
-    EXPECT_EQ(PermissionMessage::kHostsAll, ids[0]);
+    EXPECT_TRUE(PermissionSetProducesMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION,
+        PermissionMessage::kHostsAll,
+        MakePermissionIDSet(APIPermission::kHostsAll, APIPermission::kTab)));
   }
   {
     // All sites warning suppresses topSites warning.
     APIPermissionSet api_permissions;
+    api_permissions.insert(APIPermission::kTopSites);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
-    api_permissions.insert(APIPermission::kTopSites);
     scoped_refptr<PermissionSet> permissions(new PermissionSet(
         api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
-    PermissionMessageIDs ids =
-        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
-            permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, ids.size());
-    EXPECT_EQ(PermissionMessage::kHostsAll, ids[0]);
+    EXPECT_TRUE(PermissionSetProducesMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION,
+        PermissionMessage::kHostsAll,
+        MakePermissionIDSet(APIPermission::kHostsAll,
+                            APIPermission::kTopSites)));
   }
   {
     // All sites warning suppresses declarativeWebRequest warning.
     APIPermissionSet api_permissions;
+    api_permissions.insert(APIPermission::kDeclarativeWebRequest);
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
-    api_permissions.insert(APIPermission::kDeclarativeWebRequest);
     scoped_refptr<PermissionSet> permissions(new PermissionSet(
         api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
-    PermissionMessageIDs ids =
-        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
-            permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, ids.size());
-    EXPECT_EQ(PermissionMessage::kHostsAll, ids[0]);
+    EXPECT_TRUE(PermissionSetProducesMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION,
+        PermissionMessage::kHostsAll,
+        MakePermissionIDSet(APIPermission::kHostsAll,
+                            APIPermission::kDeclarativeWebRequest)));
   }
   {
     // BrowsingHistory warning suppresses all history read/write warnings.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kHistory);
     api_permissions.insert(APIPermission::kTab);
     api_permissions.insert(APIPermission::kTopSites);
     api_permissions.insert(APIPermission::kProcesses);
     api_permissions.insert(APIPermission::kWebNavigation);
     scoped_refptr<PermissionSet> permissions(
         new PermissionSet(api_permissions, ManifestPermissionSet(),
                           URLPatternSet(), URLPatternSet()));
-    PermissionMessageIDs ids =
-        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
-            permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, ids.size());
-    EXPECT_EQ(PermissionMessage::kBrowsingHistory, ids[0]);
+    EXPECT_TRUE(PermissionSetProducesMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION,
+        PermissionMessage::kBrowsingHistory,
+        MakePermissionIDSet(api_permissions)));
   }
   {
     // Tabs warning suppresses all read-only history warnings.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kTab);
     api_permissions.insert(APIPermission::kTopSites);
     api_permissions.insert(APIPermission::kProcesses);
     api_permissions.insert(APIPermission::kWebNavigation);
     scoped_refptr<PermissionSet> permissions(
         new PermissionSet(api_permissions, ManifestPermissionSet(),
                           URLPatternSet(), URLPatternSet()));
-    PermissionMessageIDs ids =
-        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
-            permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, ids.size());
-    EXPECT_EQ(PermissionMessage::kTabs, ids[0]);
+    EXPECT_TRUE(PermissionSetProducesMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION, PermissionMessage::kTabs,
+        MakePermissionIDSet(api_permissions)));
   }
 }
 
 TEST(PermissionsTest, AccessToDevicesMessages) {
   {
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kSerial);
     scoped_refptr<PermissionSet> permissions(
         new PermissionSet(api_permissions,
                           ManifestPermissionSet(),
@@ skipping 742 matching lines @@
       URLPattern(URLPattern::SCHEME_ALL, "http://www.google.com/"));
   allowed_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_ALL, "chrome://favicon/"));
   allowed_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_ALL, "chrome://thumb/"));
   scoped_refptr<PermissionSet> permissions(
       new PermissionSet(APIPermissionSet(), ManifestPermissionSet(),
                         allowed_hosts, URLPatternSet()));
   PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
       permissions.get(), Manifest::TYPE_EXTENSION);
+  PermissionMessageProvider::Get()->GetCoalescedPermissionMessages(
+      PermissionMessageProvider::Get()->GetAllPermissionIDs(
+          permissions.get(), Manifest::TYPE_EXTENSION));
 }
 
 TEST(PermissionsTest, IsPrivilegeIncrease_DeclarativeWebRequest) {
   scoped_refptr<Extension> extension(
       LoadManifest("permissions", "permissions_all_urls.json"));
   scoped_refptr<const PermissionSet> permissions(
       extension->permissions_data()->active_permissions());
 
   scoped_refptr<Extension> extension_dwr(
       LoadManifest("permissions", "web_request_all_host_permissions.json"));
   scoped_refptr<const PermissionSet> permissions_dwr(
       extension_dwr->permissions_data()->active_permissions());
 
   EXPECT_FALSE(PermissionMessageProvider::Get()->
                    IsPrivilegeIncrease(permissions.get(),
                                        permissions_dwr.get(),
                                        extension->GetType()));
 }
 
 }  // namespace extensions