Reimplements net::AddressList without struct addrinfo.

net/socket/transport_client_socket_pool.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/socket/transport_client_socket_pool.h"
 
+#include <algorithm>
+
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log.h"
 #include "net/base/net_errors.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/tcp_client_socket.h"
 
 using base::TimeDelta;
 
 namespace net {
 
 // TODO(willchan): Base this off RTT instead of statically setting it. Note we
 // choose a timeout that is different from the backup connect job timer so they
 // don't synchronize.
 const int TransportConnectJob::kIPv6FallbackTimerInMs = 300;
 
 namespace {
 
-bool AddressListStartsWithIPv6AndHasAnIPv4Addr(const AddressList& addrlist) {
-  const struct addrinfo* ai = addrlist.head();
-  if (ai->ai_family != AF_INET6)
-    return false;
-
-  ai = ai->ai_next;
-  while (ai) {
-    if (ai->ai_family != AF_INET6)
-      return true;
-    ai = ai->ai_next;
-  }
-
-  return false;
-}
-
-bool AddressListOnlyContainsIPv6Addresses(const AddressList& addrlist) {
-  DCHECK(addrlist.head());
-  for (const struct addrinfo* ai = addrlist.head(); ai; ai = ai->ai_next) {
-    if (ai->ai_family != AF_INET6)
+// Returns true iff all addresses in |list| are in the IPv6 family.
+bool AddressListOnlyContainsIPv6(const AddressList& list) {
+  DCHECK(!list.empty());
+  for (AddressList::const_iterator iter = list.begin(); iter != list.end();
+       ++iter) {
+    if (iter->GetFamily() != AF_INET6)
       return false;
   }
-
   return true;
 }
 
 }  // namespace
 
 TransportSocketParams::TransportSocketParams(
     const HostPortPair& host_port_pair,
     RequestPriority priority,
     bool disable_resolver_cache,
     bool ignore_limits)
@@ skipping 50 matching lines @@
     case STATE_TRANSPORT_CONNECT:
     case STATE_TRANSPORT_CONNECT_COMPLETE:
       return LOAD_STATE_CONNECTING;
     default:
       NOTREACHED();
       return LOAD_STATE_IDLE;
   }
 }
 
 // static
-void TransportConnectJob::MakeAddrListStartWithIPv4(AddressList* addrlist) {
-  if (addrlist->head()->ai_family != AF_INET6)
-    return;
-  bool has_ipv4 = false;
-  for (const struct addrinfo* ai = addrlist->head(); ai; ai = ai->ai_next) {
-    if (ai->ai_family != AF_INET6) {
-      has_ipv4 = true;
+void TransportConnectJob::MakeAddressListStartWithIPv4(AddressList* list) {
+  for (AddressList::iterator i = list->begin(); i != list->end(); ++i) {
+    if (i->GetFamily() == AF_INET) {
+      std::rotate(list->begin(), i, list->end());

[eroman, 2012/05/04 01:08:41]

Hmm I'll need to lookup rotate and think about this...

       break;
     }
   }
-  if (!has_ipv4)
-    return;
-
-  struct addrinfo* head = CreateCopyOfAddrinfo(addrlist->head(), true);
-  struct addrinfo* tail = head;
-  while (tail->ai_next)
-    tail = tail->ai_next;
-  char* canonname = head->ai_canonname;
-  head->ai_canonname = NULL;
-  while (head->ai_family == AF_INET6) {
-    tail->ai_next = head;
-    tail = head;
-    head = head->ai_next;
-    tail->ai_next = NULL;
-  }
-  head->ai_canonname = canonname;
-
-  *addrlist = AddressList::CreateByCopying(head);
-  FreeCopyOfAddrinfo(head);
 }
 
 void TransportConnectJob::OnIOComplete(int result) {
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING)
     NotifyDelegateOfCompletion(rv);  // Deletes |this|
 }
 
 int TransportConnectJob::DoLoop(int result) {
   DCHECK_NE(next_state_, STATE_NONE);
@@ skipping 42 matching lines @@
 }
 
 int TransportConnectJob::DoTransportConnect() {
   next_state_ = STATE_TRANSPORT_CONNECT_COMPLETE;
   transport_socket_.reset(client_socket_factory_->CreateTransportClientSocket(
         addresses_, net_log().net_log(), net_log().source()));
   connect_start_time_ = base::TimeTicks::Now();
   int rv = transport_socket_->Connect(
       base::Bind(&TransportConnectJob::OnIOComplete, base::Unretained(this)));
   if (rv == ERR_IO_PENDING &&
-      AddressListStartsWithIPv6AndHasAnIPv4Addr(addresses_)) {
+      addresses_.front().GetFamily() == AF_INET6 &&
+      !AddressListOnlyContainsIPv6(addresses_)) {
     fallback_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kIPv6FallbackTimerInMs),
         this, &TransportConnectJob::DoIPv6FallbackTransportConnect);
   }
   return rv;
 }
 
 int TransportConnectJob::DoTransportConnectComplete(int result) {
   if (result == OK) {
-    bool is_ipv4 = addresses_.head()->ai_family != AF_INET6;
+    bool is_ipv4 = addresses_.front().GetFamily() != AF_INET6;
     DCHECK(connect_start_time_ != base::TimeTicks());
     DCHECK(start_time_ != base::TimeTicks());
     base::TimeTicks now = base::TimeTicks::Now();
     base::TimeDelta total_duration = now - start_time_;
     UMA_HISTOGRAM_CUSTOM_TIMES(
         "Net.DNS_Resolution_And_TCP_Connection_Latency2",
         total_duration,
         base::TimeDelta::FromMilliseconds(1),
         base::TimeDelta::FromMinutes(10),
         100);
 
     base::TimeDelta connect_duration = now - connect_start_time_;
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency",
         connect_duration,
         base::TimeDelta::FromMilliseconds(1),
         base::TimeDelta::FromMinutes(10),
         100);
 
     if (is_ipv4) {
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv4_No_Race",
                                  connect_duration,
                                  base::TimeDelta::FromMilliseconds(1),
                                  base::TimeDelta::FromMinutes(10),
                                  100);
     } else {
-      if (AddressListOnlyContainsIPv6Addresses(addresses_)) {
+      if (AddressListOnlyContainsIPv6(addresses_)) {
         UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv6_Solo",
                                    connect_duration,
                                    base::TimeDelta::FromMilliseconds(1),
                                    base::TimeDelta::FromMinutes(10),
                                    100);
       } else {
         UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv6_Raceable",
                                    connect_duration,
                                    base::TimeDelta::FromMilliseconds(1),
                                    base::TimeDelta::FromMinutes(10),
@@ skipping 16 matching lines @@
   // succeed.
   if (next_state_ != STATE_TRANSPORT_CONNECT_COMPLETE) {
     NOTREACHED();
     return;
   }
 
   DCHECK(!fallback_transport_socket_.get());
   DCHECK(!fallback_addresses_.get());
 
   fallback_addresses_.reset(new AddressList(addresses_));
-  MakeAddrListStartWithIPv4(fallback_addresses_.get());
+  MakeAddressListStartWithIPv4(fallback_addresses_.get());
   fallback_transport_socket_.reset(
       client_socket_factory_->CreateTransportClientSocket(
           *fallback_addresses_, net_log().net_log(), net_log().source()));
   fallback_connect_start_time_ = base::TimeTicks::Now();
   int rv = fallback_transport_socket_->Connect(
       base::Bind(
           &TransportConnectJob::DoIPv6FallbackTransportConnectComplete,
           base::Unretained(this)));
   if (rv != ERR_IO_PENDING)
     DoIPv6FallbackTransportConnectComplete(rv);
@@ skipping 187 matching lines @@
 
 base::TimeDelta TransportClientSocketPool::ConnectionTimeout() const {
   return base_.ConnectionTimeout();
 }
 
 ClientSocketPoolHistograms* TransportClientSocketPool::histograms() const {
   return base_.histograms();
 }
 
 }  // namespace net