Enable permission warnings from ManifestHandlers.

chrome/common/extensions/api/sockets/sockets_handler.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/api/sockets/sockets_handler.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/extensions/api/manifest_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/permissions/permissions_data.h"
 #include "chrome/common/extensions/permissions/socket_permission_data.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/api_permission_set.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace extensions {
 
 namespace sockets_errors {
 const char kErrorInvalidHostPattern[] = "Invalid host:port pattern '*'";
 }
 
 namespace keys = extensions::manifest_keys;
 namespace errors = sockets_errors;
 using api::manifest_types::Sockets;
@@ skipping 11 matching lines @@
                                      &install_warnings,
                                      error);
   if (!data)
     return false;
 
   extension->AddInstallWarnings(install_warnings);
   extension->SetManifestData(keys::kSockets, data.release());
   return true;
 }
 
+void SocketsHandler::AddPermissionWarningMessages(
+    const Extension* extension,
+    std::vector<string16>& messages) const {
+  SocketsManifestData* manifest_data = SocketsManifestData::Get(extension);
+  if (!manifest_data)
+    return;
+  PermissionMessages permission_messages =
+      manifest_data->GetPermissionMessages();
+  for (PermissionMessages::const_iterator i = permission_messages.begin();
+       i != permission_messages.end(); ++i) {
+    messages.push_back(i->message());
+  }
+}
+
+void SocketsHandler::AddPermissionWarningMessagesDetails(
+      const Extension* extension,
+      std::vector<string16>& messages) const {
+  SocketsManifestData* manifest_data = SocketsManifestData::Get(extension);
+  if (!manifest_data)
+    return;
+  PermissionMessages permission_messages =
+      manifest_data->GetPermissionMessages();
+  for (PermissionMessages::const_iterator i = permission_messages.begin();
+       i != permission_messages.end(); ++i) {
+    messages.push_back(i->details());
+  }
+}
+
 const std::vector<std::string> SocketsHandler::Keys() const {
   return SingleKey(manifest_keys::kSockets);
 }
 
 SocketsManifestData::SocketsManifestData() {}
 SocketsManifestData::~SocketsManifestData() {}
 
 // static
 SocketsManifestData* SocketsManifestData::Get(const Extension* extension) {
   return static_cast<SocketsManifestData*>(
@@ skipping 87 matching lines @@
     const Extension* extension,
     const content::SocketPermissionRequest& request) {
   for (PermissionSet::const_iterator it = permissions_.begin();
        it != permissions_.end(); ++it) {
     if (it->Check(request))
       return true;
   }
   return false;
 }
 
+PermissionMessages SocketsManifestData::GetPermissionMessages() const {
+  // TODO(rpaquay): This function and callees is (almost) a copy/paste

[Yoyo Zhou, 2013/11/06 04:02:36]

Have you thought about how extensions that currently have socket permissions are
going to be handled when they update or Chrome updates? Will this be
backward-compatible at all? 

[rpaquay, 2013/11/06 16:16:16]

Good question. I guess unless we do extra work, there will be additional warning
messages on update.

+  // from |extensions::SocketPermission|.
+  PermissionMessages result;
+  if (!AddAnyHostMessage(result)) {
+    AddSpecificHostMessage(result);
+    AddSubdomainHostMessage(result);
+  }
+  AddNetworkListMessage(result);
+  return result;
+}
+
+bool SocketsManifestData::AddAnyHostMessage(
+    PermissionMessages& messages) const {
+  for (PermissionSet::const_iterator it = permissions_.begin();
+      it != permissions_.end(); ++it) {
+    if (it->IsAddressBoundType() &&
+        it->GetHostType() == SocketPermissionEntry::ANY_HOST) {
+      messages.push_back(PermissionMessage(
+          PermissionMessage::kSocketAnyHost,
+          l10n_util::GetStringUTF16(
+              IDS_EXTENSION_PROMPT_WARNING_SOCKET_ANY_HOST)));
+      return true;
+    }
+  }
+  return false;
+}
+
+void SocketsManifestData::AddSubdomainHostMessage(
+    PermissionMessages& messages) const {
+  std::set<string16> domains;
+  std::set<SocketPermissionData>::const_iterator i;
+  for (PermissionSet::const_iterator it = permissions_.begin();
+      it != permissions_.end(); ++it) {
+    if (it->GetHostType() == SocketPermissionEntry::HOSTS_IN_DOMAINS)
+      domains.insert(UTF8ToUTF16(i->entry().pattern().host));
+  }
+  if (!domains.empty()) {
+    int id = (domains.size() == 1) ?
+             IDS_EXTENSION_PROMPT_WARNING_SOCKET_HOSTS_IN_DOMAIN :
+             IDS_EXTENSION_PROMPT_WARNING_SOCKET_HOSTS_IN_DOMAINS;
+    messages.push_back(PermissionMessage(
+        PermissionMessage::kSocketDomainHosts,
+        l10n_util::GetStringFUTF16(
+            id,
+            JoinString(
+                std::vector<string16>(
+                    domains.begin(), domains.end()), ' '))));
+  }
+}
+
+void SocketsManifestData::AddSpecificHostMessage(
+    PermissionMessages& messages) const {
+  std::set<string16> hostnames;
+  std::set<SocketPermissionData>::const_iterator i;
+  for (PermissionSet::const_iterator it = permissions_.begin();
+    it != permissions_.end(); ++it) {
+    if (it->GetHostType() == SocketPermissionEntry::SPECIFIC_HOSTS)
+      hostnames.insert(UTF8ToUTF16(i->entry().pattern().host));
+  }
+  if (!hostnames.empty()) {
+    int id = (hostnames.size() == 1) ?
+             IDS_EXTENSION_PROMPT_WARNING_SOCKET_SPECIFIC_HOST :
+             IDS_EXTENSION_PROMPT_WARNING_SOCKET_SPECIFIC_HOSTS;
+    messages.push_back(PermissionMessage(
+        PermissionMessage::kSocketSpecificHosts,
+        l10n_util::GetStringFUTF16(
+            id,
+            JoinString(
+                std::vector<string16>(
+                    hostnames.begin(), hostnames.end()), ' '))));
+  }
+}
+
+void SocketsManifestData::AddNetworkListMessage(
+    PermissionMessages& messages) const {
+  std::set<SocketPermissionData>::const_iterator i;
+  for (PermissionSet::const_iterator it = permissions_.begin();
+      it != permissions_.end(); ++it) {
+    if (it->pattern().type == content::SocketPermissionRequest::NETWORK_STATE) {
+      messages.push_back(PermissionMessage(
+          PermissionMessage::kNetworkState,
+          l10n_util::GetStringUTF16(
+              IDS_EXTENSION_PROMPT_WARNING_NETWORK_STATE)));
+    }
+  }
+}
+
 }  // namespace extensions