Add base::HostToNetXX() & NetToHostXX(), and use them to replace htonX() & ntohX() in Chrome.

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"
 
 #include <string.h>
 
 #include <string>
 
@@ skipping 52 matching lines @@
       return PP_NETADDRESSFAMILY_IPV6;
     default:
       return PP_NETADDRESSFAMILY_UNSPECIFIED;
   }
 }
 
 uint16_t GetPort(const PP_NetAddress_Private* addr) {
   switch (GetFamilyInternal(addr)) {
     case AF_INET: {
       const sockaddr_in* a = reinterpret_cast<const sockaddr_in*>(addr->data);
-      return ntohs(a->sin_port);
+      return base::NetToHost16(a->sin_port);
     }
     case AF_INET6: {
       const sockaddr_in6* a = reinterpret_cast<const sockaddr_in6*>(addr->data);
-      return ntohs(a->sin6_port);
+      return base::NetToHost16(a->sin6_port);
     }
     default:
       return 0;
   }
 }
 
 PP_Bool GetAddress(const PP_NetAddress_Private* addr,
                    void* address,
                    uint16_t address_size) {
   switch (GetFamilyInternal(addr)) {
@@ skipping 73 matching lines @@
       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 = ntohl(a->sin_addr.s_addr);
-  unsigned port = ntohs(a->sin_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;
 }
 
 // Format an IPv6 address for human consumption, basically according to RFC
 // 5952.
 //  - If the scope is nonzero, it is appended to the address as "%<scope>" (this
 //    is not in RFC 5952, but consistent with |getnameinfo()| on Linux and
 //    Windows).
 //  - If |include_port| is true, the address (possibly including the scope) is
 //    enclosed in square brackets and ":<port>" is appended, i.e., the overall
 //    format is "[<address>]:<port>".
 //  - If the address is an IPv4 address embedded IPv6 (per RFC 4291), then the
 //    mixed format is used, e.g., "::ffff:192.168.1.2". This is optional per RFC
 //    5952, but consistent with |getnameinfo()|.
 std::string ConvertIPv6AddressToString(const sockaddr_in6* a,
                                        bool include_port) {
-  unsigned port = ntohs(a->sin6_port);
+  unsigned port = base::NetToHost16(a->sin6_port);
   unsigned scope = a->sin6_scope_id;
   std::string description(include_port ? "[" : "");
 
   // IPv4 address embedded in IPv6.
   if (a->sin6_addr.s6_addr16[0] == 0 && a->sin6_addr.s6_addr16[1] == 0 &&
       a->sin6_addr.s6_addr16[2] == 0 && a->sin6_addr.s6_addr16[3] == 0 &&
       a->sin6_addr.s6_addr16[4] == 0 &&
       (a->sin6_addr.s6_addr16[5] == 0 || a->sin6_addr.s6_addr16[5] == 0xffff)) {
     base::StringAppendF(
         &description,
         a->sin6_addr.s6_addr16[5] == 0 ? "::%u.%u.%u.%u" : "::ffff:%u.%u.%u.%u",
         static_cast<unsigned>(a->sin6_addr.s6_addr[12]),
         static_cast<unsigned>(a->sin6_addr.s6_addr[13]),
         static_cast<unsigned>(a->sin6_addr.s6_addr[14]),
         static_cast<unsigned>(a->sin6_addr.s6_addr[15]));
 
   // "Real" IPv6 addresses.
   } else {
     // Find the first longest run of 0s (of length > 1), to collapse to "::".
     int longest_start = 0;
     int longest_length = 0;
     int curr_start = 0;
     int curr_length = 0;
     for (int i = 0; i < 8; i++) {
-      if (ntohs(a->sin6_addr.s6_addr16[i]) != 0) {
+      if (base::NetToHost16(a->sin6_addr.s6_addr16[i]) != 0) {
         curr_length = 0;
       } else {
         if (!curr_length)
           curr_start = i;
         curr_length++;
         if (curr_length > longest_length) {
           longest_start = curr_start;
           longest_length = curr_length;
         }
       }
     }
 
     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 {
-        unsigned v = ntohs(a->sin6_addr.s6_addr16[i]);
+        unsigned v = base::NetToHost16(a->sin6_addr.s6_addr16[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 (scope != 0)
     base::StringAppendF(&description, "%%%u", scope);
@@ skipping 45 matching lines @@
 
 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: {
       memmove(dest_addr, src_addr, sizeof(*src_addr));
-      reinterpret_cast<sockaddr_in*>(dest_addr->data)->sin_port = htons(port);
+      reinterpret_cast<sockaddr_in*>(dest_addr->data)->sin_port =
+          base::HostToNet16(port);
       return PP_TRUE;
     }
     case AF_INET6: {
       memmove(dest_addr, src_addr, sizeof(*src_addr));
-      reinterpret_cast<sockaddr_in6*>(dest_addr->data)->sin6_port = htons(port);
+      reinterpret_cast<sockaddr_in6*>(dest_addr->data)->sin6_port =
+          base::HostToNet16(port);
       return PP_TRUE;
     }
     default:
       return PP_FALSE;
   }
 }
 
 void GetAnyAddress(PP_Bool is_ipv6, PP_NetAddress_Private* addr) {
   memset(addr->data, 0, arraysize(addr->data) * sizeof(addr->data[0]));
   if (is_ipv6) {
@@ skipping 132 matching lines @@
   net::IPEndPoint ip_end_point;
   if (!NetAddressToIPEndPoint(net_addr, &ip_end_point))
     return false;
 
   *address_list = net::AddressList::CreateFromIPAddress(ip_end_point.address(),
                                                         ip_end_point.port());
   return true;
 }
 
 }  // namespace ppapi