Introduce PPB_NetAddress_Dev.

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 <winsock2.h>
 #include <ws2tcpip.h>
@@ skipping 36 matching lines @@
 // 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 {
 
 // Define our own net-host-net conversion, rather than reuse the one in
 // base/sys_byteorder.h, to simplify the NaCl port. NaCl has no byte swap
 // primitives.
-uint16 ConvertNetEndian16(uint16 x) {
+uint16 ConvertFromNetEndian16(uint16 x) {
 #if defined(ARCH_CPU_LITTLE_ENDIAN)
   return (x << 8) | (x >> 8);
 #else
+  return x;
+#endif
+}
+
+uint16 ConvertToNetEndian16(uint16 x) {
+#if defined(ARCH_CPU_LITTLE_ENDIAN)
+  return (x << 8) | (x >> 8);
+#else
   return x;
 #endif
 }
 
 static const size_t kIPv4AddressSize = 4;
 static const size_t kIPv6AddressSize = 16;
 
 // This structure is a platform-independent representation of a network address.
 // It is a private format that we embed in PP_NetAddress_Private and is NOT part
 // of the stable Pepper API.
@@ skipping 183 matching lines @@
       }
     }
 
     bool need_sep = false;  // Whether the next item needs a ':' to separate.
     for (int i = 0; i < 8;) {
       if (longest_length > 1 && i == longest_start) {
         description.append("::");
         need_sep = false;
         i += longest_length;
       } else {
-        uint16_t v = ConvertNetEndian16(address16[i]);
+        uint16_t v = ConvertFromNetEndian16(address16[i]);
         base::StringAppendF(&description, need_sep ? ":%x" : "%x", v);
         need_sep = true;
         i++;
       }
     }
   }
 
   // Nonzero scopes, e.g., 123, are indicated by appending, e.g., "%123".
   if (net_addr->scope_id != 0)
     base::StringAppendF(&description, "%%%u", net_addr->scope_id);
@@ skipping 137 matching lines @@
 
   // Our platform neutral format stores ports in host order, not net order,
   // so convert them here.
   NetAddress* net_addr = InitNetAddress(addr);
   switch (sa->sa_family) {
     case AF_INET: {
       const struct sockaddr_in* addr4 =
           reinterpret_cast<const struct sockaddr_in*>(sa);
       net_addr->is_valid = true;
       net_addr->is_ipv6 = false;
-      net_addr->port = ConvertNetEndian16(addr4->sin_port);
+      net_addr->port = ConvertFromNetEndian16(addr4->sin_port);
       memcpy(net_addr->address, &addr4->sin_addr.s_addr, kIPv4AddressSize);
       break;
     }
     case AF_INET6: {
       const struct sockaddr_in6* addr6 =
           reinterpret_cast<const struct sockaddr_in6*>(sa);
       net_addr->is_valid = true;
       net_addr->is_ipv6 = true;
-      net_addr->port = ConvertNetEndian16(addr6->sin6_port);
+      net_addr->port = ConvertFromNetEndian16(addr6->sin6_port);
       net_addr->flow_info = addr6->sin6_flowinfo;
       net_addr->scope_id = addr6->sin6_scope_id;
       memcpy(net_addr->address, addr6->sin6_addr.s6_addr, kIPv6AddressSize);
       break;
     }
     default:
       // InitNetAddress sets net_addr->is_valid to false.
       return false;
   }
   return true;}
@@ skipping 60 matching lines @@
 
   // 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).
   if (net_addr->is_ipv6)
     return ConvertIPv6AddressToString(net_addr, include_port);
   return ConvertIPv4AddressToString(net_addr, include_port);
 }
 
+// static
+void NetAddressPrivateImpl::CreateNetAddressPrivateFromIPv4Address(
+    const PP_NetAddress_IPv4_Dev& ipv4_addr,
+    PP_NetAddress_Private* addr) {
+  CreateFromIPv4Address(ipv4_addr.addr, ConvertFromNetEndian16(ipv4_addr.port),
+                        addr);
+}
+
+// static
+void NetAddressPrivateImpl::CreateNetAddressPrivateFromIPv6Address(
+    const PP_NetAddress_IPv6_Dev& ipv6_addr,
+    PP_NetAddress_Private* addr) {
+  CreateFromIPv6Address(ipv6_addr.addr, 0,
+                        ConvertFromNetEndian16(ipv6_addr.port), addr);
+}
+
+// static
+PP_NetAddress_Family_Dev NetAddressPrivateImpl::GetFamilyFromNetAddressPrivate(
+    const PP_NetAddress_Private& addr) {
+  const NetAddress* net_addr = ToNetAddress(&addr);
+  if (!IsValid(net_addr))
+    return PP_NETADDRESS_FAMILY_UNSPECIFIED;
+  return net_addr->is_ipv6 ? PP_NETADDRESS_FAMILY_IPV6 :
+                             PP_NETADDRESS_FAMILY_IPV4;
+}
+
+// static
+bool NetAddressPrivateImpl::DescribeNetAddressPrivateAsIPv4Address(
+   const PP_NetAddress_Private& addr,
+   PP_NetAddress_IPv4_Dev* ipv4_addr) {
+  if (!ipv4_addr)
+    return false;
+
+  const NetAddress* net_addr = ToNetAddress(&addr);
+  if (!IsValid(net_addr) || net_addr->is_ipv6)
+    return false;
+
+  ipv4_addr->port = ConvertToNetEndian16(net_addr->port);
+
+  COMPILE_ASSERT(sizeof(ipv4_addr->addr) == kIPv4AddressSize,
+                 mismatched_IPv4_address_size);
+  memcpy(ipv4_addr->addr, net_addr->address, kIPv4AddressSize);
+
+  ipv4_addr->unused_padding = 0;
+  return true;
+}
+
+// static
+bool NetAddressPrivateImpl::DescribeNetAddressPrivateAsIPv6Address(
+    const PP_NetAddress_Private& addr,
+    PP_NetAddress_IPv6_Dev* ipv6_addr) {
+  if (!ipv6_addr)
+    return false;
+
+  const NetAddress* net_addr = ToNetAddress(&addr);
+  if (!IsValid(net_addr) || !net_addr->is_ipv6)
+    return false;
+
+  ipv6_addr->port = ConvertToNetEndian16(net_addr->port);
+
+  COMPILE_ASSERT(sizeof(ipv6_addr->addr) == kIPv6AddressSize,
+                 mismatched_IPv6_address_size);
+  memcpy(ipv6_addr->addr, net_addr->address, kIPv6AddressSize);
+
+  ipv6_addr->unused_padding = 0;
+  return true;
+}
+
 }  // namespace ppapi