Extensions: Prepare switch to new permission message system

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/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 784 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()));
-  PermissionMessages messages =
-      PermissionMessageProvider::Get()->GetPermissionMessages(
+  PermissionMessageIDs ids =
+      PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
           permissions.get(), Manifest::TYPE_PLATFORM_APP);
-  ASSERT_EQ(1u, messages.size());
-  std::sort(messages.begin(), messages.end());
-  std::set<PermissionMessage::ID> ids;
-  for (PermissionMessages::const_iterator it = messages.begin();
-       it != messages.end(); ++it) {
-    ids.insert(it->id());
-  }
-  EXPECT_TRUE(ContainsKey(ids, PermissionMessage::kFileSystemDirectory));
+  ASSERT_EQ(1u, ids.size());
+  EXPECT_EQ(PermissionMessage::kFileSystemDirectory, ids[0]);
 }
 
 // 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()));
-  PermissionMessages messages =
-      PermissionMessageProvider::Get()->GetPermissionMessages(
+  PermissionMessageIDs ids =
+      PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
           permissions.get(), Manifest::TYPE_PLATFORM_APP);
-  ASSERT_EQ(1u, messages.size());
-  EXPECT_EQ(PermissionMessage::kFileSystemWriteDirectory, messages[0].id());
+  ASSERT_EQ(1u, ids.size());
+  EXPECT_EQ(PermissionMessage::kFileSystemWriteDirectory, ids[0]);
 }
 
 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()));
-    PermissionMessages messages =
-        PermissionMessageProvider::Get()->GetPermissionMessages(
+    PermissionMessageIDs ids =
+        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
             permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, messages.size());
-    EXPECT_EQ(PermissionMessage::kTabs, messages[0].id());
+    EXPECT_EQ(1u, ids.size());
+    EXPECT_EQ(PermissionMessage::kTabs, ids[0]);
   }
   {
     // 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()));
-    PermissionMessages messages =
-        PermissionMessageProvider::Get()->GetPermissionMessages(
+    PermissionMessageIDs ids =
+        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
             permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, messages.size());
-    EXPECT_EQ(PermissionMessage::kBrowsingHistory, messages[0].id());
+    EXPECT_EQ(1u, ids.size());
+    EXPECT_EQ(PermissionMessage::kBrowsingHistory, ids[0]);
   }
   {
     // All sites warning suppresses tabs warning.
     APIPermissionSet api_permissions;
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
     api_permissions.insert(APIPermission::kTab);
     scoped_refptr<PermissionSet> permissions(new PermissionSet(
         api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
-    PermissionMessages messages =
-        PermissionMessageProvider::Get()->GetPermissionMessages(
+    PermissionMessageIDs ids =
+        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
             permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, messages.size());
-    EXPECT_EQ(PermissionMessage::kHostsAll, messages[0].id());
+    EXPECT_EQ(1u, ids.size());
+    EXPECT_EQ(PermissionMessage::kHostsAll, ids[0]);
   }
   {
     // All sites warning suppresses topSites warning.
     APIPermissionSet api_permissions;
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
     api_permissions.insert(APIPermission::kTopSites);
     scoped_refptr<PermissionSet> permissions(new PermissionSet(
         api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
-    PermissionMessages messages =
-        PermissionMessageProvider::Get()->GetPermissionMessages(
+    PermissionMessageIDs ids =
+        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
             permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, messages.size());
-    EXPECT_EQ(PermissionMessage::kHostsAll, messages[0].id());
+    EXPECT_EQ(1u, ids.size());
+    EXPECT_EQ(PermissionMessage::kHostsAll, ids[0]);
   }
   {
     // All sites warning suppresses declarativeWebRequest warning.
     APIPermissionSet api_permissions;
     URLPatternSet hosts;
     hosts.AddPattern(URLPattern(URLPattern::SCHEME_CHROMEUI, "*://*/*"));
     api_permissions.insert(APIPermission::kDeclarativeWebRequest);
     scoped_refptr<PermissionSet> permissions(new PermissionSet(
         api_permissions, ManifestPermissionSet(), hosts, URLPatternSet()));
-    PermissionMessages messages =
-        PermissionMessageProvider::Get()->GetPermissionMessages(
+    PermissionMessageIDs ids =
+        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
             permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, messages.size());
-    EXPECT_EQ(PermissionMessage::kHostsAll, messages[0].id());
+    EXPECT_EQ(1u, ids.size());
+    EXPECT_EQ(PermissionMessage::kHostsAll, ids[0]);
   }
   {
     // 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()));
-    PermissionMessages messages =
-        PermissionMessageProvider::Get()->GetPermissionMessages(
+    PermissionMessageIDs ids =
+        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
             permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, messages.size());
-    EXPECT_EQ(PermissionMessage::kBrowsingHistory, messages[0].id());
+    EXPECT_EQ(1u, ids.size());
+    EXPECT_EQ(PermissionMessage::kBrowsingHistory, ids[0]);
   }
   {
     // 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()));
-    PermissionMessages messages =
-        PermissionMessageProvider::Get()->GetPermissionMessages(
+    PermissionMessageIDs ids =
+        PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
             permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, messages.size());
-    EXPECT_EQ(PermissionMessage::kTabs, messages[0].id());
+    EXPECT_EQ(1u, ids.size());
+    EXPECT_EQ(PermissionMessage::kTabs, ids[0]);
   }
 }
 
 TEST(PermissionsTest, AccessToDevicesMessages) {
   {
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kSerial);
     scoped_refptr<PermissionSet> permissions(
         new PermissionSet(api_permissions,
                           ManifestPermissionSet(),
                           URLPatternSet(),
                           URLPatternSet()));
     std::vector<base::string16> messages =
-        PermissionMessageProvider::Get()->GetWarningMessages(
+        PermissionMessageProvider::Get()->GetLegacyWarningMessages(
             permissions.get(), Manifest::TYPE_EXTENSION);
     EXPECT_EQ(1u, messages.size());
     EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL),
               messages[0]);
   }
   {
     // Testing that multiple permissions will show the one message.
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kSerial);
     api_permissions.insert(APIPermission::kSerial);
     scoped_refptr<PermissionSet> permissions(
         new PermissionSet(api_permissions,
                           ManifestPermissionSet(),
                           URLPatternSet(),
                           URLPatternSet()));
     std::vector<base::string16> messages =
-        PermissionMessageProvider::Get()->GetWarningMessages(
+        PermissionMessageProvider::Get()->GetLegacyWarningMessages(
             permissions.get(), Manifest::TYPE_EXTENSION);
     EXPECT_EQ(1u, messages.size());
     EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL),
               messages[0]);
   }
   {
     scoped_refptr<Extension> extension =
         LoadManifest("permissions", "access_to_devices_bluetooth.json");
     const PermissionMessageProvider* provider =
         PermissionMessageProvider::Get();
     PermissionSet* set = const_cast<PermissionSet*>(
         extension->permissions_data()->active_permissions().get());
     std::vector<base::string16> warnings =
-        provider->GetWarningMessages(set, extension->GetType());
+        provider->GetLegacyWarningMessages(set, extension->GetType());
     EXPECT_EQ(1u, warnings.size());
     EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH),
               warnings[0]);
 
     // Test Bluetooth and Serial
     set->apis_.insert(APIPermission::kSerial);
-    warnings = provider->GetWarningMessages(set, extension->GetType());
+    warnings = provider->GetLegacyWarningMessages(set, extension->GetType());
     EXPECT_EQ(1u, warnings.size());
     EXPECT_EQ(l10n_util::GetStringUTF16(
                   IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH_SERIAL),
               warnings[0]);
     set->apis_.erase(APIPermission::kSerial);
   }
 }
 
 TEST(PermissionsTest, MergedFileSystemPermissionComparison) {
   APIPermissionSet write_api_permissions;
@@ skipping 72 matching lines @@
 }
 
 TEST(PermissionsTest, GetWarningMessages_AudioVideo) {
   // Both audio and video present.
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "audio-video.json");
   const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
   PermissionSet* set = const_cast<PermissionSet*>(
       extension->permissions_data()->active_permissions().get());
   std::vector<base::string16> warnings =
-      provider->GetWarningMessages(set, extension->GetType());
+      provider->GetLegacyWarningMessages(set, extension->GetType());
   EXPECT_FALSE(Contains(warnings, "Use your microphone"));
   EXPECT_FALSE(Contains(warnings, "Use your camera"));
   EXPECT_TRUE(Contains(warnings, "Use your microphone and camera"));
   size_t combined_index = IndexOf(warnings, "Use your microphone and camera");
   size_t combined_size = warnings.size();
 
   // Just audio present.
   set->apis_.erase(APIPermission::kVideoCapture);
-  warnings = provider->GetWarningMessages(set, extension->GetType());
+  warnings = provider->GetLegacyWarningMessages(set, extension->GetType());
   EXPECT_EQ(combined_size, warnings.size());
   EXPECT_EQ(combined_index, IndexOf(warnings, "Use your microphone"));
   EXPECT_FALSE(Contains(warnings, "Use your camera"));
   EXPECT_FALSE(Contains(warnings, "Use your microphone and camera"));
 
   // Just video present.
   set->apis_.erase(APIPermission::kAudioCapture);
   set->apis_.insert(APIPermission::kVideoCapture);
-  warnings = provider->GetWarningMessages(set, extension->GetType());
+  warnings = provider->GetLegacyWarningMessages(set, 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(PermissionsTest, GetWarningMessages_CombinedSessions) {
   {
     APIPermissionSet api_permissions;
     api_permissions.insert(APIPermission::kTab);
     api_permissions.insert(APIPermission::kTopSites);
     api_permissions.insert(APIPermission::kProcesses);
     api_permissions.insert(APIPermission::kWebNavigation);
     api_permissions.insert(APIPermission::kSessions);
     scoped_refptr<PermissionSet> permissions(
         new PermissionSet(api_permissions, ManifestPermissionSet(),
                           URLPatternSet(), URLPatternSet()));
     std::vector<base::string16> messages =
-        PermissionMessageProvider::Get()->GetWarningMessages(
+        PermissionMessageProvider::Get()->GetLegacyWarningMessages(
             permissions.get(), Manifest::TYPE_EXTENSION);
     EXPECT_EQ(1u, messages.size());
     EXPECT_EQ(l10n_util::GetStringUTF16(
                   IDS_EXTENSION_PROMPT_WARNING_HISTORY_READ_AND_SESSIONS),
               messages[0]);
   }
   {
     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);
     api_permissions.insert(APIPermission::kSessions);
     scoped_refptr<PermissionSet> permissions(
         new PermissionSet(api_permissions, ManifestPermissionSet(),
                           URLPatternSet(), URLPatternSet()));
     std::vector<base::string16> messages =
-        PermissionMessageProvider::Get()->GetWarningMessages(
+        PermissionMessageProvider::Get()->GetLegacyWarningMessages(
             permissions.get(), Manifest::TYPE_EXTENSION);
     EXPECT_EQ(1u, messages.size());
     EXPECT_EQ(l10n_util::GetStringUTF16(
                   IDS_EXTENSION_PROMPT_WARNING_HISTORY_WRITE_AND_SESSIONS),
               messages[0]);
   }
 }
 
 TEST(PermissionsTest, GetWarningMessages_DeclarativeWebRequest) {
   // Test that if the declarativeWebRequest permission is present
   // in combination with all hosts permission, then only the warning
   // for host permissions is shown, because that covers the use of
   // declarativeWebRequest.
 
   // Until Declarative Web Request is in stable, let's make sure it is enabled
   // on the current channel.
   ScopedCurrentChannel sc(chrome::VersionInfo::CHANNEL_CANARY);
 
   // First verify that declarativeWebRequest produces a message when host
   // permissions do not cover all hosts.
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "web_request_not_all_host_permissions.json");
   const PermissionMessageProvider* provider = PermissionMessageProvider::Get();
   const PermissionSet* set =
       extension->permissions_data()->active_permissions().get();
   std::vector<base::string16> warnings =
-      provider->GetWarningMessages(set, extension->GetType());
+      provider->GetLegacyWarningMessages(set, extension->GetType());
   EXPECT_TRUE(Contains(warnings, "Block parts of web pages"));
   EXPECT_FALSE(Contains(
       warnings, "Read and change all your data on the websites you visit"));
 
   // Now verify that declarativeWebRequest does not produce a message when host
   // permissions do cover all hosts.
   extension =
       LoadManifest("permissions", "web_request_all_host_permissions.json");
   set = extension->permissions_data()->active_permissions().get();
-  warnings = provider->GetWarningMessages(set, extension->GetType());
+  warnings = provider->GetLegacyWarningMessages(set, extension->GetType());
   EXPECT_FALSE(Contains(warnings, "Block parts of web pages"));
   EXPECT_TRUE(Contains(
       warnings, "Read and change all your data on the websites you visit"));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Serial) {
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "serial.json");
 
   EXPECT_TRUE(extension->is_platform_app());
@@ skipping 545 matching lines @@
   URLPatternSet allowed_hosts;
   allowed_hosts.AddPattern(
       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()->GetPermissionMessages(
+  PermissionMessageProvider::Get()->GetLegacyPermissionMessageIDs(
       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