Extensions: Switch to new permission message system, part I

- Update lots of tests to check that the old and new system match.
- In the process, fix two small bugs in the new system.
- Rename PermissionsData::GetPermissionMessageStrings and GetPermissionMessageDetailsStrings to "*Legacy*", to match the corresponding methods in PermissionMessageProvider.

BUG=398257

TBR=asargent
for a trivial rename in ephemeral_app_launcher.cc

Review URL: https://codereview.chromium.org/980353003

Cr-Commit-Position: refs/heads/master@{#321550}

11 files changed, 593 insertions, 27 deletions

diff --git a/extensions/browser/api/management/management_api.cc b/extensions/browser/api/management/management_api.cc
index 2eb5b44..4379464 100644
--- a/extensions/browser/api/management/management_api.cc
+++ b/extensions/browser/api/management/management_api.cc
@@ -62,7 +62,7 @@ AutoConfirmForTest auto_confirm_for_test = DO_NOT_SKIP;
 std::vector<std::string> CreateWarningsList(const Extension* extension) {
   std::vector<std::string> warnings_list;
   for (const base::string16& warning :
-       extension->permissions_data()->GetPermissionMessageStrings()) {
+       extension->permissions_data()->GetLegacyPermissionMessageStrings()) {
     warnings_list.push_back(base::UTF16ToUTF8(warning));
   }
 
diff --git a/extensions/common/permissions/permission_message_provider.cc b/extensions/common/permissions/permission_message_provider.cc
index 80cc582..f194340 100644
--- a/extensions/common/permissions/permission_message_provider.cc
+++ b/extensions/common/permissions/permission_message_provider.cc
@@ -4,16 +4,47 @@
 
 #include "extensions/common/permissions/permission_message_provider.h"
 
+#include "base/metrics/field_trial.h"
 #include "base/strings/string_split.h"
 #include "extensions/common/extensions_client.h"
 
 namespace extensions {
 
+namespace {
+
+ForceForTesting g_force_permission_system_for_testing =
+    ForceForTesting::DONT_FORCE;
+
+bool IsNewPermissionMessageSystemEnabled() {
+  if (g_force_permission_system_for_testing != ForceForTesting::DONT_FORCE)
+    return g_force_permission_system_for_testing == ForceForTesting::FORCE_NEW;
+  const std::string group_name =
+      base::FieldTrialList::FindFullName("PermissionMessageSystem");
+  return group_name == "NewSystem";
+}
+
+}  // namespace
+
+void ForcePermissionMessageSystemForTesting(
+    ForceForTesting force) {
+  g_force_permission_system_for_testing = force;
+}
+
 PermissionMessageString::PermissionMessageString(
     const CoalescedPermissionMessage& message)
     : message(message.message()), submessages(message.submessages()) {
 }
 
+PermissionMessageString::PermissionMessageString(const base::string16& message)
+    : message(message) {
+}
+
+PermissionMessageString::PermissionMessageString(
+    const base::string16& message,
+    const std::vector<base::string16>& submessages)
+    : message(message), submessages(submessages) {
+}
+
 PermissionMessageString::PermissionMessageString(const base::string16& message,
                                                  const base::string16& details)
     : message(message) {
@@ -28,4 +59,26 @@ const PermissionMessageProvider* PermissionMessageProvider::Get() {
   return &(ExtensionsClient::Get()->GetPermissionMessageProvider());
 }
 
+PermissionMessageStrings
+PermissionMessageProvider::GetPermissionMessageStrings(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type) const {
+  PermissionMessageStrings strings;
+  if (IsNewPermissionMessageSystemEnabled()) {
+    CoalescedPermissionMessages messages = GetCoalescedPermissionMessages(
+        GetAllPermissionIDs(permissions, extension_type));
+    for (const CoalescedPermissionMessage& msg : messages)
+      strings.push_back(PermissionMessageString(msg));
+  } else {
+    std::vector<base::string16> messages =
+        GetLegacyWarningMessages(permissions, extension_type);
+    std::vector<base::string16> details =
+        GetLegacyWarningMessagesDetails(permissions, extension_type);
+    DCHECK_EQ(messages.size(), details.size());
+    for (size_t i = 0; i < messages.size(); i++)
+      strings.push_back(PermissionMessageString(messages[i], details[i]));
+  }
+  return strings;
+}
+
 }  // namespace extensions
diff --git a/extensions/common/permissions/permission_message_provider.h b/extensions/common/permissions/permission_message_provider.h
index 942cb09..3b8e5ac 100644
--- a/extensions/common/permissions/permission_message_provider.h
+++ b/extensions/common/permissions/permission_message_provider.h
@@ -21,6 +21,9 @@ class PermissionSet;
 // TODO(treib): Remove this once we've switched to the new system.
 struct PermissionMessageString {
   PermissionMessageString(const CoalescedPermissionMessage& message);
+  PermissionMessageString(const base::string16& message);
+  PermissionMessageString(const base::string16& message,
+                          const std::vector<base::string16>& submessages);
   PermissionMessageString(const base::string16& message,
                           const base::string16& details);
   ~PermissionMessageString();
@@ -30,6 +33,14 @@ struct PermissionMessageString {
 };
 typedef std::vector<PermissionMessageString> PermissionMessageStrings;
 
+enum class ForceForTesting {
+  DONT_FORCE,
+  FORCE_OLD,
+  FORCE_NEW
+};
+
+void ForcePermissionMessageSystemForTesting(ForceForTesting force);
+
 // The PermissionMessageProvider interprets permissions, translating them
 // into warning messages to show to the user. It also determines whether
 // a new set of permissions entails showing new warning messages.
@@ -47,9 +58,9 @@ class PermissionMessageProvider {
   // cmdline flag.
   // TODO(treib): Remove this once we've switched to the new system, and update
   // all callers to use GetCoalescedPermissionMessages directly.
-  virtual PermissionMessageStrings GetPermissionMessageStrings(
+  PermissionMessageStrings GetPermissionMessageStrings(
       const PermissionSet* permissions,
-      Manifest::Type extension_type) const = 0;
+      Manifest::Type extension_type) const;
 
   // Gets the legacy permission message IDs that represent this set.
   // Deprecated. You DO NOT want to call this!
diff --git a/extensions/common/permissions/permission_message_test_util.cc b/extensions/common/permissions/permission_message_test_util.cc
new file mode 100644
index 0000000..47e9913
--- /dev/null
+++ b/extensions/common/permissions/permission_message_test_util.cc
@@ -0,0 +1,414 @@
+// Copyright 2015 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 "extensions/common/permissions/permission_message_test_util.h"
+
+#include <algorithm>
+#include <iterator>
+
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "extensions/common/permissions/permission_message_provider.h"
+#include "extensions/common/permissions/permissions_data.h"
+
+// TODO(treib): Remove the legacy messages once we've fully switched to the new
+// permission message system.
+
+namespace extensions {
+
+namespace {
+
+class ScopedForcePermissionMessageSystem {
+ public:
+  ScopedForcePermissionMessageSystem(ForceForTesting force) {
+    extensions::ForcePermissionMessageSystemForTesting(force);
+  }
+  ~ScopedForcePermissionMessageSystem() {
+    extensions::ForcePermissionMessageSystemForTesting(
+        ForceForTesting::DONT_FORCE);
+  }
+};
+
+PermissionMessageStrings GetLegacyMessages(
+    const PermissionsData* permissions_data) {
+  ScopedForcePermissionMessageSystem force(ForceForTesting::FORCE_OLD);
+  return permissions_data->GetPermissionMessageStrings();
+}
+
+PermissionMessageStrings GetLegacyMessages(const PermissionSet* permissions,
+                                           Manifest::Type extension_type) {
+  ScopedForcePermissionMessageSystem force(ForceForTesting::FORCE_OLD);
+  return PermissionMessageProvider::Get()->GetPermissionMessageStrings(
+      permissions, extension_type);
+}
+
+PermissionMessageStrings GetNewMessages(
+    const PermissionsData* permissions_data) {
+  ScopedForcePermissionMessageSystem force(ForceForTesting::FORCE_NEW);
+  return permissions_data->GetPermissionMessageStrings();
+}
+
+PermissionMessageStrings GetNewMessages(const PermissionSet* permissions,
+                                        Manifest::Type extension_type) {
+  ScopedForcePermissionMessageSystem force(ForceForTesting::FORCE_NEW);
+  return PermissionMessageProvider::Get()->GetPermissionMessageStrings(
+      permissions, extension_type);
+}
+
+std::vector<base::string16> MakeVectorString16(const base::string16& str) {
+  return std::vector<base::string16>(1, str);
+}
+
+std::vector<base::string16> MakeVectorString16(const base::string16& str1,
+                                               const base::string16& str2) {
+  std::vector<base::string16> result;
+  result.push_back(str1);
+  result.push_back(str2);
+  return result;
+}
+
+std::vector<base::string16> MakeVectorString16(const std::string& str1,
+                                               const std::string& str2) {
+  return MakeVectorString16(base::UTF8ToUTF16(str1), base::UTF8ToUTF16(str2));
+}
+
+std::vector<base::string16> MakeVectorString16(
+    const std::vector<std::string>& vec) {
+  std::vector<base::string16> result;
+  for (const std::string& msg : vec)
+    result.push_back(base::UTF8ToUTF16(msg));
+  return result;
+}
+
+std::vector<std::vector<base::string16>> MakeVectorVectorString16(
+    const std::vector<base::string16>& vec) {
+  return std::vector<std::vector<base::string16>>(1, vec);
+}
+
+std::vector<std::vector<base::string16>> MakeVectorVectorString16(
+    const std::vector<std::vector<std::string>>& vecs) {
+  std::vector<std::vector<base::string16>> result;
+  for (const std::vector<std::string>& vec : vecs)
+    result.push_back(MakeVectorString16(vec));
+  return result;
+}
+
+// Returns the vector of messages concatenated into a single string, separated
+// by newlines, e.g.: "Bar"\n"Baz"\n
+base::string16 MessagesVectorToString(
+    const std::vector<base::string16>& messages) {
+  if (messages.empty())
+    return base::ASCIIToUTF16("\n");
+  return base::ASCIIToUTF16("\"") +
+         JoinString(messages, base::ASCIIToUTF16("\"\n\"")) +
+         base::ASCIIToUTF16("\"\n");
+}
+
+base::string16 MessagesToString(const PermissionMessageStrings& messages) {
+  std::vector<base::string16> messages_vec;
+  for (const PermissionMessageString& msg : messages)
+    messages_vec.push_back(msg.message);
+  return MessagesVectorToString(messages_vec);
+}
+
+bool CheckThatSubmessagesMatch(
+    const PermissionMessageString& expected_message,
+    const std::vector<base::string16>& actual_legacy_submessages,
+    const std::vector<base::string16>& actual_submessages) {
+  bool result = true;
+
+  std::vector<base::string16> expected_sorted;
+  for (const base::string16& submessage : expected_message.submessages)
+    expected_sorted.push_back(submessage);
+  std::sort(expected_sorted.begin(), expected_sorted.end());
+
+  std::vector<base::string16> actual_legacy_sorted(actual_legacy_submessages);
+  std::sort(actual_legacy_sorted.begin(), actual_legacy_sorted.end());
+  if (expected_sorted != actual_legacy_sorted) {
+    // This is always a failure, even within an EXPECT_FALSE.
+    // Message: Expected details for "Message" to be { "Foo" }, but got
+    // { "Bar", "Baz" } in the legacy system
+    ADD_FAILURE() << "Expected details for \"" << expected_message.message
+                  << "\" to be:\n" << MessagesVectorToString(expected_sorted)
+                  << "But got:\n"
+                  << MessagesVectorToString(actual_legacy_sorted)
+                  << "in the legacy system";
+    result = false;
+  }
+
+  std::vector<base::string16> actual_sorted(actual_submessages);
+  std::sort(actual_sorted.begin(), actual_sorted.end());
+  if (actual_sorted != actual_submessages) {
+    // This is always a failure, even within an EXPECT_FALSE.
+    // Message: Expected submessages for "Message" to be { "Foo" }, but got
+    // { "Bar", "Baz" }
+    ADD_FAILURE() << "Expected submessages for \"" << expected_message.message
+                  << "\" to be:\n" << MessagesVectorToString(expected_sorted)
+                  << "But got:\n" << MessagesVectorToString(actual_sorted);
+    result = false;
+  }
+
+  return result;
+}
+
+testing::AssertionResult VerifyHasPermissionMessageImpl(
+    const PermissionMessageString& expected_message,
+    const PermissionMessageStrings& actual_legacy_messages,
+    const PermissionMessageStrings& actual_messages) {
+  auto legacy_message_it =
+      std::find_if(actual_legacy_messages.begin(), actual_legacy_messages.end(),
+                   [&expected_message](const PermissionMessageString& msg) {
+                     return msg.message == expected_message.message;
+                   });
+  bool legacy_found = legacy_message_it != actual_legacy_messages.end();
+
+  auto message_it =
+      std::find_if(actual_messages.begin(), actual_messages.end(),
+                   [&expected_message](const PermissionMessageString& msg) {
+                     return msg.message == expected_message.message;
+                   });
+  bool found = message_it != actual_messages.end();
+
+  if (legacy_found != found) {
+    // This is always a failure, even within an EXPECT_FALSE.
+    ADD_FAILURE()
+        << "Mismatch between legacy and new system when looking for \""
+        << expected_message.message << "\".\nLegacy system returned:\n"
+        << MessagesToString(actual_legacy_messages)
+        << "New system returned:\n" << MessagesToString(actual_messages);
+    return testing::AssertionFailure();
+  }
+
+  if (!found) {
+    // Message: Expected messages to contain "Foo", but got { "Bar", "Baz" }
+    return testing::AssertionFailure() << "Expected messages to contain \""
+                                       << expected_message.message
+                                       << "\", but got "
+                                       << MessagesToString(actual_messages);
+  }
+
+  if (!CheckThatSubmessagesMatch(expected_message,
+                                 legacy_message_it->submessages,
+                                 message_it->submessages)) {
+    return testing::AssertionFailure();
+  }
+
+  // Message: Expected messages NOT to contain "Foo", but got { "Bar", "Baz" }
+  return testing::AssertionSuccess() << "Expected messages NOT to contain \""
+                                     << expected_message.message
+                                     << "\", but got "
+                                     << MessagesToString(actual_messages);
+}
+
+testing::AssertionResult VerifyPermissionMessagesWithSubmessagesImpl(
+    const PermissionMessageStrings& expected_messages,
+    const PermissionMessageStrings& actual_legacy_messages,
+    const PermissionMessageStrings& actual_messages,
+    bool check_order) {
+  if (expected_messages.size() != actual_legacy_messages.size()) {
+    // Message: Expected 2 messages { "Bar", "Baz" }, but got 0 {} in the
+    // legacy system
+    return testing::AssertionFailure()
+           << "Expected " << expected_messages.size() << " messages:\n"
+           << MessagesToString(expected_messages) << "But got "
+           << actual_legacy_messages.size() << " messages:\n"
+           << MessagesToString(actual_legacy_messages)
+           << "in the legacy system";
+  }
+
+  if (expected_messages.size() != actual_messages.size()) {
+    // Message: Expected 2 messages { "Bar", "Baz" }, but got 0 {}
+    return testing::AssertionFailure()
+           << "Expected " << expected_messages.size() << " messages:\n"
+           << MessagesToString(expected_messages) << "But got "
+           << actual_messages.size() << " messages:\n"
+           << MessagesToString(actual_messages);
+  }
+
+  if (check_order) {
+    for (size_t i = 0; i < expected_messages.size(); i++) {
+      if (expected_messages[i].message != actual_legacy_messages[i].message) {
+        // Message: Expected messages to be { "Foo" }, but got { "Bar", "Baz" }
+        // in the legacy system
+        return testing::AssertionFailure()
+               << "Expected messages to be:\n"
+               << MessagesToString(expected_messages) << "But got:\n"
+               << MessagesToString(actual_legacy_messages)
+               << "in the legacy system";
+      }
+
+      if (expected_messages[i].message != actual_messages[i].message) {
+        // Message: Expected messages to be { "Foo" }, but got { "Bar", "Baz" }
+        return testing::AssertionFailure()
+               << "Expected messages to be:\n"
+               << MessagesToString(expected_messages) << "But got:\n"
+               << MessagesToString(actual_messages);
+      }
+
+      if (!CheckThatSubmessagesMatch(expected_messages[i],
+                                     actual_legacy_messages[i].submessages,
+                                     actual_messages[i].submessages)) {
+        return testing::AssertionFailure();
+      }
+    }
+  } else {
+    for (size_t i = 0; i < expected_messages.size(); i++) {
+      testing::AssertionResult result = VerifyHasPermissionMessageImpl(
+          expected_messages[i], actual_legacy_messages, actual_messages);
+      if (!result)
+        return result;
+    }
+  }
+  return testing::AssertionSuccess();
+}
+
+}  // namespace
+
+testing::AssertionResult VerifyHasPermissionMessage(
+    const PermissionsData* permissions_data,
+    const std::string& expected_message) {
+  return VerifyHasPermissionMessage(permissions_data,
+                                    base::UTF8ToUTF16(expected_message));
+}
+
+testing::AssertionResult VerifyHasPermissionMessage(
+    const PermissionsData* permissions_data,
+    const base::string16& expected_message) {
+  return VerifyHasPermissionMessageImpl(
+      PermissionMessageString(expected_message),
+      GetLegacyMessages(permissions_data), GetNewMessages(permissions_data));
+}
+
+testing::AssertionResult VerifyHasPermissionMessage(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type,
+    const std::string& expected_message) {
+  return VerifyHasPermissionMessage(permissions, extension_type,
+                                    base::UTF8ToUTF16(expected_message));
+}
+
+testing::AssertionResult VerifyHasPermissionMessage(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type,
+    const base::string16& expected_message) {
+  return VerifyHasPermissionMessageImpl(
+      PermissionMessageString(expected_message),
+      GetLegacyMessages(permissions, extension_type),
+      GetNewMessages(permissions, extension_type));
+}
+
+testing::AssertionResult VerifyNoPermissionMessages(
+    const PermissionsData* permissions_data) {
+  return VerifyPermissionMessages(permissions_data,
+                                  std::vector<base::string16>(), true);
+}
+
+testing::AssertionResult VerifyOnePermissionMessage(
+    const PermissionsData* permissions_data,
+    const std::string& expected_message) {
+  return VerifyOnePermissionMessage(permissions_data,
+                                    base::UTF8ToUTF16(expected_message));
+}
+
+testing::AssertionResult VerifyOnePermissionMessage(
+    const PermissionsData* permissions_data,
+    const base::string16& expected_message) {
+  return VerifyPermissionMessages(permissions_data,
+                                  MakeVectorString16(expected_message), true);
+}
+
+testing::AssertionResult VerifyOnePermissionMessage(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type,
+    const base::string16& expected_message) {
+  return VerifyPermissionMessagesWithSubmessagesImpl(
+      PermissionMessageStrings(1, PermissionMessageString(expected_message)),
+      GetLegacyMessages(permissions, extension_type),
+      GetNewMessages(permissions, extension_type), true);
+}
+
+testing::AssertionResult VerifyOnePermissionMessageWithSubmessages(
+    const PermissionsData* permissions_data,
+    const std::string& expected_message,
+    const std::vector<std::string>& expected_submessages) {
+  return VerifyOnePermissionMessageWithSubmessages(
+      permissions_data, base::UTF8ToUTF16(expected_message),
+      MakeVectorString16(expected_submessages));
+}
+
+testing::AssertionResult VerifyOnePermissionMessageWithSubmessages(
+    const PermissionsData* permissions_data,
+    const base::string16& expected_message,
+    const std::vector<base::string16>& expected_submessages) {
+  return VerifyPermissionMessagesWithSubmessages(
+      permissions_data, MakeVectorString16(expected_message),
+      MakeVectorVectorString16(expected_submessages), true);
+}
+
+testing::AssertionResult VerifyTwoPermissionMessages(
+    const PermissionsData* permissions_data,
+    const std::string& expected_message_1,
+    const std::string& expected_message_2,
+    bool check_order) {
+  return VerifyPermissionMessages(
+      permissions_data,
+      MakeVectorString16(expected_message_1, expected_message_2), check_order);
+}
+
+testing::AssertionResult VerifyTwoPermissionMessages(
+    const PermissionsData* permissions_data,
+    const base::string16& expected_message_1,
+    const base::string16& expected_message_2,
+    bool check_order) {
+  return VerifyPermissionMessages(
+      permissions_data,
+      MakeVectorString16(expected_message_1, expected_message_2), check_order);
+}
+
+testing::AssertionResult VerifyPermissionMessages(
+    const PermissionsData* permissions_data,
+    const std::vector<std::string>& expected_messages,
+    bool check_order) {
+  return VerifyPermissionMessages(
+      permissions_data, MakeVectorString16(expected_messages), check_order);
+}
+
+testing::AssertionResult VerifyPermissionMessages(
+    const PermissionsData* permissions_data,
+    const std::vector<base::string16>& expected_messages,
+    bool check_order) {
+  return VerifyPermissionMessagesWithSubmessages(
+      permissions_data, expected_messages,
+      std::vector<std::vector<base::string16>>(expected_messages.size()),
+      check_order);
+}
+
+testing::AssertionResult VerifyPermissionMessagesWithSubmessages(
+    const PermissionsData* permissions_data,
+    const std::vector<std::string>& expected_messages,
+    const std::vector<std::vector<std::string>>& expected_submessages,
+    bool check_order) {
+  return VerifyPermissionMessagesWithSubmessages(
+      permissions_data, MakeVectorString16(expected_messages),
+      MakeVectorVectorString16(expected_submessages), check_order);
+}
+
+testing::AssertionResult VerifyPermissionMessagesWithSubmessages(
+    const PermissionsData* permissions_data,
+    const std::vector<base::string16>& expected_messages,
+    const std::vector<std::vector<base::string16>>& expected_submessages,
+    bool check_order) {
+  CHECK_EQ(expected_messages.size(), expected_submessages.size());
+  PermissionMessageStrings expected;
+  for (size_t i = 0; i < expected_messages.size(); i++) {
+    expected.push_back(PermissionMessageString(expected_messages[i],
+                                               expected_submessages[i]));
+  }
+  return VerifyPermissionMessagesWithSubmessagesImpl(
+      expected, GetLegacyMessages(permissions_data),
+      GetNewMessages(permissions_data), check_order);
+}
+
+}  // namespace extensions
diff --git a/extensions/common/permissions/permission_message_test_util.h b/extensions/common/permissions/permission_message_test_util.h
new file mode 100644
index 0000000..8cfc3e0
--- /dev/null
+++ b/extensions/common/permissions/permission_message_test_util.h
@@ -0,0 +1,91 @@
+// Copyright 2015 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.
+
+#ifndef EXTENSIONS_COMMON_PERMISSIONS_PERMISSION_MESSAGE_TEST_UTIL_H_
+#define EXTENSIONS_COMMON_PERMISSIONS_PERMISSION_MESSAGE_TEST_UTIL_H_
+
+#include <string>
+#include <vector>
+
+#include "base/strings/string16.h"
+#include "extensions/common/manifest.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace extensions {
+
+class PermissionsData;
+class PermissionSet;
+
+testing::AssertionResult VerifyHasPermissionMessage(
+    const PermissionsData* permissions_data,
+    const std::string& expected_message);
+testing::AssertionResult VerifyHasPermissionMessage(
+    const PermissionsData* permissions_data,
+    const base::string16& expected_message);
+testing::AssertionResult VerifyHasPermissionMessage(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type,
+    const std::string& expected_message);
+testing::AssertionResult VerifyHasPermissionMessage(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type,
+    const base::string16& expected_message);
+
+testing::AssertionResult VerifyNoPermissionMessages(
+    const PermissionsData* permissions_data);
+
+testing::AssertionResult VerifyOnePermissionMessage(
+    const PermissionsData* permissions_data,
+    const std::string& expected_message);
+testing::AssertionResult VerifyOnePermissionMessage(
+    const PermissionsData* permissions_data,
+    const base::string16& expected_message);
+testing::AssertionResult VerifyOnePermissionMessage(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type,
+    const base::string16& expected_message);
+
+testing::AssertionResult VerifyOnePermissionMessageWithSubmessages(
+    const PermissionsData* permissions_data,
+    const std::string& expected_message,
+    const std::vector<std::string>& expected_submessages);
+testing::AssertionResult VerifyOnePermissionMessageWithSubmessages(
+    const PermissionsData* permissions_data,
+    const base::string16& expected_message,
+    const std::vector<base::string16>& expected_submessages);
+
+testing::AssertionResult VerifyTwoPermissionMessages(
+    const PermissionsData* permissions_data,
+    const std::string& expected_message_1,
+    const std::string& expected_message_2,
+    bool check_order);
+testing::AssertionResult VerifyTwoPermissionMessages(
+    const PermissionsData* permissions_data,
+    const base::string16& expected_message_1,
+    const base::string16& expected_message_2,
+    bool check_order);
+
+testing::AssertionResult VerifyPermissionMessages(
+    const PermissionsData* permissions_data,
+    const std::vector<std::string>& expected_messages,
+    bool check_order);
+testing::AssertionResult VerifyPermissionMessages(
+    const PermissionsData* permissions_data,
+    const std::vector<base::string16>& expected_messages,
+    bool check_order);
+
+testing::AssertionResult VerifyPermissionMessagesWithSubmessages(
+    const PermissionsData* permissions_data,
+    const std::vector<std::string>& expected_messages,
+    const std::vector<std::vector<std::string>>& expected_submessages,
+    bool check_order);
+testing::AssertionResult VerifyPermissionMessagesWithSubmessages(
+    const PermissionsData* permissions_data,
+    const std::vector<base::string16>& expected_messages,
+    const std::vector<std::vector<base::string16>>& expected_submessages,
+    bool check_order);
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_COMMON_PERMISSIONS_PERMISSION_MESSAGE_TEST_UTIL_H_
diff --git a/extensions/common/permissions/permissions_data.cc b/extensions/common/permissions/permissions_data.cc
index 92eabb5..2202758 100644
--- a/extensions/common/permissions/permissions_data.cc
+++ b/extensions/common/permissions/permissions_data.cc
@@ -13,7 +13,6 @@
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/permissions_parser.h"
-#include "extensions/common/permissions/permission_message_provider.h"
 #include "extensions/common/permissions/permission_message_util.h"
 #include "extensions/common/switches.h"
 #include "extensions/common/url_pattern_set.h"
@@ -205,7 +204,14 @@ PermissionMessageIDs PermissionsData::GetLegacyPermissionMessageIDs() const {
   }
 }
 
-std::vector<base::string16> PermissionsData::GetPermissionMessageStrings()
+PermissionMessageStrings PermissionsData::GetPermissionMessageStrings() const {
+  if (ShouldSkipPermissionWarnings(extension_id_))
+    return PermissionMessageStrings();
+  return PermissionMessageProvider::Get()->GetPermissionMessageStrings(
+      active_permissions().get(), manifest_type_);
+}
+
+std::vector<base::string16> PermissionsData::GetLegacyPermissionMessageStrings()
     const {
   if (ShouldSkipPermissionWarnings(extension_id_))
     return std::vector<base::string16>();
@@ -214,7 +220,7 @@ std::vector<base::string16> PermissionsData::GetPermissionMessageStrings()
 }
 
 std::vector<base::string16>
-PermissionsData::GetPermissionMessageDetailsStrings() const {
+PermissionsData::GetLegacyPermissionMessageDetailsStrings() const {
   if (ShouldSkipPermissionWarnings(extension_id_))
     return std::vector<base::string16>();
   return PermissionMessageProvider::Get()->GetLegacyWarningMessagesDetails(
diff --git a/extensions/common/permissions/permissions_data.h b/extensions/common/permissions/permissions_data.h
index ab7ea52..3fee044 100644
--- a/extensions/common/permissions/permissions_data.h
+++ b/extensions/common/permissions/permissions_data.h
@@ -16,6 +16,7 @@
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/coalesced_permission_message.h"
 #include "extensions/common/permissions/permission_message.h"
+#include "extensions/common/permissions/permission_message_provider.h"
 #include "extensions/common/permissions/permission_set.h"
 
 class GURL;
@@ -71,7 +72,7 @@ class PermissionsData {
       const Extension* extension,
       const PermissionSet* permissions);
 
-  // Returns true if we should skip the permisisons warning for the extension
+  // Returns true if we should skip the permissions warning for the extension
   // with the given |extension_id|.
   static bool ShouldSkipPermissionWarnings(const std::string& extension_id);
 
@@ -138,13 +139,17 @@ class PermissionsData {
 
   // Returns the full list of permission messages that should display at install
   // time as strings.
-  // TODO(sashab): Deprecate this in favor of GetCoalescedPermissionMessages().
-  std::vector<base::string16> GetPermissionMessageStrings() const;
+  PermissionMessageStrings GetPermissionMessageStrings() const;
+
+  // Returns the full list of permission messages that should display at install
+  // time as strings.
+  // TODO(sashab): Deprecate this in favor of GetPermissionMessageStrings.
+  std::vector<base::string16> GetLegacyPermissionMessageStrings() const;
 
   // Returns the full list of permission details for messages that should
   // display at install time as strings.
-  // TODO(sashab): Deprecate this in favor of GetCoalescedPermissionMessages().
-  std::vector<base::string16> GetPermissionMessageDetailsStrings() const;
+  // TODO(sashab): Deprecate this in favor of GetPermissionMessageStrings.
+  std::vector<base::string16> GetLegacyPermissionMessageDetailsStrings() const;
 
   // Returns the full list of permission details for messages that should
   // display at install time, in a nested format ready for display.
diff --git a/extensions/extensions.gypi b/extensions/extensions.gypi
index 03c3ae7..8db0724 100644
--- a/extensions/extensions.gypi
+++ b/extensions/extensions.gypi
@@ -1013,6 +1013,8 @@
       'common/extension_builder.h',
       'common/manifest_test.cc',
       'common/manifest_test.h',
+      'common/permissions/permission_message_test_util.cc',
+      'common/permissions/permission_message_test_util.h',
       'common/test_util.cc',
       'common/test_util.h',
       'renderer/test_extensions_renderer_client.cc',
diff --git a/extensions/shell/common/shell_extensions_client.cc b/extensions/shell/common/shell_extensions_client.cc
index 072ebb1..c3d07ea 100644
--- a/extensions/shell/common/shell_extensions_client.cc
+++ b/extensions/shell/common/shell_extensions_client.cc
@@ -42,12 +42,6 @@ class ShellPermissionMessageProvider : public PermissionMessageProvider {
   ~ShellPermissionMessageProvider() override {}
 
   // PermissionMessageProvider implementation.
-  PermissionMessageStrings GetPermissionMessageStrings(
-      const PermissionSet* permissions,
-      Manifest::Type extension_type) const override {
-    return PermissionMessageStrings();
-  }
-
   PermissionMessageIDs GetLegacyPermissionMessageIDs(
       const PermissionSet* permissions,
       Manifest::Type extension_type) const override {
diff --git a/extensions/test/test_permission_message_provider.cc b/extensions/test/test_permission_message_provider.cc
index 28a9112..6f7a7d8 100644
--- a/extensions/test/test_permission_message_provider.cc
+++ b/extensions/test/test_permission_message_provider.cc
@@ -12,13 +12,6 @@ TestPermissionMessageProvider::TestPermissionMessageProvider() {
 TestPermissionMessageProvider::~TestPermissionMessageProvider() {
 }
 
-PermissionMessageStrings
-TestPermissionMessageProvider::GetPermissionMessageStrings(
-    const PermissionSet* permissions,
-    Manifest::Type extension_type) const {
-  return PermissionMessageStrings();
-}
-
 PermissionMessageIDs
 TestPermissionMessageProvider::GetLegacyPermissionMessageIDs(
     const PermissionSet* permissions,
diff --git a/extensions/test/test_permission_message_provider.h b/extensions/test/test_permission_message_provider.h
index 6cefa22..091fe01 100644
--- a/extensions/test/test_permission_message_provider.h
+++ b/extensions/test/test_permission_message_provider.h
@@ -16,9 +16,6 @@ class TestPermissionMessageProvider : public PermissionMessageProvider {
   ~TestPermissionMessageProvider() override;
 
  private:
-  PermissionMessageStrings GetPermissionMessageStrings(
-      const PermissionSet* permissions,
-      Manifest::Type extension_type) const override;
   PermissionMessageIDs GetLegacyPermissionMessageIDs(
       const PermissionSet* permissions,
       Manifest::Type extension_type) const override;