Reimplements net::AddressList without struct addrinfo.

net/curvecp/client_packetizer.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 "net/curvecp/client_packetizer.h"
 
 #include "base/bind.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/curvecp/protocol.h"
 #include "net/udp/udp_client_socket.h"
 
 namespace {
 
 const int kMaxHelloAttempts = 8;
 const int kHelloTimeoutMs[kMaxHelloAttempts] = {
   1000,  // 1 second, with 1.5x increase for each retry.
   1500,
   2250,
   3375,
   5063,
   7594,
  11391,
  17086,
 };
 
 }  // namespace
 
 namespace net {
 
 ClientPacketizer::ClientPacketizer()
     : Packetizer(),
       next_state_(NONE),
       listener_(NULL),
-      current_address_(NULL),
+      current_address_index_(-1),
       hello_attempts_(0),
       initiate_sent_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(base::Bind(&ClientPacketizer::OnIOComplete,
                                   base::Unretained(this)))),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   // TODO(mbelshe): Initialize our keys and such properly.
   //     for now we use random values to keep them unique.
   for (int i = 0; i < 32; ++i)
     shortterm_public_key_[i] = rand() % 26 + 'a';
@@ skipping 236 matching lines @@
   DCHECK(!user_callback_.is_null());
 
   CompletionCallback callback = user_callback_;
   user_callback_.Reset();
   callback.Run(result);
 }
 
 int ClientPacketizer::ConnectNextAddress() {
   // TODO(mbelshe): plumb Netlog information
 
-  DCHECK(addresses_.head());
+  DCHECK(!addresses_.empty());
 
   socket_.reset(new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
                                     RandIntCallback(),
                                     NULL,
                                     NetLog::Source()));
 
-  // Rotate to next address in the list.
-  if (current_address_)
-    current_address_ = current_address_->ai_next;
-  if (!current_address_)
-    current_address_ = addresses_.head();
+  // Rotate to next address in the list. Note, this sets it to 0 on first call.
+  current_address_index_ = (current_address_index_ + 1) % addresses_.size();
 
-  IPEndPoint endpoint;
-  if (!endpoint.FromSockAddr(current_address_->ai_addr,
-                             current_address_->ai_addrlen))
-    return ERR_FAILED;
-
-  int rv = socket_->Connect(endpoint);
+  int rv = socket_->Connect(addresses_[current_address_index_]);
   DCHECK_NE(ERR_IO_PENDING, rv);
 
   return rv;
 }
 
 void ClientPacketizer::StartHelloTimer(base::TimeDelta delay) {
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ClientPacketizer::OnHelloTimeout, weak_factory_.GetWeakPtr()),
       delay);
@@ skipping 59 matching lines @@
   return rv;
 }
 
 void ClientPacketizer::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     DoCallback(rv);
 }
 
 }  // namespace net