Move sockets manifest types to //extensions.

extensions/common/api/sockets/sockets_manifest_permission.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_manifest_permission.h"
+#include "extensions/common/api/sockets/sockets_manifest_permission.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/common/extensions/api/manifest_types.h"
-#include "chrome/common/extensions/api/sockets/sockets_manifest_data.h"
+#include "extensions/common/api/extensions_manifest_types.h"
+#include "extensions/common/api/sockets/sockets_manifest_data.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_constants.h"
 #include "grit/generated_resources.h"
 #include "ipc/ipc_message.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace extensions {
 
 namespace sockets_errors {
 const char kErrorInvalidHostPattern[] = "Invalid host:port pattern '*'";
 }
 
 namespace errors = sockets_errors;
-using api::manifest_types::Sockets;
-using api::manifest_types::SocketHostPatterns;
+using core_api::extensions_manifest_types::Sockets;
+using core_api::extensions_manifest_types::SocketHostPatterns;
 using content::SocketPermissionRequest;
 
-namespace  {
+namespace {
 
 static bool ParseHostPattern(
     SocketsManifestPermission* permission,
     content::SocketPermissionRequest::OperationType operation_type,
     const std::string& host_pattern,
     base::string16* error) {
   SocketPermissionEntry entry;
   if (!SocketPermissionEntry::ParseHostPattern(
-        operation_type, host_pattern, &entry)) {
+          operation_type, host_pattern, &entry)) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kErrorInvalidHostPattern, host_pattern);
     return false;
   }
   permission->AddPermission(entry);
   return true;
 }
 
 static bool ParseHostPatterns(
     SocketsManifestPermission* permission,
     content::SocketPermissionRequest::OperationType operation_type,
     const scoped_ptr<SocketHostPatterns>& host_patterns,
     base::string16* error) {
   if (!host_patterns)
     return true;
 
   if (host_patterns->as_string) {
-    return ParseHostPattern(permission, operation_type,
-                            *host_patterns->as_string, error);
+    return ParseHostPattern(
+        permission, operation_type, *host_patterns->as_string, error);
   }
 
   CHECK(host_patterns->as_strings);
   for (std::vector<std::string>::const_iterator it =
-      host_patterns->as_strings->begin();
-      it != host_patterns->as_strings->end(); ++it) {
+           host_patterns->as_strings->begin();
+       it != host_patterns->as_strings->end();
+       ++it) {
     if (!ParseHostPattern(permission, operation_type, *it, error)) {
       return false;
     }
   }
   return true;
 }
 
 static void SetHostPatterns(
     scoped_ptr<SocketHostPatterns>& host_patterns,
     const SocketsManifestPermission* permission,
     content::SocketPermissionRequest::OperationType operation_type) {
   host_patterns.reset(new SocketHostPatterns());
   host_patterns->as_strings.reset(new std::vector<std::string>());
   for (SocketsManifestPermission::SocketPermissionEntrySet::const_iterator it =
-      permission->entries().begin(); it != permission->entries().end() ; ++it) {
+           permission->entries().begin();
+       it != permission->entries().end();
+       ++it) {
     if (it->pattern().type == operation_type) {
       host_patterns->as_strings->push_back(it->GetHostPatternAsString());
     }
   }
 }
 
 }  // namespace
 
 SocketsManifestPermission::SocketsManifestPermission() {}
 
@@ skipping 44 matching lines @@
       return scoped_ptr<SocketsManifestPermission>();
     }
   }
   return result.Pass();
 }
 
 bool SocketsManifestPermission::CheckRequest(
     const Extension* extension,
     const SocketPermissionRequest& request) const {
   for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
-       it != permissions_.end(); ++it) {
+       it != permissions_.end();
+       ++it) {
     if (it->Check(request))
       return true;
   }
   return false;
 }
 
 std::string SocketsManifestPermission::name() const {
   return manifest_keys::kSockets;
 }
 
-std::string SocketsManifestPermission::id() const {
-  return name();
-}
+std::string SocketsManifestPermission::id() const { return name(); }
 
 bool SocketsManifestPermission::HasMessages() const {
   bool is_empty = permissions_.empty();
   return !is_empty;
 }
 
 PermissionMessages SocketsManifestPermission::GetMessages() const {
   // TODO(rpaquay): This function and callees is (almost) a copy/paste
   // from extensions::SocketPermissiona.
   PermissionMessages result;
@@ skipping 16 matching lines @@
     return false;
 
   permissions_ = manifest_permission->permissions_;
   return true;
 }
 
 scoped_ptr<base::Value> SocketsManifestPermission::ToValue() const {
   Sockets sockets;
 
   sockets.udp.reset(new Sockets::Udp());
-  SetHostPatterns(sockets.udp->bind, this,
-                  SocketPermissionRequest::UDP_BIND);
-  SetHostPatterns(sockets.udp->send, this,
-                  SocketPermissionRequest::UDP_SEND_TO);
-  SetHostPatterns(sockets.udp->multicast_membership, this,
+  SetHostPatterns(sockets.udp->bind, this, SocketPermissionRequest::UDP_BIND);
+  SetHostPatterns(
+      sockets.udp->send, this, SocketPermissionRequest::UDP_SEND_TO);
+  SetHostPatterns(sockets.udp->multicast_membership,
+                  this,
                   SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP);
   if (sockets.udp->bind->as_strings->size() == 0 &&
       sockets.udp->send->as_strings->size() == 0 &&
       sockets.udp->multicast_membership->as_strings->size() == 0) {
     sockets.udp.reset(NULL);
   }
 
   sockets.tcp.reset(new Sockets::Tcp());
-  SetHostPatterns(sockets.tcp->connect, this,
-                  SocketPermissionRequest::TCP_CONNECT);
+  SetHostPatterns(
+      sockets.tcp->connect, this, SocketPermissionRequest::TCP_CONNECT);
   if (sockets.tcp->connect->as_strings->size() == 0) {
     sockets.tcp.reset(NULL);
   }
 
   sockets.tcp_server.reset(new Sockets::TcpServer());
-  SetHostPatterns(sockets.tcp_server->listen, this,
-                  SocketPermissionRequest::TCP_LISTEN);
+  SetHostPatterns(
+      sockets.tcp_server->listen, this, SocketPermissionRequest::TCP_LISTEN);
   if (sockets.tcp_server->listen->as_strings->size() == 0) {
     sockets.tcp_server.reset(NULL);
   }
 
   return scoped_ptr<base::Value>(sockets.ToValue().release()).Pass();
 }
 
 ManifestPermission* SocketsManifestPermission::Clone() const {
   scoped_ptr<SocketsManifestPermission> result(new SocketsManifestPermission());
   result->permissions_ = permissions_;
@@ skipping 62 matching lines @@
 }
 
 void SocketsManifestPermission::AddPermission(
     const SocketPermissionEntry& entry) {
   permissions_.insert(entry);
 }
 
 bool SocketsManifestPermission::AddAnyHostMessage(
     PermissionMessages& messages) const {
   for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
-      it != permissions_.end(); ++it) {
+       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)));
+      messages.push_back(
+          PermissionMessage(PermissionMessage::kSocketAnyHost,
+                            l10n_util::GetStringUTF16(
+                                IDS_EXTENSION_PROMPT_WARNING_SOCKET_ANY_HOST)));
       return true;
     }
   }
   return false;
 }
 
 void SocketsManifestPermission::AddSubdomainHostMessage(
     PermissionMessages& messages) const {
   std::set<base::string16> domains;
   for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
-      it != permissions_.end(); ++it) {
+       it != permissions_.end();
+       ++it) {
     if (it->GetHostType() == SocketPermissionEntry::HOSTS_IN_DOMAINS)
       domains.insert(base::UTF8ToUTF16(it->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;
+    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<base::string16>(
-                    domains.begin(), domains.end()), ' '))));
+                std::vector<base::string16>(domains.begin(), domains.end()),
+                ' '))));
   }
 }
 
 void SocketsManifestPermission::AddSpecificHostMessage(
     PermissionMessages& messages) const {
   std::set<base::string16> hostnames;
   for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
-    it != permissions_.end(); ++it) {
+       it != permissions_.end();
+       ++it) {
     if (it->GetHostType() == SocketPermissionEntry::SPECIFIC_HOSTS)
       hostnames.insert(base::UTF8ToUTF16(it->pattern().host));
   }
   if (!hostnames.empty()) {
-    int id = (hostnames.size() == 1) ?
-             IDS_EXTENSION_PROMPT_WARNING_SOCKET_SPECIFIC_HOST :
-             IDS_EXTENSION_PROMPT_WARNING_SOCKET_SPECIFIC_HOSTS;
+    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<base::string16>(
-                    hostnames.begin(), hostnames.end()), ' '))));
+                std::vector<base::string16>(hostnames.begin(), hostnames.end()),
+                ' '))));
   }
 }
 
 void SocketsManifestPermission::AddNetworkListMessage(
     PermissionMessages& messages) const {
   for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
-      it != permissions_.end(); ++it) {
+       it != permissions_.end();
+       ++it) {
     if (it->pattern().type == SocketPermissionRequest::NETWORK_STATE) {
-      messages.push_back(PermissionMessage(
-          PermissionMessage::kNetworkState,
-          l10n_util::GetStringUTF16(
-              IDS_EXTENSION_PROMPT_WARNING_NETWORK_STATE)));
+      messages.push_back(
+          PermissionMessage(PermissionMessage::kNetworkState,
+                            l10n_util::GetStringUTF16(
+                                IDS_EXTENSION_PROMPT_WARNING_NETWORK_STATE)));
     }
   }
 }
 
 }  // namespace extensions