Extensions: Prepare switch to new permission message system

chrome/common/extensions/permissions/chrome_permission_message_provider.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/common/extensions/permissions/chrome_permission_message_provider.h"
 
 #include "base/memory/scoped_vector.h"
+#include "base/metrics/field_trial.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/common/extensions/permissions/chrome_permission_message_rules.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/permissions/permission_message.h"
 #include "extensions/common/permissions/permission_message_util.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/url_pattern.h"
 #include "extensions/common/url_pattern_set.h"
 #include "grit/extensions_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
+bool IsNewPermissionMessageSystemEnabled() {
+  const std::string group_name =
+      base::FieldTrialList::FindFullName("PermissionMessageSystem");

[Yoyo Zhou, 2015/03/12 20:55:57]

You haven't defined this field trial yet (see field_trial.h documentation). IMO
you should do so in this patch, because otherwise we're asking about a
nonexistent field trial. The trial can start out with 100% of users not using
the new system.

[Marc Treib, 2015/03/13 10:43:09]

My intention was to enable this through Finch. In that case, I think we mustn't
define the field trial in Chrome (see go/finch-guide).

[Yoyo Zhou, 2015/03/13 18:08:13]

Ok.

+  return group_name == "NewSystem";
+}
+
 typedef std::set<PermissionMessage> PermissionMsgSet;
 
 template<typename T>
 typename T::iterator FindMessageByID(T& messages, int id) {
   for (typename T::iterator it = messages.begin();
        it != messages.end(); ++it) {
     if (it->id() == id)
       return it;
   }
   return messages.end();
@@ skipping 111 matching lines @@
                      PermissionMessage::ID>::const_iterator it =
            kSuppressList.begin();
        it != kSuppressList.end();
        ++it) {
     SuppressMessage(messages, it->first, it->second);
   }
 
   return messages;
 }
 
+PermissionMessageStrings
+ChromePermissionMessageProvider::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;
+}
+
+PermissionMessageIDs
+ChromePermissionMessageProvider::GetLegacyPermissionMessageIDs(
+    const PermissionSet* permissions,
+    Manifest::Type extension_type) const {
+  PermissionMessageIDs ids;
+  for (const PermissionMessage& msg :
+       GetPermissionMessages(permissions, extension_type)) {
+    ids.push_back(msg.id());
+  }
+  return ids;
+}
+
 CoalescedPermissionMessages
 ChromePermissionMessageProvider::GetCoalescedPermissionMessages(
     const PermissionIDSet& permissions) const {
   std::vector<ChromePermissionMessageRule> rules =
       ChromePermissionMessageRule::GetAllRules();
 
   // Apply each of the rules, in order, to generate the messages for the given
   // permissions. Once a permission is used in a rule, remove it from the set
   // of available permissions so it cannot be applied to subsequent rules.
   PermissionIDSet remaining_permissions = permissions;
@@ skipping 10 matching lines @@
           rule.formatter()->GetPermissionMessage(used_permissions));
 
       remaining_permissions =
           PermissionIDSet::Difference(remaining_permissions, used_permissions);
     }
   }
 
   return messages;
 }
 
-std::vector<base::string16> ChromePermissionMessageProvider::GetWarningMessages(
+std::vector<base::string16>
+ChromePermissionMessageProvider::GetLegacyWarningMessages(
     const PermissionSet* permissions,
     Manifest::Type extension_type) const {
   std::vector<base::string16> message_strings;
   std::vector<base::string16> message_details_strings;
   CoalesceWarningMessages(permissions,
                           extension_type,
                           &message_strings,
                           &message_details_strings);
   return message_strings;
 }
 
 std::vector<base::string16>
-ChromePermissionMessageProvider::GetWarningMessagesDetails(
+ChromePermissionMessageProvider::GetLegacyWarningMessagesDetails(
     const PermissionSet* permissions,
     Manifest::Type extension_type) const {
   std::vector<base::string16> message_strings;
   std::vector<base::string16> message_details_strings;
   CoalesceWarningMessages(permissions,
                           extension_type,
                           &message_strings,
                           &message_details_strings);
   return message_details_strings;
 }
@@ skipping 311 matching lines @@
   std::set<std::string> old_hosts_set(
       permission_message_util::GetDistinctHosts(old_list, false, false));
   std::set<std::string> new_hosts_only =
       base::STLSetDifference<std::set<std::string> >(new_hosts_set,
                                                      old_hosts_set);
 
   return !new_hosts_only.empty();
 }
 
 }  // namespace extensions