Reimplements net::AddressList without struct addrinfo.

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>
 
 #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 "net/base/sys_addrinfo.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
 
@@ skipping 435 matching lines @@
   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,
     PP_NetAddress_Private* net_addr) {
-  sockaddr_storage storage = { 0 };
-  size_t length = sizeof(storage);
+  net::SockaddrStorage storage;
 
-  return ip.ToSockAddr(reinterpret_cast<sockaddr*>(&storage), &length) &&
-      SockaddrToNetAddress(reinterpret_cast<const sockaddr*>(&storage), length,
-                           net_addr);
+  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) {
-  const addrinfo* head = address_list.head();
-  return head && SockaddrToNetAddress(head->ai_addr, head->ai_addrlen,
-                                      net_addr);
+  return !address_list.empty() && IPEndPointToNetAddress(address_list.front(),
+                                                         net_addr);
 }
 
 // static
 bool NetAddressPrivateImpl::NetAddressToIPEndPoint(
     const PP_NetAddress_Private& net_addr,
     net::IPEndPoint* ip_end_point) {
   if (!ip_end_point || !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::CreateFromIPAddress(ip_end_point.address(),
-                                                        ip_end_point.port());
+  *address_list = net::AddressList(ip_end_point);
   return true;
 }
 
 }  // namespace ppapi