Reimplements net::AddressList without struct addrinfo.

chrome/browser/net/network_stats.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 "chrome/browser/net/network_stats.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/tuple.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/udp/udp_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 using content::BrowserThread;
 
 namespace chrome_browser_net {
 
 // This specifies the number of bytes to be sent to the TCP/UDP servers as part
@@ skipping 582 matching lines @@
       new net::UDPClientSocket(net::DatagramSocket::DEFAULT_BIND,
                                net::RandIntCallback(),
                                NULL,
                                net::NetLog::Source());
   if (!udp_socket) {
     Finish(SOCKET_CREATE_FAILED, net::ERR_INVALID_ARGUMENT);
     return false;
   }
   set_socket(udp_socket);
 
-  const addrinfo* address = GetAddressList().head();
-  if (!address) {
+  if (addresses().empty()) {
     Finish(RESOLVE_FAILED, net::ERR_INVALID_ARGUMENT);
     return false;
   }
 
-  net::IPEndPoint endpoint;
-  endpoint.FromSockAddr(address->ai_addr, address->ai_addrlen);
+  const net::IPEndPoint& endpoint = addresses().front();
   int rv = udp_socket->Connect(endpoint);
   if (rv < 0) {
     Finish(CONNECT_FAILED, rv);
     return false;
   }
   return NetworkStats::ConnectComplete(rv);
 }
 
 bool UDPStatsClient::ReadComplete(int result) {
   DCHECK_NE(net::ERR_IO_PENDING, result);
@@ skipping 25 matching lines @@
 TCPStatsClient::~TCPStatsClient() {
 }
 
 bool TCPStatsClient::DoConnect(int result) {
   if (result != net::OK) {
     Finish(RESOLVE_FAILED, result);
     return false;
   }
 
   net::TCPClientSocket* tcp_socket =
-      new net::TCPClientSocket(GetAddressList(), NULL, net::NetLog::Source());
+      new net::TCPClientSocket(addresses(), NULL, net::NetLog::Source());
   if (!tcp_socket) {
     Finish(SOCKET_CREATE_FAILED, net::ERR_INVALID_ARGUMENT);
     return false;
   }
   set_socket(tcp_socket);
 
   int rv = tcp_socket->Connect(base::Bind(&TCPStatsClient::OnConnectComplete,
                                           base::Unretained(this)));
   if (rv == net::ERR_IO_PENDING)
     return true;
@@ skipping 156 matching lines @@
         UDPStatsClient* packet_loss_udp_stats = new UDPStatsClient();
         packet_loss_udp_stats->Start(
             host_resolver, server_address, histogram_port,
             kLargeTestBytesToSend, kMaximumPackets, net::CompletionCallback());
       }
       break;
   }
 }
 
 }  // namespace chrome_browser_net