Removing the * from hosts and adding the words 'all' and 'site'.

extensions/common/permissions/permission_message_util.cc

 // Copyright 2014 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_util.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "extensions/common/permissions/permission_message.h"
 #include "extensions/common/permissions/permission_set.h"
@@ skipping 20 matching lines @@
   if (a == "org")
     return b != "com" && b != "net";
   return false;
 }
 
 }  // namespace
 
 namespace permission_message_util {
 
 PermissionMessage CreateFromHostList(const std::set<std::string>& hosts) {
-  std::vector<std::string> host_list(hosts.begin(), hosts.end());
-  DCHECK(host_list.size());
+  std::vector<base::string16> host_list;
   PermissionMessage::ID message_id;
   base::string16 message;
   base::string16 details;
+  int host_msg_id = IDS_EXTENSION_PROMPT_WARNING_HOST_AND_SUBDOMAIN;
+  if (hosts.size() > 3)

[jww, 2014/07/22 16:20:31]

I really, really don't like hard coded numbers like this. Especially when
combined with the switch statement below, it means that if we ever decide that
"3" is no longer the magical number of what looks pretty, we'll have to refactor
all the code, not just a set of constants.

Obviously, it was already sort of like this, but this seems like as good an
opportunity to change it as any :-) May I suggest that, instead, you create a
value of something like uint_t kMaxBeforeManyMessage = 3, then instead of the
switch statement, you create a static array of pairs
std::pair<PermissionMessage, string16> that hold the default messages, and you
can then check:

if (host_list.size() < kMaxBeforeManyMessage) {
   message_id = pairs[host_list.size()][0];
   message = pairs[host_list.size()][1];
} else {
   message_id = PermissionMessage::kHostsMore;
   message = IDS_EXTENSION_PROMPT_WARING_HOSTS_MORE_HOSTS;
}

[mhm, 2014/07/22 18:56:31]

Done.

+    host_msg_id = IDS_EXTENSION_PROMPT_WARNING_HOST_AND_SUBDOMAIN_LIST;
+
+  for (std::set<std::string>::const_iterator it = hosts.begin();
+       it != hosts.end();
+       ++it) {
+    std::string host = *it;
+    host_list.push_back(
+        host[0] == '*' && host[1] == '.'
+            ? l10n_util::GetStringFUTF16(host_msg_id,
+                                         base::UTF8ToUTF16(host.erase(0, 2)))
+            : base::UTF8ToUTF16(host));
+  }
+  DCHECK(host_list.size());
 
   switch (host_list.size()) {
     case 1:
       message_id = PermissionMessage::kHosts1;
       message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_1_HOST,
-                                           base::UTF8ToUTF16(host_list[0]));
+                                           host_list[0]);
       break;
     case 2:
       message_id = PermissionMessage::kHosts2;
-      message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_2_HOSTS,
-                                           base::UTF8ToUTF16(host_list[0]),
-                                           base::UTF8ToUTF16(host_list[1]));
+      message = l10n_util::GetStringFUTF16(
+          IDS_EXTENSION_PROMPT_WARNING_2_HOSTS, host_list[0], host_list[1]);
       break;
     case 3:
       message_id = PermissionMessage::kHosts3;
       message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_3_HOSTS,
-                                           base::UTF8ToUTF16(host_list[0]),
-                                           base::UTF8ToUTF16(host_list[1]),
-                                           base::UTF8ToUTF16(host_list[2]));
+                                           host_list[0],
+                                           host_list[1],
+                                           host_list[2]);
       break;
     default:
       message_id = PermissionMessage::kHosts4OrMore;
-
-      const int kRetainedFilesMessageIDs[6] = {
-          IDS_EXTENSION_PROMPT_WARNING_HOSTS_DEFAULT,
-          IDS_EXTENSION_PROMPT_WARNING_HOST_SINGULAR,
-          IDS_EXTENSION_PROMPT_WARNING_HOSTS_ZERO,
-          IDS_EXTENSION_PROMPT_WARNING_HOSTS_TWO,
-          IDS_EXTENSION_PROMPT_WARNING_HOSTS_FEW,
-          IDS_EXTENSION_PROMPT_WARNING_HOSTS_MANY, };
-      std::vector<int> message_ids;
-      for (size_t i = 0; i < arraysize(kRetainedFilesMessageIDs); i++) {
-        message_ids.push_back(kRetainedFilesMessageIDs[i]);
-      }
-      message = l10n_util::GetPluralStringFUTF16(message_ids, host_list.size());
-
+      message = l10n_util::GetStringUTF16(
+          IDS_EXTENSION_PROMPT_WARNING_HOSTS_4_OR_MORE_HOSTS);
       for (size_t i = 0; i < host_list.size(); ++i) {
         if (i > 0)
           details += base::ASCIIToUTF16("\n");
         details += l10n_util::GetStringFUTF16(
-            IDS_EXTENSION_PROMPT_WARNING_HOST_LIST_ENTRY,
-            base::UTF8ToUTF16(host_list[i]));
+            IDS_EXTENSION_PROMPT_WARNING_HOST_LIST_ENTRY, host_list[i]);
       }
   }
 
   return PermissionMessage(message_id, message, details);
 }
 
 std::set<std::string> GetDistinctHosts(const URLPatternSet& host_patterns,
                                        bool include_rcd,
                                        bool exclude_file_scheme) {
   // Use a vector to preserve order (also faster than a map on small sets).
@@ skipping 43 matching lines @@
   // Build up the final vector by concatenating hosts and RCDs.
   std::set<std::string> distinct_hosts;
   for (HostVector::iterator it = hosts_best_rcd.begin();
        it != hosts_best_rcd.end();
        ++it)
     distinct_hosts.insert(it->first + it->second);
   return distinct_hosts;
 }
 
 }  // namespace permission_message_util