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;
+  uint32_t kMaxBeforeListOfHosts = 3;

[jww, 2014/07/22 21:31:56]

This should be const, I think.

[mhm, 2014/07/22 23:37:28]

Done.

+  std::vector<std::pair<PermissionMessage::ID, base::string16> > kMessagesList;

[jww, 2014/07/22 21:31:56]

I don't see why this needs to be a vector since it's basically static content
that you're pushing onto it. In fact, by making it a vector, you're basically
reintroducing the "code-rather-than-data" problem I was trying to avoid in the
previous comment.

Can you make this a static array of pairs? Something like:
const std::pair<int, int>kList[kMaxBeforeListOfHosts] = {                       
                        
  std::pair<int, int>(1, 2),                                                    
   
  std::pair<int, int>(2, 3),                                                    
   
  std::pair<int, int>(3, 4)                                                     
   
};

Obviously, the pairs should not be of ints but should be of the proper types
you're working with :-)

[mhm, 2014/07/22 21:53:34]

So the main issue here is that to be able to create the pair, the second element
requires we know the host_list which is computed inside this function. We use a
different string for each of the three options as each one has a different
number of placers.

I don't how this can be converted to pure data.

[jww, 2014/07/22 22:14:35]

Ah, I see. Well, you can still do something more extensible, I think, by making
the data pairs of PermissionMessages and base::string16s, and calling
l10n_util::GetStringFUTF16 when you extract .second from the pairs. So you'll
initialize with something like: 

const std::pair<PermissionMessage, base::string16>kList[kMaxBeforeListOfHosts] =
{                       
                        
  std::pair<PermissionMessage, base::string16>(
      PermissionMessage::kHosts1,
      IDS_EXTENSION_PROMPT_WARNING_1_HOST),
...   
};

then later

message_id = kMessagesList[host_list.size() - 1].first;
message = l10n_util::GetStringFUTF16(kMessagesList[host_list.size() - 1].second,
host_list, NULL);

You'll probably want to typdef the pair type since it's kinda ugly though :-)

[mhm, 2014/07/22 23:37:28]

Done.

+  int host_msg_id = hosts.size() <= kMaxBeforeListOfHosts
+                        ? IDS_EXTENSION_PROMPT_WARNING_HOST_AND_SUBDOMAIN
+                        : IDS_EXTENSION_PROMPT_WARNING_HOST_AND_SUBDOMAIN_LIST;
 
-  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]));
-      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]));
-      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]));
-      break;
-    default:
-      message_id = PermissionMessage::kHosts4OrMore;
+  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());
 
-      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());
+  kMessagesList.push_back(std::make_pair(
+      PermissionMessage::kHosts1,
+      l10n_util::GetStringFUTF16(
+          IDS_EXTENSION_PROMPT_WARNING_1_HOST, host_list, NULL)));
+  kMessagesList.push_back(std::make_pair(
+      PermissionMessage::kHosts2,
+      l10n_util::GetStringFUTF16(
+          IDS_EXTENSION_PROMPT_WARNING_2_HOSTS, host_list, NULL)));
+  kMessagesList.push_back(std::make_pair(
+      PermissionMessage::kHosts3,
+      l10n_util::GetStringFUTF16(
+          IDS_EXTENSION_PROMPT_WARNING_3_HOSTS, host_list, NULL)));
 
-      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]));
-      }
+  if (host_list.size() <= kMaxBeforeListOfHosts) {
+    message_id = kMessagesList[host_list.size() - 1].first;
+    message = kMessagesList[host_list.size() - 1].second;
+  } else {
+    message_id = PermissionMessage::kHosts4OrMore;
+    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, 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).
   // Each item is a host split into two parts: host without RCDs and
@@ skipping 42 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