Reimplements net::AddressList without struct addrinfo.

net/spdy/spdy_session_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/spdy/spdy_session_pool.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "net/base/address_list.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.h"
 #include "net/spdy/spdy_session.h"
 
 
 namespace net {
 
 namespace {
 
 enum SpdySessionGetTypes {
@@ skipping 144 matching lines @@
           "source_dependency", (*spdy_session)->net_log().source())));
 
   // We have a new session.  Lookup the IP address for this session so that we
   // can match future Sessions (potentially to different domains) which can
   // potentially be pooled with this one. Because GetPeerAddress() reports the
   // proxy's address instead of the origin server, check to see if this is a
   // direct connection.
   if (g_enable_ip_pooling  && host_port_proxy_pair.second.is_direct()) {
     AddressList addresses;
     if (connection->socket()->GetPeerAddress(&addresses) == OK)
-      AddAlias(addresses.head(), host_port_proxy_pair);
+      AddAlias(addresses.front(), host_port_proxy_pair);
   }
 
   // Now we can initialize the session with the SSL socket.
   return (*spdy_session)->InitializeWithSocket(connection, is_secure,
                                                certificate_error_code);
 }
 
 bool SpdySessionPool::HasSession(
     const HostPortProxyPair& host_port_proxy_pair) const {
   if (GetSessionList(host_port_proxy_pair))
@@ skipping 81 matching lines @@
       bool record_histograms) const {
   // We should only be checking aliases when there is no direct session.
   DCHECK(!GetSessionList(host_port_proxy_pair));
 
   if (!g_enable_ip_pooling)
     return NULL;
 
   AddressList addresses;
   if (!LookupAddresses(host_port_proxy_pair, net_log, &addresses))
     return NULL;
-  const addrinfo* address = addresses.head();
-  while (address) {
-    IPEndPoint endpoint;
-    endpoint.FromSockAddr(address->ai_addr, address->ai_addrlen);
-    address = address->ai_next;
-
-    SpdyAliasMap::const_iterator it = aliases_.find(endpoint);
-    if (it == aliases_.end())
+  for (AddressList::const_iterator iter = addresses.begin();
+       iter != addresses.end();
+       ++iter) {
+    SpdyAliasMap::const_iterator alias_iter = aliases_.find(*iter);
+    if (alias_iter == aliases_.end())
       continue;
 
     // We found an alias.
-    const HostPortProxyPair& alias_pair = it->second;
+    const HostPortProxyPair& alias_pair = alias_iter->second;
 
     // If the proxy settings match, we can reuse this session.
     if (!(alias_pair.second == host_port_proxy_pair.second))
       continue;
 
     SpdySessionList* list = GetSessionList(alias_pair);
     if (!list) {
       NOTREACHED();  // It shouldn't be in the aliases table if we can't get it!
       continue;
     }
@@ skipping 75 matching lines @@
 
 bool SpdySessionPool::LookupAddresses(const HostPortProxyPair& pair,
                                       const BoundNetLog& net_log,
                                       AddressList* addresses) const {
   net::HostResolver::RequestInfo resolve_info(pair.first);
   int rv = resolver_->ResolveFromCache(resolve_info, addresses, net_log);
   DCHECK_NE(ERR_IO_PENDING, rv);
   return rv == OK;
 }
 
-void SpdySessionPool::AddAlias(const addrinfo* address,
+void SpdySessionPool::AddAlias(const IPEndPoint& endpoint,
                                const HostPortProxyPair& pair) {
   DCHECK(g_enable_ip_pooling);
-  DCHECK(address);
-  IPEndPoint endpoint;
-  endpoint.FromSockAddr(address->ai_addr, address->ai_addrlen);
   aliases_[endpoint] = pair;
 }
 
 void SpdySessionPool::RemoveAliases(const HostPortProxyPair& pair) {
   // Walk the aliases map, find references to this pair.
   // TODO(mbelshe):  Figure out if this is too expensive.
   SpdyAliasMap::iterator alias_it = aliases_.begin();
   while (alias_it != aliases_.end()) {
     if (HostPortProxyPairsAreEqual(alias_it->second, pair)) {
       aliases_.erase(alias_it);
@@ skipping 59 matching lines @@
     const scoped_refptr<SpdySession>& session = *session_it;
     CHECK(session);
     if (!session->is_active()) {
       session->CloseSessionOnError(
           net::ERR_ABORTED, true, "Closing idle sessions.");
     }
   }
 }
 
 }  // namespace net