Show read-only messages for non-interact non-desktop Automation extensions

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/macros.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"
 #include "extensions/common/url_pattern_set.h"
 #include "grit/extensions_strings.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/url_constants.h"
 
@@ skipping 13 matching lines @@
     return b != "com";
   if (a == "org")
     return b != "com" && b != "net";
   return false;
 }
 
 }  // namespace
 
 namespace permission_message_util {
 
-PermissionMessage CreateFromHostList(const std::set<std::string>& hosts) {
+PermissionMessage CreateFromHostList(const std::set<std::string>& hosts,
+                                     PermissionMessageProperties properties) {
   typedef std::pair<PermissionMessage::ID, int> MsgPair;
-  const MsgPair kMessagesList[] = {
+  static const MsgPair kReadWriteMessagesList[] = {
       std::make_pair(PermissionMessage::kHosts1,
                      IDS_EXTENSION_PROMPT_WARNING_1_HOST),
       std::make_pair(PermissionMessage::kHosts2,
                      IDS_EXTENSION_PROMPT_WARNING_2_HOSTS),
       std::make_pair(PermissionMessage::kHosts3,
                      IDS_EXTENSION_PROMPT_WARNING_3_HOSTS),
       std::make_pair(PermissionMessage::kHosts4OrMore,
                      IDS_EXTENSION_PROMPT_WARNING_HOSTS_LIST)};
+  static const MsgPair kReadOnlyMessagesList[] = {
+      std::make_pair(PermissionMessage::kHosts1ReadOnly,
+                     IDS_EXTENSION_PROMPT_WARNING_1_HOST_READ_ONLY),
+      std::make_pair(PermissionMessage::kHosts2ReadOnly,
+                     IDS_EXTENSION_PROMPT_WARNING_2_HOSTS_READ_ONLY),
+      std::make_pair(PermissionMessage::kHosts3ReadOnly,
+                     IDS_EXTENSION_PROMPT_WARNING_3_HOSTS_READ_ONLY),
+      std::make_pair(PermissionMessage::kHosts4OrMoreReadOnly,
+                     IDS_EXTENSION_PROMPT_WARNING_HOSTS_LIST_READ_ONLY)};
+  COMPILE_ASSERT(
+      arraysize(kReadWriteMessagesList) == arraysize(kReadOnlyMessagesList),
+      "Different numbers of entries in kReadWriteMessagesList vs "
+      "kReadWriteMessagesList");
+  static const int kNumMessages = arraysize(kReadWriteMessagesList);
+  const MsgPair(&messages_list)[kNumMessages] =

[aboxhall, 2014/07/25 19:06:31]

Before you ask, this is how clang-format formatted it.

+      properties & kReadOnly ? kReadOnlyMessagesList : kReadWriteMessagesList;

[not at google - send to devlin, 2014/07/25 20:40:03]

shouldn't this be "== kReadOnly"?

[aboxhall, 2014/07/25 20:54:22]

Ugh yeah, I think I was imagining it was a bitmask.

 
-  int host_msg_id = hosts.size() < arraysize(kMessagesList)
+  int host_msg_id = hosts.size() < kNumMessages
                         ? IDS_EXTENSION_PROMPT_WARNING_HOST_AND_SUBDOMAIN
                         : IDS_EXTENSION_PROMPT_WARNING_HOST_AND_SUBDOMAIN_LIST;
   std::vector<base::string16> host_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());
 
-  if (host_list.size() < arraysize(kMessagesList)) {
+  if (host_list.size() < kNumMessages) {
     return PermissionMessage(
-        kMessagesList[host_list.size() - 1].first,
+        messages_list[host_list.size() - 1].first,
         l10n_util::GetStringFUTF16(
-            kMessagesList[host_list.size() - 1].second, host_list, NULL));
+            messages_list[host_list.size() - 1].second, host_list, NULL));
   }
 
   base::string16 details;
   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(
-      kMessagesList[arraysize(kMessagesList) - 1].first,
+      messages_list[arraysize(messages_list) - 1].first,
       l10n_util::GetStringUTF16(
-          kMessagesList[arraysize(kMessagesList) - 1].second),
+          messages_list[arraysize(messages_list) - 1].second),
       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
   // current best RCD.
   typedef std::vector<std::pair<std::string, std::string> > HostVector;
@@ skipping 40 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