Extensions: Switch to new permission message system, part I

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"
 #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"
 #include "extensions/common/permissions/permission_message_provider.h"
+#include "extensions/common/permissions/permission_message_test_util.h"
 #include "extensions/common/permissions/permission_message_util.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/permissions/socket_permission.h"
 #include "extensions/common/value_builder.h"
 #include "extensions/strings/grit/extensions_strings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using extension_test_util::LoadManifest;
 
 namespace extensions {
 
 namespace {
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
-size_t IndexOf(const std::vector<base::string16>& warnings,
+size_t IndexOf(const PermissionMessageStrings& warnings,
                const std::string& warning) {
   for (size_t i = 0; i < warnings.size(); ++i) {
-    if (warnings[i] == base::ASCIIToUTF16(warning))
+    if (warnings[i].message == base::ASCIIToUTF16(warning))
       return i;
   }
 
   return warnings.size();
 }
 
-bool Contains(const std::vector<base::string16>& warnings,
-              const std::string& warning) {
-  return IndexOf(warnings, warning) != warnings.size();
-}
-
 }  // 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 903 matching lines @@
 
 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()->GetLegacyWarningMessages(
-            permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, messages.size());
-    EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL),
-              messages[0]);
+    VerifyOnePermissionMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION,
+        l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL));
   }
   {
     // 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()->GetLegacyWarningMessages(
-            permissions.get(), Manifest::TYPE_EXTENSION);
-    EXPECT_EQ(1u, messages.size());
-    EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL),
-              messages[0]);
+    VerifyOnePermissionMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION,
+        l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL));
   }
   {
     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->GetLegacyWarningMessages(set, extension->GetType());
-    EXPECT_EQ(1u, warnings.size());
-    EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH),
-              warnings[0]);
+    VerifyOnePermissionMessage(
+        set, extension->GetType(),
+        l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH));
 
     // Test Bluetooth and Serial
     set->apis_.insert(APIPermission::kSerial);
-    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);
+    VerifyOnePermissionMessage(
+        set, extension->GetType(),
+        l10n_util::GetStringUTF16(
+            IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH_SERIAL));
   }
 }
 
 TEST(PermissionsTest, MergedFileSystemPermissionComparison) {
   APIPermissionSet write_api_permissions;
   write_api_permissions.insert(APIPermission::kFileSystemWrite);
   scoped_refptr<PermissionSet> write_permissions(
       new PermissionSet(write_api_permissions, ManifestPermissionSet(),
                         URLPatternSet(), URLPatternSet()));
 
@@ skipping 28 matching lines @@
   EXPECT_FALSE(provider->IsPrivilegeIncrease(directory_permissions.get(),
                                              write_permissions.get(),
                                              Manifest::TYPE_PLATFORM_APP));
   EXPECT_TRUE(provider->IsPrivilegeIncrease(directory_permissions.get(),
                                             write_directory_permissions.get(),
                                             Manifest::TYPE_PLATFORM_APP));
 }
 
 TEST(PermissionsTest, GetWarningMessages_ManyHosts) {
   scoped_refptr<Extension> extension;
-
   extension = LoadManifest("permissions", "many-hosts.json");
-  std::vector<base::string16> warnings =
-      extension->permissions_data()->GetPermissionMessageStrings();
-  ASSERT_EQ(1u, warnings.size());
-  EXPECT_EQ(
-      "Read and change your data on encrypted.google.com and "
-      "www.google.com",
-      base::UTF16ToUTF8(warnings[0]));
+  EXPECT_TRUE(VerifyOnePermissionMessage(
+      extension->permissions_data(),
+      "Read and change your data on encrypted.google.com and www.google.com"));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Plugins) {
   scoped_refptr<Extension> extension;
-  scoped_refptr<PermissionSet> permissions;
-
   extension = LoadManifest("permissions", "plugins.json");
-  std::vector<base::string16> warnings =
-      extension->permissions_data()->GetPermissionMessageStrings();
 // We don't parse the plugins key on Chrome OS, so it should not ask for any
-  // permissions.
+// permissions.
 #if defined(OS_CHROMEOS)
-  ASSERT_EQ(0u, warnings.size());
+  EXPECT_TRUE(VerifyNoPermissionMessages(extension->permissions_data()));
 #else
-  ASSERT_EQ(1u, warnings.size());
-  EXPECT_EQ(
-      "Read and change all your data on your computer and the websites "
-      "you visit",
-      base::UTF16ToUTF8(warnings[0]));
+  EXPECT_TRUE(VerifyOnePermissionMessage(
+      extension->permissions_data(),
+      "Read and change all your data on your computer and the websites you "
+      "visit"));
 #endif
 }
 
 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->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"));
+  EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(),
+                                          "Use your microphone"));
+  EXPECT_FALSE(
+      VerifyHasPermissionMessage(set, extension->GetType(), "Use your camera"));
+  EXPECT_TRUE(VerifyHasPermissionMessage(set, extension->GetType(),
+                                         "Use your microphone and camera"));
+  PermissionMessageStrings warnings =
+      provider->GetPermissionMessageStrings(set, extension->GetType());
   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->GetLegacyWarningMessages(set, extension->GetType());
+  EXPECT_TRUE(VerifyHasPermissionMessage(set, extension->GetType(),
+                                         "Use your microphone"));
+  EXPECT_FALSE(
+      VerifyHasPermissionMessage(set, extension->GetType(), "Use your camera"));
+  EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(),
+                                          "Use your microphone and camera"));
+  warnings = provider->GetPermissionMessageStrings(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->GetLegacyWarningMessages(set, extension->GetType());
+  EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(),
+                                          "Use your microphone"));
+  EXPECT_TRUE(
+      VerifyHasPermissionMessage(set, extension->GetType(), "Use your camera"));
+  EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(),
+                                          "Use your microphone and camera"));
+  warnings = provider->GetPermissionMessageStrings(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()->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]);
+    EXPECT_TRUE(VerifyOnePermissionMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION,
+        l10n_util::GetStringUTF16(
+            IDS_EXTENSION_PROMPT_WARNING_HISTORY_READ_AND_SESSIONS)));
   }
   {
     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()->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]);
+    EXPECT_TRUE(VerifyOnePermissionMessage(
+        permissions.get(), Manifest::TYPE_EXTENSION,
+        l10n_util::GetStringUTF16(
+            IDS_EXTENSION_PROMPT_WARNING_HISTORY_WRITE_AND_SESSIONS)));
   }
 }
 
 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->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"));
+  EXPECT_TRUE(VerifyHasPermissionMessage(set, extension->GetType(),
+                                         "Block parts of web pages"));
+  EXPECT_FALSE(VerifyHasPermissionMessage(
+      set, extension->GetType(),
+      "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->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"));
+  EXPECT_FALSE(VerifyHasPermissionMessage(set, extension->GetType(),
+                                          "Block parts of web pages"));
+  EXPECT_TRUE(VerifyHasPermissionMessage(
+      set, extension->GetType(),
+      "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());
   EXPECT_TRUE(
       extension->permissions_data()->HasAPIPermission(APIPermission::kSerial));
-  std::vector<base::string16> warnings =
-      extension->permissions_data()->GetPermissionMessageStrings();
-  EXPECT_TRUE(Contains(warnings, "Access your serial devices"));
-  ASSERT_EQ(1u, warnings.size());
+  EXPECT_TRUE(VerifyOnePermissionMessage(extension->permissions_data(),
+                                         "Access your serial devices"));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Socket_AnyHost) {
   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->permissions_data()->HasAPIPermission(APIPermission::kSocket));
-  std::vector<base::string16> warnings =
-      extension->permissions_data()->GetPermissionMessageStrings();
-  EXPECT_EQ(1u, warnings.size());
-  EXPECT_TRUE(Contains(warnings, "Exchange data with any computer "
-                                 "on the local network or internet"));
+  EXPECT_TRUE(VerifyOnePermissionMessage(
+      extension->permissions_data(),
+      "Exchange data with any computer on the local network or internet"));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Socket_OneDomainTwoHostnames) {
   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->permissions_data()->HasAPIPermission(APIPermission::kSocket));
-  std::vector<base::string16> warnings =
-      extension->permissions_data()->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],
-              base::UTF8ToUTF16("Exchange data with any computer in the domain "
-                          "example.org"));
-  if (warnings.size() > 1)
-    EXPECT_EQ(warnings[1],
-              base::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
+  EXPECT_TRUE(VerifyTwoPermissionMessages(
+      extension->permissions_data(),
+      "Exchange data with any computer in the domain example.org",
+      "Exchange data with the computers named: "
+      "b\xC3\xA5r.example.com foo.example.com",
+      // "\xC3\xA5" = UTF-8 for lowercase A with ring above
+      true));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Socket_TwoDomainsOneHostname) {
   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->permissions_data()->HasAPIPermission(APIPermission::kSocket));
-  std::vector<base::string16> warnings =
-      extension->permissions_data()->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],
-              base::UTF8ToUTF16("Exchange data with any computer in the "
-                                "domains: example.com foo.example.org"));
-  if (warnings.size() > 1)
-    EXPECT_EQ(warnings[1],
-              base::UTF8ToUTF16("Exchange data with the computer named "
-                                "bar.example.org"));
+  EXPECT_TRUE(VerifyTwoPermissionMessages(
+      extension->permissions_data(),
+      "Exchange data with any computer in the domains: "
+      "example.com foo.example.org",
+      "Exchange data with the computer named bar.example.org", true));
 }
 
-TEST(PermissionsTest, GetWarningMessages_PlatformApppHosts) {
+// Since platform apps always use isolated storage, they can't (silently)
+// access user data on other domains, so there's no need to prompt about host
+// permissions. See crbug.com/255229.
+TEST(PermissionsTest, GetWarningMessages_PlatformAppHosts) {
   scoped_refptr<Extension> extension;
 
   extension = LoadManifest("permissions", "platform_app_hosts.json");
   EXPECT_TRUE(extension->is_platform_app());
-  std::vector<base::string16> warnings =
-      extension->permissions_data()->GetPermissionMessageStrings();
-  ASSERT_EQ(0u, warnings.size());
+  EXPECT_TRUE(VerifyNoPermissionMessages(extension->permissions_data()));
 
   extension = LoadManifest("permissions", "platform_app_all_urls.json");
   EXPECT_TRUE(extension->is_platform_app());
-  warnings = extension->permissions_data()->GetPermissionMessageStrings();
-  ASSERT_EQ(0u, warnings.size());
+  EXPECT_TRUE(VerifyNoPermissionMessages(extension->permissions_data()));
 }
 
-bool ShowsAllHostsWarning(const std::string& pattern) {
+testing::AssertionResult ShowsAllHostsWarning(const std::string& pattern) {
   scoped_refptr<Extension> extension =
       ExtensionBuilder()
           .SetManifest(DictionaryBuilder()
                            .Set("name", "TLDWildCardTest")
                            .Set("version", "0.1.0")
                            .Set("permissions", ListBuilder().Append(pattern))
                            .Build())
           .Build();
 
-  std::vector<base::string16> warnings =
-      extension->permissions_data()->GetPermissionMessageStrings();
-
-  if (warnings.empty())
-    return false;
-
-  if (warnings[0] !=
-      l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_ALL_HOSTS)) {
-    return false;
-  }
-
-  return true;
+  return VerifyHasPermissionMessage(
+      extension->permissions_data(),
+      l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_ALL_HOSTS));
 }
 
 TEST(PermissionsTest, GetWarningMessages_TLDWildcardTreatedAsAllHosts) {
   EXPECT_TRUE(ShowsAllHostsWarning("http://*.com/*"));    // most popular.
   EXPECT_TRUE(ShowsAllHostsWarning("http://*.org/*"));    // sanity check.
   EXPECT_TRUE(ShowsAllHostsWarning("http://*.co.uk/*"));  // eTLD.
   EXPECT_TRUE(ShowsAllHostsWarning("http://*.de/*"));  // foreign country tld.
 
   // We should still show the normal permissions (i.e., "Can access your data on
   // *.rdcronin.com") for things that are not TLDs.
@@ skipping 402 matching lines @@
 }
 
 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->permissions_data()->HasAPIPermission(
       APIPermission::kSyncFileSystem));
-  std::vector<base::string16> warnings =
-      extension->permissions_data()->GetPermissionMessageStrings();
-  EXPECT_TRUE(Contains(warnings, "Store data in your Google Drive account"));
-  ASSERT_EQ(1u, warnings.size());
+  EXPECT_TRUE(
+      VerifyOnePermissionMessage(extension->permissions_data(),
+                                 "Store data in your Google Drive account"));
 }
 
 // Make sure that we don't crash when we're trying to show the permissions
 // even though chrome://thumb (and everything that's not chrome://favicon with
 // a chrome:// scheme) is not a valid permission.
 // More details here: crbug/246314.
 TEST(PermissionsTest, ChromeURLs) {
   URLPatternSet allowed_hosts;
   allowed_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_ALL, "http://www.google.com/"));
@@ skipping 19 matching lines @@
   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