Remove PPAPI dependency on 'net'.

ppapi/shared_impl/private/net_address_private_impl.cc

 // Copyright (c) 2012 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 "ppapi/shared_impl/private/net_address_private_impl.h"
 
+#if defined(OS_WIN)
+#include <windows.h>
+#include <ws2tcpip.h>
+#elif defined(OS_POSIX)
+#include <sys/socket.h>
+#include <sys/types.h>
+#endif
+
 #include <string.h>
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "build/build_config.h"
-#include "net/base/address_list.h"
-#include "net/base/ip_endpoint.h"
-#include "net/base/net_util.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/thunk/thunk.h"
 
 #if defined(OS_MACOSX)
 // This is a bit evil, but it's standard operating procedure for |s6_addr|....
 #define s6_addr16 __u6_addr.__u6_addr16
 #endif
 
 #if defined(OS_WIN)
 // The type of |sockaddr::sa_family|.
 typedef ADDRESS_FAMILY sa_family_t;
 
 #define s6_addr16 u.Word
 #define ntohs(x) _byteswap_ushort(x)
 #define htons(x) _byteswap_ushort(x)
-#endif // OS_WIN
+#endif  // defined(OS_WIN)
 
 // The net address interface doesn't have a normal C -> C++ thunk since it
 // doesn't actually have any proxy wrapping or associated objects; it's just a
 // call into base. So we implement the entire interface here, using the thunk
 // namespace so it magically gets hooked up in the proper places.
 
 namespace ppapi {
 
 namespace {
 
+static const size_t kIPv4AddressSize = 4;
+static const size_t kIPv6AddressSize = 16;
+
+bool IPEndPointToSockaddr(const std::vector<unsigned char>& address,
+                          int port,
+                          sockaddr* sa) {
+  DCHECK(sa);
+  switch (address.size()) {
+    case kIPv4AddressSize: {
+      struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(sa);
+      memset(addr, 0, sizeof(struct sockaddr_in));
+      addr->sin_family = AF_INET;
+      addr->sin_port = base::HostToNet16(port);
+      memcpy(&addr->sin_addr, &address[0], static_cast<int>(address.size()));
+      break;
+    }
+    case kIPv6AddressSize: {
+      struct sockaddr_in6* addr6 =
+          reinterpret_cast<struct sockaddr_in6*>(sa);
+      memset(addr6, 0, sizeof(struct sockaddr_in6));
+      addr6->sin6_family = AF_INET6;
+      addr6->sin6_port = base::HostToNet16(port);
+      memcpy(&addr6->sin6_addr, &address[0], static_cast<int>(address.size()));
+      break;
+    }
+    default:
+      return false;
+  }
+  return true;
+}
+
+bool SockaddrToIPEndPoint(const sockaddr& sa,
+                          std::vector<unsigned char>* address,
+                          int* port) {
+  DCHECK(address);
+  DCHECK(port);
+  switch (sa.sa_family) {
+    case AF_INET: {
+      const struct sockaddr_in* addr =
+          reinterpret_cast<const struct sockaddr_in*>(&sa);
+      *port = base::NetToHost16(addr->sin_port);
+      const char* bytes = reinterpret_cast<const char*>(&addr->sin_addr);
+      address->assign(&bytes[0], &bytes[kIPv4AddressSize]);
+      break;
+    }
+    case AF_INET6: {
+      const struct sockaddr_in6* addr =
+          reinterpret_cast<const struct sockaddr_in6*>(&sa);
+      *port = base::NetToHost16(addr->sin6_port);
+      const char* bytes = reinterpret_cast<const char*>(&addr->sin6_addr);
+      address->assign(&bytes[0], &bytes[kIPv6AddressSize]);
+      break;
+    }
+    default:
+      return false;
+  }
+  return true;
+}
+
 // This assert fails on OpenBSD for an unknown reason at the moment.
 #if !defined(OS_OPENBSD)
 // Make sure the storage in |PP_NetAddress_Private| is big enough. (Do it here
 // since the data is opaque elsewhere.)
 COMPILE_ASSERT(sizeof(reinterpret_cast<PP_NetAddress_Private*>(0)->data) >=
                sizeof(sockaddr_storage), PP_NetAddress_Private_data_too_small);
 #endif
 
 sa_family_t GetFamilyInternal(const PP_NetAddress_Private* addr) {
   return reinterpret_cast<const sockaddr*>(addr->data)->sa_family;
@@ skipping 113 matching lines @@
           reinterpret_cast<const sockaddr_in6*>(addr1->data);
       const sockaddr_in6* a2 =
           reinterpret_cast<const sockaddr_in6*>(addr2->data);
       return PP_FromBool(a1->sin6_port == a2->sin6_port);
     }
     default:
       return PP_FALSE;
   }
 }
 
-#if defined(OS_WIN) || defined(OS_MACOSX)
 std::string ConvertIPv4AddressToString(const sockaddr_in* a,
                                        bool include_port) {
   unsigned ip = base::NetToHost32(a->sin_addr.s_addr);
   unsigned port = base::NetToHost16(a->sin_port);
   std::string description = base::StringPrintf(
       "%u.%u.%u.%u",
       (ip >> 24) & 0xff, (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
   if (include_port)
     base::StringAppendF(&description, ":%u", port);
   return description;
@@ skipping 67 matching lines @@
 
   // Nonzero scopes, e.g., 123, are indicated by appending, e.g., "%123".
   if (scope != 0)
     base::StringAppendF(&description, "%%%u", scope);
 
   if (include_port)
     base::StringAppendF(&description, "]:%u", port);
 
   return description;
 }
-#endif  // OS_WIN || OS_MACOSX
 
 PP_Var Describe(PP_Module /*module*/,
                 const struct PP_NetAddress_Private* addr,
                 PP_Bool include_port) {
   if (!NetAddressPrivateImpl::ValidateNetAddress(*addr))
     return PP_MakeUndefined();
 
-#if defined(OS_WIN) || defined(OS_MACOSX)
   // On Windows, |NetAddressToString()| doesn't work in the sandbox. On Mac,
   // the output isn't consistent with RFC 5952, at least on Mac OS 10.6:
   // |getnameinfo()| collapses length-one runs of zeros (and also doesn't
   // display the scope).
-  // TODO(viettrungluu): Consider switching to this on Linux.
   switch (GetFamilyInternal(addr)) {
     case AF_INET: {
       const sockaddr_in* a = reinterpret_cast<const sockaddr_in*>(addr->data);
       return StringVar::StringToPPVar(
           ConvertIPv4AddressToString(a, !!include_port));
     }
     case AF_INET6: {
       const sockaddr_in6* a = reinterpret_cast<const sockaddr_in6*>(addr->data);
       return StringVar::StringToPPVar(
           ConvertIPv6AddressToString(a, !!include_port));
     }
     default:
       NOTREACHED();
       break;
   }
   return PP_MakeUndefined();
-#else
-  const sockaddr* a = reinterpret_cast<const sockaddr*>(addr->data);
-  socklen_t l = addr->size;
-  std::string description =
-      include_port ? net::NetAddressToStringWithPort(a, l) :
-                     net::NetAddressToString(a, l);
-  return StringVar::StringToPPVar(description);
-#endif
 }
 
 PP_Bool ReplacePort(const struct PP_NetAddress_Private* src_addr,
                     uint16_t port,
                     struct PP_NetAddress_Private* dest_addr) {
   if (!NetAddressPrivateImpl::ValidateNetAddress(*src_addr))
     return PP_FALSE;
 
   switch (GetFamilyInternal(src_addr)) {
     case AF_INET: {
@@ skipping 146 matching lines @@
     return false;
 
   CHECK_LE(sa_length, sizeof(net_addr->data));
   net_addr->size = sa_length;
   memcpy(net_addr->data, sa, net_addr->size);
   return true;
 }
 
 // static
 bool NetAddressPrivateImpl::IPEndPointToNetAddress(
-    const net::IPEndPoint& ip,
+    const std::vector<unsigned char>& address,
+    int port,
     PP_NetAddress_Private* net_addr) {
-  net::SockaddrStorage storage;
-
-  return ip.ToSockAddr(storage.addr, &storage.addr_len) &&
-      SockaddrToNetAddress(storage.addr, storage.addr_len, net_addr);
-}
-
-// static
-bool NetAddressPrivateImpl::AddressListToNetAddress(
-    const net::AddressList& address_list,
-    PP_NetAddress_Private* net_addr) {
-  return !address_list.empty() && IPEndPointToNetAddress(address_list.front(),
-                                                         net_addr);
+  sockaddr_storage storage;
+  sockaddr* sa = reinterpret_cast<sockaddr*>(&storage);
+  if (!IPEndPointToSockaddr(address, port, sa))
+    return false;
+  return SockaddrToNetAddress(sa, sizeof(storage), net_addr);
 }
 
 // static
 bool NetAddressPrivateImpl::NetAddressToIPEndPoint(
     const PP_NetAddress_Private& net_addr,
-    net::IPEndPoint* ip_end_point) {
-  if (!ip_end_point || !ValidateNetAddress(net_addr))
+    std::vector<unsigned char>* address,
+    int* port) {
+  if (!address || !port || !ValidateNetAddress(net_addr))
     return false;
 
-  if (!ip_end_point->FromSockAddr(
-      reinterpret_cast<const sockaddr*>(net_addr.data), net_addr.size)) {
-    return false;
-  }
-
-  return true;
-}
-
-// static
-bool NetAddressPrivateImpl::NetAddressToAddressList(
-    const PP_NetAddress_Private& net_addr, net::AddressList* address_list) {
-  if (!address_list)
-    return false;
-
-  net::IPEndPoint ip_end_point;
-  if (!NetAddressToIPEndPoint(net_addr, &ip_end_point))
-    return false;
-
-  *address_list = net::AddressList(ip_end_point);
-  return true;
+  return SockaddrToIPEndPoint(
+      reinterpret_cast<const sockaddr&>(*net_addr.data), address, port);
 }
 
 }  // namespace ppapi