Reimplements net::AddressList without struct addrinfo.

net::AddressList extends std::vector<std::IPEndPoint> by canonical name. (Canonical name is planned to be removed as well.)

Removes dependency on sys_addrinfo.h throughout the codebase.

Introduces net::SockaddrStorage for convenience.

BUG=125696
TEST=green waterfall


Review URL: http://codereview.chromium.org/10309002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@135731 0039d316-1c4b-4281-b951-d872f2087c98

69 files changed, 641 insertions, 1432 deletions

diff --git a/net/base/address_list.cc b/net/base/address_list.cc
index 4aee12c..e5935c7 100644
--- a/net/base/address_list.cc
+++ b/net/base/address_list.cc
@@ -4,283 +4,66 @@
 
 #include "net/base/address_list.h"
 
-#include <stdlib.h>
-
 #include "base/logging.h"
-#include "base/string_util.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
 
 namespace net {
 
-namespace {
-
-struct addrinfo* CreateAddrInfo(const IPAddressNumber& address,
-                                bool canonicalize_name) {
-  struct addrinfo* ai = new addrinfo;
-  memset(ai, 0, sizeof(addrinfo));
-  ai->ai_socktype = SOCK_STREAM;
-
-  switch (address.size()) {
-    case kIPv4AddressSize: {
-      ai->ai_family = AF_INET;
-      const size_t sockaddr_in_size = sizeof(struct sockaddr_in);
-      ai->ai_addrlen = sockaddr_in_size;
-
-      struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(
-          new char[sockaddr_in_size]);
-      memset(addr, 0, sockaddr_in_size);
-      addr->sin_family = AF_INET;
-#if defined(SIN6_LEN)
-      addr->sin_len = sockaddr_in_size;
-#endif
-      memcpy(&addr->sin_addr, &address[0], kIPv4AddressSize);
-      ai->ai_addr = reinterpret_cast<struct sockaddr*>(addr);
-      break;
-    }
-    case kIPv6AddressSize: {
-      ai->ai_family = AF_INET6;
-      const size_t sockaddr_in6_size = sizeof(struct sockaddr_in6);
-      ai->ai_addrlen = sockaddr_in6_size;
-
-      struct sockaddr_in6* addr6 = reinterpret_cast<struct sockaddr_in6*>(
-          new char[sockaddr_in6_size]);
-      memset(addr6, 0, sockaddr_in6_size);
-      addr6->sin6_family = AF_INET6;
-#if defined(SIN6_LEN)
-      addr6->sin6_len = sockaddr_in6_size;
-#endif
-      memcpy(&addr6->sin6_addr, &address[0], kIPv6AddressSize);
-      ai->ai_addr = reinterpret_cast<struct sockaddr*>(addr6);
-      break;
-    }
-    default: {
-      NOTREACHED() << "Bad IP address";
-      break;
-    }
-  }
-
-  if (canonicalize_name) {
-    std::string name = NetAddressToString(ai);
-    ai->ai_canonname = base::strdup(name.c_str());
-  }
-  return ai;
-}
-
-}  // namespace
-
-struct AddressList::Data : public base::RefCountedThreadSafe<Data> {
-  Data(struct addrinfo* ai, bool is_system_created);
-
-  // This variable is const since it should NOT be mutated. Since
-  // Data is reference counted, this |head| could be shared by multiple
-  // instances of AddressList, hence we need to be careful not to mutate
-  // it from any one instance.
-  const struct addrinfo * const head;
-
-  // Indicates which free function to use for |head|.
-  bool is_system_created;
-
- private:
-  friend class base::RefCountedThreadSafe<Data>;
-
-  ~Data();
-};
+AddressList::AddressList() {}
 
-AddressList::AddressList() {
-}
-
-AddressList::AddressList(const AddressList& addresslist)
-    : data_(addresslist.data_) {
-}
+AddressList::~AddressList() {}
 
-AddressList::~AddressList() {
+AddressList::AddressList(const IPEndPoint& endpoint) {
+  push_back(endpoint);
 }
 
-AddressList& AddressList::operator=(const AddressList& addresslist) {
-  data_ = addresslist.data_;
-  return *this;
+// static
+AddressList AddressList::CreateFromIPAddress(const IPAddressNumber& address,
+                                             uint16 port) {
+  return AddressList(IPEndPoint(address, port));
 }
 
 // static
 AddressList AddressList::CreateFromIPAddressList(
     const IPAddressList& addresses,
     const std::string& canonical_name) {
-  DCHECK(!addresses.empty());
-  struct addrinfo* head = NULL;
-  struct addrinfo* next = NULL;
-
-  for (IPAddressList::const_iterator it = addresses.begin();
-       it != addresses.end(); ++it) {
-    if (head == NULL) {
-      head = next = CreateAddrInfo(*it, false);
-      if (!canonical_name.empty()) {
-        head->ai_canonname = base::strdup(canonical_name.c_str());
-      }
-    } else {
-      next->ai_next = CreateAddrInfo(*it, false);
-      next = next->ai_next;
-    }
+  AddressList list;
+  list.set_canonical_name(canonical_name);
+  for (IPAddressList::const_iterator iter = addresses.begin();
+       iter != addresses.end(); ++iter) {
+    list.push_back(IPEndPoint(*iter, 0));
   }
-
-  return AddressList(new Data(head, false));
+  return list;
 }
 
 // static
-AddressList AddressList::CreateFromIPAddress(
-      const IPAddressNumber& address,
-      uint16 port) {
-  return CreateFromIPAddressWithCname(address, port, false);
-}
-
-// static
-AddressList AddressList::CreateFromIPAddressWithCname(
-    const IPAddressNumber& address,
-    uint16 port,
-    bool canonicalize_name) {
-  struct addrinfo* ai = CreateAddrInfo(address, canonicalize_name);
-
-  SetPortForAllAddrinfos(ai, port);
-  return AddressList(new Data(ai, false /*is_system_created*/));
-}
-
-
-// static
-AddressList AddressList::CreateByAdoptingFromSystem(struct addrinfo* head) {
-  return AddressList(new Data(head, true /*is_system_created*/));
-}
-
-// static
-AddressList AddressList::CreateByCopying(const struct addrinfo* head) {
-  return AddressList(new Data(CreateCopyOfAddrinfo(head, true /*recursive*/),
-                              false /*is_system_created*/));
-}
-
-// static
-AddressList AddressList::CreateByCopyingFirstAddress(
-    const struct addrinfo* head) {
-  return AddressList(new Data(CreateCopyOfAddrinfo(head, false /*recursive*/),
-                              false /*is_system_created*/));
-}
-
-// static
-AddressList AddressList::CreateFromSockaddr(
-    const struct sockaddr* address,
-    socklen_t address_length,
-    int socket_type,
-    int protocol) {
-  // Do sanity checking on socket_type and protocol.
-  DCHECK(socket_type == SOCK_DGRAM || socket_type == SOCK_STREAM);
-  DCHECK(protocol == IPPROTO_TCP || protocol == IPPROTO_UDP);
-
-  struct addrinfo* ai = new addrinfo;
-  memset(ai, 0, sizeof(addrinfo));
-  switch (address_length) {
-    case sizeof(struct sockaddr_in):
-      {
-        const struct sockaddr_in* sin =
-            reinterpret_cast<const struct sockaddr_in*>(address);
-        ai->ai_family = sin->sin_family;
-        DCHECK_EQ(AF_INET, ai->ai_family);
-      }
-      break;
-    case sizeof(struct sockaddr_in6):
-      {
-        const struct sockaddr_in6* sin6 =
-            reinterpret_cast<const struct sockaddr_in6*>(address);
-        ai->ai_family = sin6->sin6_family;
-        DCHECK_EQ(AF_INET6, ai->ai_family);
-      }
-      break;
-    default:
-      NOTREACHED() << "Bad IP address";
-      break;
-  }
-  ai->ai_socktype = socket_type;
-  ai->ai_protocol = protocol;
-  ai->ai_addrlen = address_length;
-  ai->ai_addr = reinterpret_cast<struct sockaddr*>(new char[address_length]);
-  memcpy(ai->ai_addr, address, address_length);
-  return AddressList(new Data(ai, false /*is_system_created*/));
-}
-
-void AddressList::Append(const struct addrinfo* head) {
+AddressList AddressList::CreateFromAddrinfo(const struct addrinfo* head) {
   DCHECK(head);
-  // Always create a copy, since the Data might be shared across instances.
-  struct addrinfo* new_head = CreateCopyOfAddrinfo(data_->head, true);
-  data_ = new Data(new_head, false /*is_system_created*/);
-
-  // Find the end of current linked list and append new data there.
-  struct addrinfo* copy_ptr = new_head;
-  while (copy_ptr->ai_next)
-    copy_ptr = copy_ptr->ai_next;
-  copy_ptr->ai_next = CreateCopyOfAddrinfo(head, true);
-
-  // Only the head of the list should have a canonname.  Strip any
-  // canonical name in the appended data.
-  copy_ptr = copy_ptr->ai_next;
-  while (copy_ptr) {
-    if (copy_ptr->ai_canonname) {
-      free(copy_ptr->ai_canonname);
-      copy_ptr->ai_canonname = NULL;
-    }
-    copy_ptr = copy_ptr->ai_next;
+  AddressList list;
+  if (head->ai_canonname)
+    list.set_canonical_name(std::string(head->ai_canonname));
+  for (const struct addrinfo* ai = head; ai; ai = ai->ai_next) {
+    IPEndPoint ipe;
+    // NOTE: Ignoring non-INET* families.
+    if (ipe.FromSockAddr(ai->ai_addr, ai->ai_addrlen))
+      list.push_back(ipe);
+    else
+      DLOG(WARNING) << "Unknown family found in addrinfo: " << ai->ai_family;
   }
+  return list;
 }
 
-void AddressList::SetPort(uint16 port) {
-  // NOTE: we need to be careful not to mutate the reference-counted data,
-  // since it might be shared by other AddressLists.
-  struct addrinfo* head = CreateCopyOfAddrinfo(data_->head, true);
-  SetPortForAllAddrinfos(head, port);
-  data_ = new Data(head, false /*is_system_created*/);
+void AddressList::SetDefaultCanonicalName() {
+  DCHECK(!empty());
+  set_canonical_name(front().ToStringWithoutPort());
 }
 
-uint16 AddressList::GetPort() const {
-  return GetPortFromAddrinfo(data_->head);
-}
-
-bool AddressList::GetCanonicalName(std::string* canonical_name) const {
-  DCHECK(canonical_name);
-  if (!data_ || !data_->head->ai_canonname)
-    return false;
-  canonical_name->assign(data_->head->ai_canonname);
-  return true;
-}
-
-const struct addrinfo* AddressList::head() const {
-  if (!data_)
-    return NULL;
-  return data_->head;
-}
-
-AddressList::AddressList(Data* data) : data_(data) {}
-
-AddressList::Data::Data(struct addrinfo* ai, bool is_system_created)
-    : head(ai), is_system_created(is_system_created) {
-  DCHECK(head);
-}
-
-AddressList::Data::~Data() {
-  // Casting away the const is safe, since upon destruction we know that
-  // no one holds a reference to the data any more.
-  struct addrinfo* mutable_head = const_cast<struct addrinfo*>(head);
-
-  // Call either freeaddrinfo(head), or FreeMyAddrinfo(head), depending who
-  // created the data.
-  if (is_system_created)
-    freeaddrinfo(mutable_head);
-  else
-    FreeCopyOfAddrinfo(mutable_head);
-}
-
-AddressList CreateAddressListUsingPort(const AddressList& src, int port) {
-  if (src.GetPort() == port)
-    return src;
-
-  AddressList out = src;
-  out.SetPort(port);
-  return out;
+void SetPortOnAddressList(uint16 port, AddressList* list) {
+  DCHECK(list);
+  for (AddressList::iterator it = list->begin(); it != list->end(); ++it) {
+    *it = IPEndPoint(it->address(), port);
+  }
 }
 
 }  // namespace net
diff --git a/net/base/address_list.h b/net/base/address_list.h
index edcdf09..c76152f 100644
--- a/net/base/address_list.h
+++ b/net/base/address_list.h
@@ -7,8 +7,10 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
-#include "base/memory/ref_counted.h"
+#include "base/basictypes.h"
+#include "net/base/ip_endpoint.h"
 #include "net/base/net_export.h"
 #include "net/base/net_util.h"
 
@@ -16,106 +18,62 @@ struct addrinfo;
 
 namespace net {
 
-// An AddressList object contains a linked list of addrinfo structures.  This
-// class is designed to be copied around by value.
-class NET_EXPORT AddressList {
+class NET_EXPORT AddressList : private std::vector<IPEndPoint> {
  public:
-  // Constructs an invalid address list. Should not call any methods on this
-  // other than assignment.
   AddressList();
-
-  AddressList(const AddressList& addresslist);
   ~AddressList();
-  AddressList& operator=(const AddressList& addresslist);
 
-  // Creates an address list for a list of IP literals.
+  // Creates an address list for a single IP literal.
+  explicit AddressList(const IPEndPoint& endpoint);
+
+  static AddressList CreateFromIPAddress(const IPAddressNumber& address,
+                                         uint16 port);
+
   static AddressList CreateFromIPAddressList(
       const IPAddressList& addresses,
       const std::string& canonical_name);
 
-  // Creates an address list for a single IP literal.
-  static AddressList CreateFromIPAddress(
-      const IPAddressNumber& address,
-      uint16 port);
-
-  // Creates an address list for a single IP literal.  If
-  // |canonicalize_name| is true, fill the ai_canonname field with the
-  // canonicalized IP address.
-  static AddressList CreateFromIPAddressWithCname(
-      const IPAddressNumber& address,
-      uint16 port,
-      bool canonicalize_name);
-
-  // Adopts the given addrinfo list (assumed to have been created by
-  // the system, e.g. returned by getaddrinfo()) in place of the
-  // existing one if any.  This hands over responsibility for freeing
-  // the addrinfo list to the AddressList object.
-  static AddressList CreateByAdoptingFromSystem(struct addrinfo* head);
-
-  // Creates a new address list with a copy of |head|. This includes the
-  // entire linked list.
-  static AddressList CreateByCopying(const struct addrinfo* head);
-
-  // Creates a new address list wich has a single address, |head|. If there
-  // are other addresses in |head| they will be ignored.
-  static AddressList CreateByCopyingFirstAddress(const struct addrinfo* head);
-
-  // Creates an address list for a single socket address.
-  // |address| the sockaddr to copy.
-  // |socket_type| is either SOCK_STREAM or SOCK_DGRAM.
-  // |protocol| is either IPPROTO_TCP or IPPROTO_UDP.
-  static AddressList CreateFromSockaddr(
-      const struct sockaddr* address,
-      socklen_t address_length,
-      int socket_type,
-      int protocol);
-
-  // Appends a copy of |head| and all its linked addrinfos to the stored
-  // addrinfo. Note that this will cause a reallocation of the linked list,
-  // which invalidates the head pointer.
-  void Append(const struct addrinfo* head);
-
-  // Sets the port of all addresses in the list to |port| (that is the
-  // sin[6]_port field for the sockaddrs). Note that this will cause a
-  // reallocation of the linked list, which invalidates the head pointer.
-  void SetPort(uint16 port);
-
-  // Retrieves the port number of the first sockaddr in the list. (If SetPort()
-  // was previously used on this list, then all the addresses will have this
-  // same port number.)
-  uint16 GetPort() const;
-
-  // Gets the canonical name for the address.
-  // If the canonical name exists, |*canonical_name| is filled in with the
-  // value and true is returned. If it does not exist, |*canonical_name| is
-  // not altered and false is returned.
-  // |canonical_name| must be a non-null value.
-  bool GetCanonicalName(std::string* canonical_name) const;
-
-  // Gets access to the head of the addrinfo list.
-  //
-  // IMPORTANT: Callers SHOULD NOT mutate the addrinfo chain, since under the
-  //            hood this data might be shared by other AddressLists, which
-  //            might even be running on other threads.
-  //
-  //            Additionally, non-const methods like SetPort() and Append() can
-  //            cause the head to be reallocated, so do not cache the return
-  //            value of head() across such calls.
-  const struct addrinfo* head() const;
+  // Copies the data from |head| and the chained list into an AddressList.
+  static AddressList CreateFromAddrinfo(const struct addrinfo* head);
+
+  // TODO(szym): Remove all three. http://crbug.com/126134
+  const std::string& canonical_name() const {
+    return canonical_name_;
+  }
+
+  void set_canonical_name(const std::string& canonical_name) {
+    canonical_name_ = canonical_name;
+  }
+
+  // Sets canonical name to the literal of the first IP address on the list.
+  void SetDefaultCanonicalName();
+
+  // Exposed methods from std::vector.
+  using std::vector<IPEndPoint>::size;
+  using std::vector<IPEndPoint>::empty;
+  using std::vector<IPEndPoint>::clear;
+  using std::vector<IPEndPoint>::reserve;
+  using std::vector<IPEndPoint>::capacity;
+  using std::vector<IPEndPoint>::operator[];
+  using std::vector<IPEndPoint>::front;
+  using std::vector<IPEndPoint>::back;
+  using std::vector<IPEndPoint>::push_back;
+  using std::vector<IPEndPoint>::insert;
+  using std::vector<IPEndPoint>::erase;
+  using std::vector<IPEndPoint>::iterator;
+  using std::vector<IPEndPoint>::const_iterator;
+  using std::vector<IPEndPoint>::begin;
+  using std::vector<IPEndPoint>::end;
+  using std::vector<IPEndPoint>::rbegin;
+  using std::vector<IPEndPoint>::rend;
 
  private:
-  struct Data;
-
-  explicit AddressList(Data* data);
-
-  scoped_refptr<Data> data_;
+   // TODO(szym): Remove. http://crbug.com/126134
+  std::string canonical_name_;
 };
 
-// Helper to create an AddressList that has a particular port. It has an
-// optimization to avoid allocating a new address linked list when the
-// port is already what we want.
-AddressList NET_EXPORT CreateAddressListUsingPort(const AddressList& src,
-                                                  int port);
+// Sets the port on each element in |list| to |port|.
+void NET_EXPORT SetPortOnAddressList(uint16 port, AddressList* list);
 
 }  // namespace net
 
diff --git a/net/base/address_list_net_log_param.cc b/net/base/address_list_net_log_param.cc
index 72332ef..78fa660 100644
--- a/net/base/address_list_net_log_param.cc
+++ b/net/base/address_list_net_log_param.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -6,7 +6,6 @@
 
 #include "base/values.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 
 namespace net {
 
@@ -18,9 +17,8 @@ Value* AddressListNetLogParam::ToValue() const {
   DictionaryValue* dict = new DictionaryValue();
   ListValue* list = new ListValue();
 
-  for (const addrinfo* head = address_list_.head();
-       head != NULL ; head = head->ai_next) {
-    list->Append(Value::CreateStringValue(NetAddressToStringWithPort(head)));
+  for (size_t i = 0; i < address_list_.size() ; ++i) {
+    list->Append(Value::CreateStringValue(address_list_[i].ToString()));
   }
 
   dict->Set("address_list", list);
diff --git a/net/base/address_list_unittest.cc b/net/base/address_list_unittest.cc
index 7eda7df..734332e 100644
--- a/net/base/address_list_unittest.cc
+++ b/net/base/address_list_unittest.cc
@@ -4,155 +4,25 @@
 
 #include "net/base/address_list.h"
 
-#include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
-#include "net/base/host_resolver_proc.h"
+#include "base/sys_byteorder.h"
 #include "net/base/net_util.h"
 #include "net/base/sys_addrinfo.h"
-#if defined(OS_WIN)
-#include "net/base/winsock_init.h"
-#endif
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
-void MutableSetPort(uint16 port, AddressList* addrlist) {
-  struct addrinfo* mutable_head =
-      const_cast<struct addrinfo*>(addrlist->head());
-  SetPortForAllAddrinfos(mutable_head, port);
-}
-
-// Use getaddrinfo() to allocate an addrinfo structure.
-int CreateAddressList(const std::string& hostname, int port,
-                      AddressList* addrlist) {
-#if defined(OS_WIN)
-  EnsureWinsockInit();
-#endif
-  int rv = SystemHostResolverProc(hostname,
-                                  ADDRESS_FAMILY_UNSPECIFIED,
-                                  0,
-                                  addrlist, NULL);
-  if (rv == 0)
-    MutableSetPort(port, addrlist);
-  return rv;
-}
-
-void CreateLongAddressList(AddressList* addrlist, int port) {
-  EXPECT_EQ(0, CreateAddressList("192.168.1.1", port, addrlist));
-  AddressList second_list;
-  EXPECT_EQ(0, CreateAddressList("192.168.1.2", port, &second_list));
-  addrlist->Append(second_list.head());
-}
-
-TEST(AddressListTest, GetPort) {
-  AddressList addrlist;
-  EXPECT_EQ(0, CreateAddressList("192.168.1.1", 81, &addrlist));
-  EXPECT_EQ(81, addrlist.GetPort());
-
-  MutableSetPort(83, &addrlist);
-  EXPECT_EQ(83, addrlist.GetPort());
-}
-
-TEST(AddressListTest, SetPortMakesCopy) {
-  AddressList addrlist1;
-  EXPECT_EQ(0, CreateAddressList("192.168.1.1", 85, &addrlist1));
-  EXPECT_EQ(85, addrlist1.GetPort());
-
-  AddressList addrlist2 = addrlist1;
-  EXPECT_EQ(85, addrlist2.GetPort());
-
-  // addrlist1 should not be affected by the assignment to
-  // addrlist2.
-  addrlist1.SetPort(80);
-  EXPECT_EQ(80, addrlist1.GetPort());
-  EXPECT_EQ(85, addrlist2.GetPort());
-}
-
-TEST(AddressListTest, Assignment) {
-  AddressList addrlist1;
-  EXPECT_EQ(0, CreateAddressList("192.168.1.1", 85, &addrlist1));
-  EXPECT_EQ(85, addrlist1.GetPort());
-
-  // Should reference the same data as addrlist1 -- so when we change addrlist1
-  // both are changed.
-  AddressList addrlist2 = addrlist1;
-  EXPECT_EQ(85, addrlist2.GetPort());
-
-  MutableSetPort(80, &addrlist1);
-  EXPECT_EQ(80, addrlist1.GetPort());
-  EXPECT_EQ(80, addrlist2.GetPort());
-}
-
-TEST(AddressListTest, CopyRecursive) {
-  AddressList addrlist1;
-  CreateLongAddressList(&addrlist1, 85);
-  EXPECT_EQ(85, addrlist1.GetPort());
-
-  AddressList addrlist2 =
-      AddressList::CreateByCopying(addrlist1.head());
-
-  ASSERT_TRUE(addrlist2.head()->ai_next != NULL);
-
-  // addrlist1 is the same as addrlist2 at this point.
-  EXPECT_EQ(85, addrlist1.GetPort());
-  EXPECT_EQ(85, addrlist2.GetPort());
-
-  // Changes to addrlist1 are not reflected in addrlist2.
-  MutableSetPort(70, &addrlist1);
-  MutableSetPort(90, &addrlist2);
-
-  EXPECT_EQ(70, addrlist1.GetPort());
-  EXPECT_EQ(90, addrlist2.GetPort());
-}
-
-TEST(AddressListTest, CopyNonRecursive) {
-  AddressList addrlist1;
-  CreateLongAddressList(&addrlist1, 85);
-  EXPECT_EQ(85, addrlist1.GetPort());
-
-  AddressList addrlist2 =
-      AddressList::CreateByCopyingFirstAddress(addrlist1.head());
-
-  ASSERT_TRUE(addrlist2.head()->ai_next == NULL);
-
-  // addrlist1 is the same as addrlist2 at this point.
-  EXPECT_EQ(85, addrlist1.GetPort());
-  EXPECT_EQ(85, addrlist2.GetPort());
-
-  // Changes to addrlist1 are not reflected in addrlist2.
-  MutableSetPort(70, &addrlist1);
-  MutableSetPort(90, &addrlist2);
-
-  EXPECT_EQ(70, addrlist1.GetPort());
-  EXPECT_EQ(90, addrlist2.GetPort());
-}
-
-TEST(AddressListTest, Append) {
-  AddressList addrlist1;
-  EXPECT_EQ(0, CreateAddressList("192.168.1.1", 11, &addrlist1));
-  EXPECT_EQ(11, addrlist1.GetPort());
-  AddressList addrlist2;
-  EXPECT_EQ(0, CreateAddressList("192.168.1.2", 12, &addrlist2));
-  EXPECT_EQ(12, addrlist2.GetPort());
-
-  ASSERT_TRUE(addrlist1.head()->ai_next == NULL);
-  addrlist1.Append(addrlist2.head());
-  ASSERT_TRUE(addrlist1.head()->ai_next != NULL);
-
-  AddressList addrlist3 =
-      AddressList::CreateByCopyingFirstAddress(addrlist1.head()->ai_next);
-  EXPECT_EQ(12, addrlist3.GetPort());
-}
-
 static const char* kCanonicalHostname = "canonical.bar.com";
 
 TEST(AddressListTest, Canonical) {
   // Create an addrinfo with a canonical name.
-  sockaddr_in address;
+  struct sockaddr_in address;
   // The contents of address do not matter for this test,
   // so just zero-ing them out for consistency.
   memset(&address, 0x0, sizeof(address));
+  // But we need to set the family.
+  address.sin_family = AF_INET;
   struct addrinfo ai;
   memset(&ai, 0x0, sizeof(ai));
   ai.ai_family = AF_INET;
@@ -163,115 +33,57 @@ TEST(AddressListTest, Canonical) {
 
   // Copy the addrinfo struct into an AddressList object and
   // make sure it seems correct.
-  AddressList addrlist1 = AddressList::CreateByCopying(&ai);
-  const struct addrinfo* addrinfo1 = addrlist1.head();
-  EXPECT_TRUE(addrinfo1 != NULL);
-  EXPECT_TRUE(addrinfo1->ai_next == NULL);
-  std::string canon_name1;
-  EXPECT_TRUE(addrlist1.GetCanonicalName(&canon_name1));
-  EXPECT_EQ("canonical.bar.com", canon_name1);
+  AddressList addrlist1 = AddressList::CreateFromAddrinfo(&ai);
+  EXPECT_EQ("canonical.bar.com", addrlist1.canonical_name());
 
   // Copy the AddressList to another one.
-  AddressList addrlist2 = AddressList::CreateByCopying(addrinfo1);
-  const struct addrinfo* addrinfo2 = addrlist2.head();
-  EXPECT_TRUE(addrinfo2 != NULL);
-  EXPECT_TRUE(addrinfo2->ai_next == NULL);
-  EXPECT_TRUE(addrinfo2->ai_canonname != NULL);
-  EXPECT_NE(addrinfo1, addrinfo2);
-  EXPECT_NE(addrinfo1->ai_canonname, addrinfo2->ai_canonname);
-  std::string canon_name2;
-  EXPECT_TRUE(addrlist2.GetCanonicalName(&canon_name2));
-  EXPECT_EQ("canonical.bar.com", canon_name2);
-
-  // Make sure that GetCanonicalName correctly returns false
-  // when ai_canonname is NULL.
-  ai.ai_canonname = NULL;
-  AddressList addrlist_no_canon = AddressList::CreateByCopying(&ai);
-  std::string canon_name3 = "blah";
-  EXPECT_FALSE(addrlist_no_canon.GetCanonicalName(&canon_name3));
-  EXPECT_EQ("blah", canon_name3);
+  AddressList addrlist2 = addrlist1;
+  EXPECT_EQ("canonical.bar.com", addrlist2.canonical_name());
 }
 
-TEST(AddressListTest, IPLiteralConstructor) {
-  struct TestData {
-    std::string ip_address;
-    std::string canonical_ip_address;
-    bool is_ipv6;
-  } tests[] = {
-    { "127.0.00.1", "127.0.0.1", false },
-    { "192.168.1.1", "192.168.1.1", false },
-    { "::1", "::1", true },
-    { "2001:db8:0::42", "2001:db8::42", true },
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
-    AddressList expected_list;
-    int rv = CreateAddressList(tests[i].canonical_ip_address, 80,
-                               &expected_list);
-    if (tests[i].is_ipv6 && rv != 0) {
-      LOG(WARNING) << "Unable to resolve ip literal '" << tests[i].ip_address
-                   << "' test skipped.";
-      continue;
-    }
-    ASSERT_EQ(0, rv);
-    const struct addrinfo* good_ai = expected_list.head();
+TEST(AddressListTest, CreateFromAddrinfo) {
+  // Create an 4-element addrinfo.
+  const unsigned kNumElements = 4;
+  SockaddrStorage storage[kNumElements];
+  struct addrinfo ai[kNumElements];
+  for (unsigned i = 0; i < kNumElements; ++i) {
+    struct sockaddr_in* addr =
+        reinterpret_cast<struct sockaddr_in*>(storage[i].addr);
+    storage[i].addr_len = sizeof(struct sockaddr_in);
+    // Populating the address with { i, i, i, i }.
+    memset(&addr->sin_addr, i, kIPv4AddressSize);
+    addr->sin_family = AF_INET;
+    // Set port to i << 2;
+    addr->sin_port = base::HostToNet16(static_cast<uint16>(i << 2));
+    memset(&ai[i], 0x0, sizeof(ai[i]));
+    ai[i].ai_family = addr->sin_family;
+    ai[i].ai_socktype = SOCK_STREAM;
+    ai[i].ai_addrlen = storage[i].addr_len;
+    ai[i].ai_addr = storage[i].addr;
+    if (i + 1 < kNumElements)
+      ai[i].ai_next = &ai[i + 1];
+  }
 
-    IPAddressNumber ip_number;
-    ASSERT_TRUE(ParseIPLiteralToNumber(tests[i].ip_address, &ip_number));
-    AddressList test_list = AddressList::CreateFromIPAddressWithCname(
-        ip_number, 80, true);
-    const struct addrinfo* test_ai = test_list.head();
+  AddressList list = AddressList::CreateFromAddrinfo(&ai[0]);
 
-    EXPECT_EQ(good_ai->ai_family, test_ai->ai_family);
-    EXPECT_EQ(good_ai->ai_socktype, test_ai->ai_socktype);
-    EXPECT_EQ(good_ai->ai_addrlen, test_ai->ai_addrlen);
-    size_t sockaddr_size =
-        good_ai->ai_socktype == AF_INET ? sizeof(struct sockaddr_in) :
-        good_ai->ai_socktype == AF_INET6 ? sizeof(struct sockaddr_in6) : 0;
-    EXPECT_EQ(memcmp(good_ai->ai_addr, test_ai->ai_addr, sockaddr_size), 0);
-    EXPECT_EQ(good_ai->ai_next, test_ai->ai_next);
-    EXPECT_EQ(strcmp(tests[i].canonical_ip_address.c_str(),
-                     test_ai->ai_canonname), 0);
+  ASSERT_EQ(kNumElements, list.size());
+  for (size_t i = 0; i < list.size(); ++i) {
+    EXPECT_EQ(AF_INET, list[i].GetFamily());
+    // Only check the first byte of the address.
+    EXPECT_EQ(i, list[i].address()[0]);
+    EXPECT_EQ(static_cast<int>(i << 2), list[i].port());
   }
-}
-
-TEST(AddressListTest, AddressFromAddrInfo) {
-  struct TestData {
-    std::string ip_address;
-    std::string canonical_ip_address;
-    bool is_ipv6;
-  } tests[] = {
-    { "127.0.00.1", "127.0.0.1", false },
-    { "192.168.1.1", "192.168.1.1", false },
-    { "::1", "::1", true },
-    { "2001:db8:0::42", "2001:db8::42", true },
-  };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
-    AddressList expected_list;
-    int rv = CreateAddressList(tests[i].canonical_ip_address, 80,
-                               &expected_list);
-    if (tests[i].is_ipv6 && rv != 0) {
-      LOG(WARNING) << "Unable to resolve ip literal '" << tests[i].ip_address
-                   << "' test skipped.";
-      continue;
-    }
-    ASSERT_EQ(0, rv);
-    const struct addrinfo* good_ai = expected_list.head();
 
-    AddressList test_list =
-        AddressList::CreateFromSockaddr(good_ai->ai_addr,
-                                        good_ai->ai_addrlen,
-                                        SOCK_STREAM,
-                                        IPPROTO_TCP);
-    const struct addrinfo* test_ai = test_list.head();
+  // Check if operator= works.
+  AddressList copy;
+  copy = list;
+  ASSERT_EQ(kNumElements, copy.size());
 
-    EXPECT_EQ(good_ai->ai_family, test_ai->ai_family);
-    EXPECT_EQ(good_ai->ai_addrlen, test_ai->ai_addrlen);
-    size_t sockaddr_size =
-        good_ai->ai_family == AF_INET ? sizeof(struct sockaddr_in) :
-        good_ai->ai_family == AF_INET6 ? sizeof(struct sockaddr_in6) : 0;
-    EXPECT_EQ(memcmp(good_ai->ai_addr, test_ai->ai_addr, sockaddr_size), 0);
-    EXPECT_EQ(good_ai->ai_next, test_ai->ai_next);
-  }
+  // Check if copy is independent.
+  copy[1] = IPEndPoint(copy[2].address(), 0xBEEF);
+  // Original should be unchanged.
+  EXPECT_EQ(1u, list[1].address()[0]);
+  EXPECT_EQ(1 << 2, list[1].port());
 }
 
 TEST(AddressListTest, CreateFromIPAddressList) {
@@ -318,25 +130,8 @@ TEST(AddressListTest, CreateFromIPAddressList) {
   AddressList test_list = AddressList::CreateFromIPAddressList(ip_list,
                                                                kCanonicalName);
   std::string canonical_name;
-  EXPECT_TRUE(test_list.GetCanonicalName(&canonical_name));
-  EXPECT_EQ(kCanonicalName, canonical_name);
-
-  // Make sure that CreateFromIPAddressList has created an addrinfo
-  // chain of exactly the same length as the |tests| with correct content.
-  const struct addrinfo* next_ai = test_list.head();
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    ASSERT_TRUE(next_ai != NULL);
-    EXPECT_EQ(tests[i].ai_family, next_ai->ai_family);
-    EXPECT_EQ(tests[i].ai_addrlen, static_cast<size_t>(next_ai->ai_addrlen));
-
-    char* ai_addr = reinterpret_cast<char*>(next_ai->ai_addr);
-    int rv = memcmp(tests[i].in_addr,
-                    ai_addr + tests[i].in_addr_offset,
-                    tests[i].in_addr_size);
-    EXPECT_EQ(0, rv);
-    next_ai = next_ai->ai_next;
-  }
-  EXPECT_EQ(NULL, next_ai);
+  EXPECT_EQ(kCanonicalName, test_list.canonical_name());
+  EXPECT_EQ(ARRAYSIZE_UNSAFE(tests), test_list.size());
 }
 
 }  // namespace
diff --git a/net/base/host_port_pair.cc b/net/base/host_port_pair.cc
index 773c7ee..6dbb855 100644
--- a/net/base/host_port_pair.cc
+++ b/net/base/host_port_pair.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -9,8 +9,7 @@
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "googleurl/src/gurl.h"
-#include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
+#include "net/base/ip_endpoint.h"
 
 namespace net {
 
@@ -24,9 +23,8 @@ HostPortPair HostPortPair::FromURL(const GURL& url) {
 }
 
 // static
-HostPortPair HostPortPair::FromAddrInfo(const struct addrinfo* ai) {
-  return HostPortPair(NetAddressToString(ai),
-                      GetPortFromSockaddr(ai->ai_addr, ai->ai_addrlen));
+HostPortPair HostPortPair::FromIPEndPoint(const IPEndPoint& ipe) {
+  return HostPortPair(ipe.ToStringWithoutPort(), ipe.port());
 }
 
 HostPortPair HostPortPair::FromString(const std::string& str) {
diff --git a/net/base/host_port_pair.h b/net/base/host_port_pair.h
index 1288a44..df22768 100644
--- a/net/base/host_port_pair.h
+++ b/net/base/host_port_pair.h
@@ -10,11 +10,12 @@
 #include "base/basictypes.h"
 #include "net/base/net_export.h"
 
-struct addrinfo;
 class GURL;
 
 namespace net {
 
+class IPEndPoint;
+
 class NET_EXPORT HostPortPair {
  public:
   HostPortPair();
@@ -24,8 +25,8 @@ class NET_EXPORT HostPortPair {
   // Creates a HostPortPair for the origin of |url|.
   static HostPortPair FromURL(const GURL& url);
 
-  // Creates a HostPortPair from an addrinfo struct.
-  static HostPortPair FromAddrInfo(const struct addrinfo* ai);
+  // Creates a HostPortPair from an IPEndPoint.
+  static HostPortPair FromIPEndPoint(const IPEndPoint& ipe);
 
   // Creates a HostPortPair from a string formatted in same manner as
   // ToString().
diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc
index 541246f..d2d9d5d 100644
--- a/net/base/host_resolver_impl.cc
+++ b/net/base/host_resolver_impl.cc
@@ -70,18 +70,6 @@ const unsigned kNegativeCacheEntryTTLSeconds = 0;
 // that limit this to 6, so we're temporarily holding it at that level.
 static const size_t kDefaultMaxProcTasks = 6u;
 
-// Helper to mutate the linked list contained by AddressList to the given
-// port. Note that in general this is dangerous since the AddressList's
-// data might be shared (and you should use AddressList::SetPort).
-//
-// However since we allocated the AddressList ourselves we can safely
-// do this optimization and avoid reallocating the list.
-void MutableSetPort(int port, AddressList* addr_list) {
-  struct addrinfo* mutable_head =
-      const_cast<struct addrinfo*>(addr_list->head());
-  SetPortForAllAddrinfos(mutable_head, port);
-}
-
 // We use a separate histogram name for each platform to facilitate the
 // display of error codes by their symbolic name (since each platform has
 // different mappings).
@@ -180,6 +168,13 @@ class CallSystemHostResolverProc : public HostResolverProc {
   virtual ~CallSystemHostResolverProc() {}
 };
 
+void EnsurePortOnAddressList(uint16 port, AddressList* list) {
+  DCHECK(list);
+  if (list->empty() || list->front().port() == port)
+    return;
+  SetPortOnAddressList(port, list);
+}
+
 // Extra parameters to attach to the NetLog when the resolve failed.
 class ProcTaskFailedParams : public NetLog::EventParameters {
  public:
@@ -534,8 +529,10 @@ class HostResolverImpl::Request {
 
   // Prepare final AddressList and call completion callback.
   void OnComplete(int error, const AddressList& addr_list) {
-    if (error == OK)
-      *addresses_ = CreateAddressListUsingPort(addr_list, info_.port());
+    if (error == OK) {
+      *addresses_ = addr_list;
+      EnsurePortOnAddressList(info_.port(), addresses_);
+    }
     CompletionCallback callback = callback_;
     MarkAsCanceled();
     callback.Run(error);
@@ -736,7 +733,7 @@ class HostResolverImpl::ProcTask
                         int error,
                         const int os_error) {
     DCHECK(origin_loop_->BelongsToCurrentThread());
-    DCHECK(error || results.head());
+    DCHECK(error || !results.empty());
 
     bool was_retry_attempt = attempt_number > 1;
 
@@ -1427,10 +1424,8 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job {
 
     DCHECK(!requests_.empty());
 
-    // We are the only consumer of |list|, so we can safely change the port
-    // without copy-on-write. This pays off, when job has only one request.
     if (net_error == OK)
-      MutableSetPort(requests_->front()->info().port(), &list);
+      SetPortOnAddressList(requests_->front()->info().port(), &list);
 
     if ((net_error != ERR_ABORTED) &&
         (net_error != ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)) {
@@ -1758,9 +1753,9 @@ bool HostResolverImpl::ResolveAsIP(const Key& key,
   if ((ip_number.size() == kIPv6AddressSize) && ipv6_disabled) {
     *net_error = ERR_NAME_NOT_RESOLVED;
   } else {
-    *addresses = AddressList::CreateFromIPAddressWithCname(
-        ip_number, info.port(),
-        (key.host_resolver_flags & HOST_RESOLVER_CANONNAME));
+    *addresses = AddressList::CreateFromIPAddress(ip_number, info.port());
+    if (key.host_resolver_flags & HOST_RESOLVER_CANONNAME)
+      addresses->SetDefaultCanonicalName();
   }
   return true;
 }
@@ -1780,8 +1775,10 @@ bool HostResolverImpl::ServeFromCache(const Key& key,
     return false;
 
   *net_error = cache_entry->error;
-  if (*net_error == OK)
-    *addresses = CreateAddressListUsingPort(cache_entry->addrlist, info.port());
+  if (*net_error == OK) {
+    *addresses = cache_entry->addrlist;
+    EnsurePortOnAddressList(info.port(), addresses);
+  }
   return true;
 }
 
diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc
index d82f6f7..fa88f78 100644
--- a/net/base/host_resolver_impl_unittest.cc
+++ b/net/base/host_resolver_impl_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "net/base/host_resolver_impl.h"
 
+#include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ -21,7 +22,6 @@
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -240,7 +240,7 @@ class Request {
     result_ = resolver_->Resolve(
         info_, &list_, base::Bind(&Request::OnComplete, base::Unretained(this)),
         &handle_, BoundNetLog());
-    if (list_.head())
+    if (!list_.empty())
       EXPECT_EQ(OK, result_);
     return result_;
   }
@@ -269,28 +269,14 @@ class Request {
     IPAddressNumber ip;
     bool rv = ParseIPLiteralToNumber(address, &ip);
     DCHECK(rv);
-    IPEndPoint target(ip, port);
-    for (const struct addrinfo* ai = list_.head();
-         ai != NULL;
-         ai = ai->ai_next) {
-      IPEndPoint ipe;
-      rv = ipe.FromSockAddr(ai->ai_addr, ai->ai_addrlen);
-      DCHECK(rv);
-      if (target == ipe)
-        return true;
-    }
-    return false;
+    return std::find(list_.begin(),
+                     list_.end(),
+                     IPEndPoint(ip, port)) != list_.end();
   }
 
   // Returns the number of addresses in |list_|.
   unsigned NumberOfAddresses() const {
-    unsigned count = 0;
-    for (const struct addrinfo* ai = list_.head();
-         ai != NULL;
-         ai = ai->ai_next) {
-      ++count;
-    }
-    return count;
+    return list_.size();
   }
 
   bool HasOneAddress(const std::string& address, int port) const {
@@ -323,10 +309,10 @@ class Request {
     EXPECT_NE(ERR_IO_PENDING, rv);
     result_ = rv;
     handle_ = NULL;
-    if (list_.head())
+    if (!list_.empty()) {
       EXPECT_EQ(OK, result_);
-    if (OK == rv)
-      EXPECT_EQ(info_.port(), list_.GetPort());
+      EXPECT_EQ(info_.port(), list_.front().port());
+    }
     if (handler_)
       handler_->Handle(this);
     if (quit_on_complete_) {
diff --git a/net/base/host_resolver_proc.cc b/net/base/host_resolver_proc.cc
index c2f2ddd..729079e 100644
--- a/net/base/host_resolver_proc.cc
+++ b/net/base/host_resolver_proc.cc
@@ -236,7 +236,8 @@ int SystemHostResolverProc(const std::string& host,
     return ERR_NAME_NOT_RESOLVED;
   }
 
-  *addrlist = AddressList::CreateByAdoptingFromSystem(ai);
+  *addrlist = AddressList::CreateFromAddrinfo(ai);
+  freeaddrinfo(ai);
   return OK;
 }
 
diff --git a/net/base/host_resolver_proc.h b/net/base/host_resolver_proc.h
index 0acb31e..7a54d01 100644
--- a/net/base/host_resolver_proc.h
+++ b/net/base/host_resolver_proc.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
diff --git a/net/base/ip_endpoint.cc b/net/base/ip_endpoint.cc
index e962d91..b8a161b 100644
--- a/net/base/ip_endpoint.cc
+++ b/net/base/ip_endpoint.cc
@@ -15,6 +15,12 @@
 
 namespace net {
 
+namespace {
+// By definition, socklen_t is large enough to hold both sizes.
+const socklen_t kSockaddrInSize = sizeof(struct sockaddr_in);
+const socklen_t kSockaddrIn6Size = sizeof(struct sockaddr_in6);
+}
+
 IPEndPoint::IPEndPoint() : port_(0) {}
 
 IPEndPoint::~IPEndPoint() {}
@@ -30,28 +36,25 @@ IPEndPoint::IPEndPoint(const IPEndPoint& endpoint) {
 
 int IPEndPoint::GetFamily() const {
   switch (address_.size()) {
-    case kIPv4AddressSize: {
+    case kIPv4AddressSize:
       return AF_INET;
-    }
-    case kIPv6AddressSize: {
+    case kIPv6AddressSize:
       return AF_INET6;
-    }
-    default: {
+    default:
       NOTREACHED() << "Bad IP address";
       return AF_UNSPEC;
-    }
   }
 }
 
 bool IPEndPoint::ToSockAddr(struct sockaddr* address,
-                            size_t* address_length) const {
+                            socklen_t* address_length) const {
   DCHECK(address);
   DCHECK(address_length);
   switch (address_.size()) {
     case kIPv4AddressSize: {
-      if (*address_length < sizeof(struct sockaddr_in))
+      if (*address_length < kSockaddrInSize)
         return false;
-      *address_length = sizeof(struct sockaddr_in);
+      *address_length = kSockaddrInSize;
       struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(address);
       memset(addr, 0, sizeof(struct sockaddr_in));
       addr->sin_family = AF_INET;
@@ -60,9 +63,9 @@ bool IPEndPoint::ToSockAddr(struct sockaddr* address,
       break;
     }
     case kIPv6AddressSize: {
-      if (*address_length < sizeof(struct sockaddr_in6))
+      if (*address_length < kSockaddrIn6Size)
         return false;
-      *address_length = sizeof(struct sockaddr_in6);
+      *address_length = kSockaddrIn6Size;
       struct sockaddr_in6* addr6 =
           reinterpret_cast<struct sockaddr_in6*>(address);
       memset(addr6, 0, sizeof(struct sockaddr_in6));
@@ -71,20 +74,18 @@ bool IPEndPoint::ToSockAddr(struct sockaddr* address,
       memcpy(&addr6->sin6_addr, &address_[0], kIPv6AddressSize);
       break;
     }
-    default: {
-      NOTREACHED() << "Bad IP address";
-      break;
-    }
+    default:
+      return false;
   }
   return true;
 }
 
 bool IPEndPoint::FromSockAddr(const struct sockaddr* address,
-                              size_t address_length) {
+                              socklen_t address_length) {
   DCHECK(address);
   switch (address->sa_family) {
     case AF_INET: {
-      if (address_length < sizeof(struct sockaddr_in))
+      if (address_length < kSockaddrInSize)
         return false;
       const struct sockaddr_in* addr =
           reinterpret_cast<const struct sockaddr_in*>(address);
@@ -94,7 +95,7 @@ bool IPEndPoint::FromSockAddr(const struct sockaddr* address,
       break;
     }
     case AF_INET6: {
-      if (address_length < sizeof(struct sockaddr_in6))
+      if (address_length < kSockaddrIn6Size)
         return false;
       const struct sockaddr_in6* addr =
           reinterpret_cast<const struct sockaddr_in6*>(address);
@@ -103,22 +104,28 @@ bool IPEndPoint::FromSockAddr(const struct sockaddr* address,
       address_.assign(&bytes[0], &bytes[kIPv6AddressSize]);
       break;
     }
-    default: {
-      NOTREACHED() << "Bad IP address";
-      break;
-    }
+    default:
+      return false;
   }
   return true;
 }
 
 std::string IPEndPoint::ToString() const {
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (!ToSockAddr(addr, &addr_len)) {
-    return "";
+  SockaddrStorage storage;
+  if (!ToSockAddr(storage.addr, &storage.addr_len)) {
+    return std::string();
+  }
+  // TODO(szym): Don't use getnameinfo. http://crbug.com/126212
+  return NetAddressToStringWithPort(storage.addr, storage.addr_len);
+}
+
+std::string IPEndPoint::ToStringWithoutPort() const {
+  SockaddrStorage storage;
+  if (!ToSockAddr(storage.addr, &storage.addr_len)) {
+    return std::string();
   }
-  return NetAddressToStringWithPort(addr, addr_len);
+  // TODO(szym): Don't use getnameinfo. http://crbug.com/126212
+  return NetAddressToString(storage.addr, storage.addr_len);
 }
 
 bool IPEndPoint::operator<(const IPEndPoint& that) const {
diff --git a/net/base/ip_endpoint.h b/net/base/ip_endpoint.h
index 1c8c907..7d59e0d 100644
--- a/net/base/ip_endpoint.h
+++ b/net/base/ip_endpoint.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -6,7 +6,10 @@
 #define NET_BASE_IP_ENDPOINT_H_
 #pragma once
 
+#include <string>
+
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "net/base/net_export.h"
 #include "net/base/net_util.h"
 
@@ -37,19 +40,24 @@ class NET_EXPORT IPEndPoint {
   //    size of data in |address| available.  On output, it is the size of
   //    the address that was copied into |address|.
   // Returns true on success, false on failure.
-  bool ToSockAddr(struct sockaddr* address, size_t* address_length) const;
+  bool ToSockAddr(struct sockaddr* address, socklen_t* address_length) const
+      WARN_UNUSED_RESULT;
 
   // Convert from a sockaddr struct.
   // |address| is the address.
   // |address_length| is the length of |address|.
   // Returns true on success, false on failure.
-  bool FromSockAddr(const struct sockaddr* address, size_t address_length);
+  bool FromSockAddr(const struct sockaddr* address, socklen_t address_length)
+      WARN_UNUSED_RESULT;
 
   // Returns value as a string (e.g. "127.0.0.1:80"). Returns empty
   // string if the address is invalid, and cannot not be converted to a
   // string.
   std::string ToString() const;
 
+  // As above, but without port.
+  std::string ToStringWithoutPort() const;
+
   bool operator<(const IPEndPoint& that) const;
   bool operator==(const IPEndPoint& that) const;
 
diff --git a/net/base/ip_endpoint_unittest.cc b/net/base/ip_endpoint_unittest.cc
index b551bb4..f93a08f 100644
--- a/net/base/ip_endpoint_unittest.cc
+++ b/net/base/ip_endpoint_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -78,20 +78,19 @@ TEST_F(IPEndPointTest, ToFromSockAddr) {
     IPEndPoint ip_endpoint(tests[index].ip_address, index);
 
     // Convert to a sockaddr.
-    struct sockaddr_storage addr;
-    size_t addr_len = sizeof(addr);
-    struct sockaddr* sockaddr = reinterpret_cast<struct sockaddr*>(&addr);
-    EXPECT_TRUE(ip_endpoint.ToSockAddr(sockaddr, &addr_len));
+    SockaddrStorage storage;
+    EXPECT_TRUE(ip_endpoint.ToSockAddr(storage.addr, &storage.addr_len));
 
     // Basic verification.
-    size_t expected_size = tests[index].ipv6 ?
+    socklen_t expected_size = tests[index].ipv6 ?
         sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
-    EXPECT_EQ(expected_size, addr_len);
-    EXPECT_EQ(ip_endpoint.port(), GetPortFromSockaddr(sockaddr, addr_len));
+    EXPECT_EQ(expected_size, storage.addr_len);
+    EXPECT_EQ(ip_endpoint.port(), GetPortFromSockaddr(storage.addr,
+                                                      storage.addr_len));
 
     // And convert back to an IPEndPoint.
     IPEndPoint ip_endpoint2;
-    EXPECT_TRUE(ip_endpoint2.FromSockAddr(sockaddr, addr_len));
+    EXPECT_TRUE(ip_endpoint2.FromSockAddr(storage.addr, storage.addr_len));
     EXPECT_EQ(ip_endpoint.port(), ip_endpoint2.port());
     EXPECT_EQ(ip_endpoint.address(), ip_endpoint2.address());
   }
@@ -101,10 +100,9 @@ TEST_F(IPEndPointTest, ToSockAddrBufTooSmall) {
   for (int index = 0; index < test_count; ++index) {
     IPEndPoint ip_endpoint(tests[index].ip_address, index);
 
-    struct sockaddr_storage addr;
-    size_t addr_len = index;  // size is too small!
-    struct sockaddr* sockaddr = reinterpret_cast<struct sockaddr*>(&addr);
-    EXPECT_FALSE(ip_endpoint.ToSockAddr(sockaddr, &addr_len));
+    SockaddrStorage storage;
+    storage.addr_len = index;  // size is too small!
+    EXPECT_FALSE(ip_endpoint.ToSockAddr(storage.addr, &storage.addr_len));
   }
 }
 
diff --git a/net/base/mapped_host_resolver_unittest.cc b/net/base/mapped_host_resolver_unittest.cc
index 7e691be..5ea95c0 100644
--- a/net/base/mapped_host_resolver_unittest.cc
+++ b/net/base/mapped_host_resolver_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -16,6 +16,12 @@ namespace net {
 
 namespace {
 
+std::string FirstAddress(const AddressList& address_list) {
+  if (address_list.empty())
+    return "";
+  return address_list.front().ToString();
+}
+
 TEST(MappedHostResolverTest, Inclusion) {
   // Create a mock host resolver, with specific hostname to IP mappings.
   MockHostResolver* resolver_impl(new MockHostResolver());
@@ -53,8 +59,7 @@ TEST(MappedHostResolverTest, Inclusion) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
-  EXPECT_EQ("192.168.1.5", NetAddressToString(address_list.head()));
-  EXPECT_EQ(80, address_list.GetPort());
+  EXPECT_EQ("192.168.1.5:80", FirstAddress(address_list));
 
   // Try resolving "foo.com:77". This will NOT be remapped, so result
   // is "foo.com:77".
@@ -64,8 +69,7 @@ TEST(MappedHostResolverTest, Inclusion) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
-  EXPECT_EQ("192.168.1.8", NetAddressToString(address_list.head()));
-  EXPECT_EQ(77, address_list.GetPort());
+  EXPECT_EQ("192.168.1.8:77", FirstAddress(address_list));
 
   // Remap "*.org" to "proxy:99".
   EXPECT_TRUE(resolver->AddRuleFromString("Map *.org proxy:99"));
@@ -78,8 +82,7 @@ TEST(MappedHostResolverTest, Inclusion) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
-  EXPECT_EQ("192.168.1.11", NetAddressToString(address_list.head()));
-  EXPECT_EQ(99, address_list.GetPort());
+  EXPECT_EQ("192.168.1.11:99", FirstAddress(address_list));
 }
 
 // Tests that exclusions are respected.
@@ -111,8 +114,7 @@ TEST(MappedHostResolverTest, Exclusion) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
-  EXPECT_EQ("192.168.1.3", NetAddressToString(address_list.head()));
-  EXPECT_EQ(80, address_list.GetPort());
+  EXPECT_EQ("192.168.1.3:80", FirstAddress(address_list));
 
   // Try resolving "chrome.com:80". Should be remapped to "baz:80".
   rv = resolver->Resolve(HostResolver::RequestInfo(
@@ -122,8 +124,7 @@ TEST(MappedHostResolverTest, Exclusion) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
-  EXPECT_EQ("192.168.1.5", NetAddressToString(address_list.head()));
-  EXPECT_EQ(80, address_list.GetPort());
+  EXPECT_EQ("192.168.1.5:80", FirstAddress(address_list));
 }
 
 TEST(MappedHostResolverTest, SetRulesFromString) {
@@ -151,8 +152,7 @@ TEST(MappedHostResolverTest, SetRulesFromString) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
-  EXPECT_EQ("192.168.1.7", NetAddressToString(address_list.head()));
-  EXPECT_EQ(80, address_list.GetPort());
+  EXPECT_EQ("192.168.1.7:80", FirstAddress(address_list));
 
   // Try resolving "chrome.net:80". Should be remapped to "bar:60".
   rv = resolver->Resolve(HostResolver::RequestInfo(
@@ -162,8 +162,7 @@ TEST(MappedHostResolverTest, SetRulesFromString) {
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
-  EXPECT_EQ("192.168.1.9", NetAddressToString(address_list.head()));
-  EXPECT_EQ(60, address_list.GetPort());
+  EXPECT_EQ("192.168.1.9:60", FirstAddress(address_list));
 }
 
 // Parsing bad rules should silently discard the rule (and never crash).
diff --git a/net/base/mock_host_resolver.cc b/net/base/mock_host_resolver.cc
index 0394451..156ae8c 100644
--- a/net/base/mock_host_resolver.cc
+++ b/net/base/mock_host_resolver.cc
@@ -17,7 +17,6 @@
 #include "net/base/host_cache.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 
 namespace net {
@@ -37,21 +36,14 @@ int ParseAddressList(const std::string& host_list,
   *addrlist = AddressList();
   std::vector<std::string> addresses;
   base::SplitString(host_list, ',', &addresses);
+  addrlist->set_canonical_name(canonical_name);
   for (size_t index = 0; index < addresses.size(); ++index) {
     IPAddressNumber ip_number;
     if (!ParseIPLiteralToNumber(addresses[index], &ip_number)) {
       LOG(WARNING) << "Not a supported IP literal: " << addresses[index];
       return ERR_UNEXPECTED;
     }
-
-    AddressList result = AddressList::CreateFromIPAddress(ip_number, -1);
-    struct addrinfo* ai = const_cast<struct addrinfo*>(result.head());
-    if (index == 0)
-      ai->ai_canonname = base::strdup(canonical_name.c_str());
-    if (!addrlist->head())
-      *addrlist = AddressList::CreateByCopyingFirstAddress(result.head());
-    else
-      addrlist->Append(result.head());
+    addrlist->push_back(IPEndPoint(ip_number, -1));
   }
   return OK;
 }
@@ -137,8 +129,9 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache(const RequestInfo& info,
                                                       AddressList* addresses) {
   IPAddressNumber ip;
   if (ParseIPLiteralToNumber(info.hostname(), &ip)) {
-    *addresses = AddressList::CreateFromIPAddressWithCname(
-        ip, info.port(), info.host_resolver_flags() & HOST_RESOLVER_CANONNAME);
+    *addresses = AddressList::CreateFromIPAddress(ip, info.port());
+    if (info.host_resolver_flags() & HOST_RESOLVER_CANONNAME)
+      addresses->SetDefaultCanonicalName();
     return OK;
   }
   int rv = ERR_DNS_CACHE_MISS;
@@ -149,8 +142,10 @@ int MockHostResolverBase::ResolveFromIPLiteralOrCache(const RequestInfo& info,
     const HostCache::Entry* entry = cache_->Lookup(key, base::TimeTicks::Now());
     if (entry) {
       rv = entry->error;
-      if (rv == OK)
-        *addresses = CreateAddressListUsingPort(entry->addrlist, info.port());
+      if (rv == OK) {
+        *addresses = entry->addrlist;
+        SetPortOnAddressList(info.port(), addresses);
+      }
     }
   }
   return rv;
@@ -175,8 +170,10 @@ int MockHostResolverBase::ResolveProc(size_t id,
       ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
     cache_->Set(key, rv, addr, base::TimeTicks::Now(), ttl);
   }
-  if (rv == OK)
-    *addresses = CreateAddressListUsingPort(addr, info.port());
+  if (rv == OK) {
+    *addresses = addr;
+    SetPortOnAddressList(info.port(), addresses);
+  }
   return rv;
 }
 
diff --git a/net/base/net_util.cc b/net/base/net_util.cc
index 6060fd8..b9e7ad1 100644
--- a/net/base/net_util.cc
+++ b/net/base/net_util.cc
@@ -2265,73 +2265,6 @@ bool IPNumberMatchesPrefix(const IPAddressNumber& ip_number,
   return true;
 }
 
-struct addrinfo* CreateCopyOfAddrinfo(const struct addrinfo* info,
-                                      bool recursive) {
-  DCHECK(info);
-  struct addrinfo* copy = new addrinfo;
-
-  // Copy all the fields (some of these are pointers, we will fix that next).
-  memcpy(copy, info, sizeof(addrinfo));
-
-  // ai_canonname is a NULL-terminated string.
-  if (info->ai_canonname) {
-    copy->ai_canonname = base::strdup(info->ai_canonname);
-  }
-
-  // ai_addr is a buffer of length ai_addrlen.
-  if (info->ai_addr) {
-    copy->ai_addr = reinterpret_cast<sockaddr *>(new char[info->ai_addrlen]);
-    memcpy(copy->ai_addr, info->ai_addr, info->ai_addrlen);
-  }
-
-  // Recursive copy.
-  if (recursive && info->ai_next)
-    copy->ai_next = CreateCopyOfAddrinfo(info->ai_next, recursive);
-  else
-    copy->ai_next = NULL;
-
-  return copy;
-}
-
-void FreeCopyOfAddrinfo(struct addrinfo* info) {
-  DCHECK(info);
-  if (info->ai_canonname)
-    free(info->ai_canonname);  // Allocated by strdup.
-
-  if (info->ai_addr)
-    delete [] reinterpret_cast<char*>(info->ai_addr);
-
-  struct addrinfo* next = info->ai_next;
-
-  delete info;
-
-  // Recursive free.
-  if (next)
-    FreeCopyOfAddrinfo(next);
-}
-
-// Returns the port field of the sockaddr in |info|.
-uint16* GetPortFieldFromAddrinfo(struct addrinfo* info) {
-  const struct addrinfo* const_info = info;
-  const uint16* port_field = GetPortFieldFromAddrinfo(const_info);
-  return const_cast<uint16*>(port_field);
-}
-
-const uint16* GetPortFieldFromAddrinfo(const struct addrinfo* info) {
-  DCHECK(info);
-  const struct sockaddr* address = info->ai_addr;
-  DCHECK(address);
-  DCHECK_EQ(info->ai_family, address->sa_family);
-  return GetPortFieldFromSockaddr(address, info->ai_addrlen);
-}
-
-uint16 GetPortFromAddrinfo(const struct addrinfo* info) {
-  const uint16* port_field = GetPortFieldFromAddrinfo(info);
-  if (!port_field)
-    return -1;
-  return base::NetToHost16(*port_field);
-}
-
 const uint16* GetPortFieldFromSockaddr(const struct sockaddr* address,
                                        socklen_t address_len) {
   if (address->sa_family == AF_INET) {
@@ -2357,16 +2290,6 @@ int GetPortFromSockaddr(const struct sockaddr* address, socklen_t address_len) {
   return base::NetToHost16(*port_field);
 }
 
-// Assign |port| to each address in the linked list starting from |head|.
-void SetPortForAllAddrinfos(struct addrinfo* head, uint16 port) {
-  DCHECK(head);
-  for (struct addrinfo* ai = head; ai; ai = ai->ai_next) {
-    uint16* port_field = GetPortFieldFromAddrinfo(ai);
-    if (port_field)
-      *port_field = base::HostToNet16(port);
-  }
-}
-
 bool IsLocalhost(const std::string& host) {
   if (host == "localhost" ||
       host == "localhost.localdomain" ||
diff --git a/net/base/net_util.h b/net/base/net_util.h
index 757086a..f63f860 100644
--- a/net/base/net_util.h
+++ b/net/base/net_util.h
@@ -26,7 +26,6 @@
 #include "net/base/escape.h"
 #include "net/base/net_export.h"
 
-struct addrinfo;
 class FilePath;
 class GURL;
 
@@ -100,17 +99,23 @@ NET_EXPORT std::string GetHostAndPort(const GURL& url);
 // if it is the default for the URL's scheme.
 NET_EXPORT_PRIVATE std::string GetHostAndOptionalPort(const GURL& url);
 
+// Convenience struct for when you need a |struct sockaddr|.
+struct SockaddrStorage {
+  SockaddrStorage() : addr_len(sizeof(addr_storage)),
+                      addr(reinterpret_cast<struct sockaddr*>(&addr_storage)) {}
+  struct sockaddr_storage addr_storage;
+  socklen_t addr_len;
+  struct sockaddr* const addr;
+};
+
 // Returns the string representation of an address, like "192.168.0.1".
 // Returns empty string on failure.
-NET_EXPORT std::string NetAddressToString(const struct addrinfo* net_address);
 NET_EXPORT std::string NetAddressToString(const struct sockaddr* net_address,
                                           socklen_t address_len);
 
 // Same as NetAddressToString, but additionally includes the port number. For
 // example: "192.168.0.1:99" or "[::1]:80".
 NET_EXPORT std::string NetAddressToStringWithPort(
-    const struct addrinfo* net_address);
-NET_EXPORT std::string NetAddressToStringWithPort(
     const struct sockaddr* net_address,
     socklen_t address_len);
 
@@ -416,34 +421,13 @@ NET_EXPORT_PRIVATE bool IPNumberMatchesPrefix(const IPAddressNumber& ip_number,
                                               const IPAddressNumber& ip_prefix,
                                               size_t prefix_length_in_bits);
 
-// Makes a copy of |info|. The dynamically-allocated parts are copied as well.
-// If |recursive| is true, chained entries via ai_next are copied too.
-// The copy returned by this function should be freed using
-// FreeCopyOfAddrinfo(), and NOT freeaddrinfo().
-struct addrinfo* CreateCopyOfAddrinfo(const struct addrinfo* info,
-                                      bool recursive);
-
-// Frees an addrinfo that was created by CreateCopyOfAddrinfo().
-void FreeCopyOfAddrinfo(struct addrinfo* info);
-
-// Returns the port field of the sockaddr in |info|.
-const uint16* GetPortFieldFromAddrinfo(const struct addrinfo* info);
-uint16* GetPortFieldFromAddrinfo(struct addrinfo* info);
-
-// Returns the value of |info's| port (in host byte ordering).
-uint16 GetPortFromAddrinfo(const struct addrinfo* info);
-
-// Same except for struct sockaddr.
+// Retuns the port field of the |sockaddr|.
 const uint16* GetPortFieldFromSockaddr(const struct sockaddr* address,
                                        socklen_t address_len);
+// Returns the value of port in |sockaddr| (in host byte ordering).
 NET_EXPORT_PRIVATE int GetPortFromSockaddr(const struct sockaddr* address,
                                            socklen_t address_len);
 
-// Sets every addrinfo in the linked list |head| as having a port field of
-// |port|.
-NET_EXPORT_PRIVATE void SetPortForAllAddrinfos(struct addrinfo* head,
-                                               uint16 port);
-
 // Returns true if |host| is one of the names (e.g. "localhost") or IP
 // addresses (IPv4 127.0.0.0/8 or IPv6 ::1) that indicate a loopback.
 //
diff --git a/net/base/net_util_unittest.cc b/net/base/net_util_unittest.cc
index caf64b5..6650863 100644
--- a/net/base/net_util_unittest.cc
+++ b/net/base/net_util_unittest.cc
@@ -19,7 +19,6 @@
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
-#include "net/base/sys_addrinfo.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -405,52 +404,26 @@ struct UrlTestData {
   size_t prefix_len;
 };
 
-// Returns an addrinfo for the given 32-bit address (IPv4.)
-// The result lives in static storage, so don't delete it.
+// Fills in sockaddr for the given 32-bit address (IPv4.)
 // |bytes| should be an array of length 4.
-const struct addrinfo* GetIPv4Address(const uint8* bytes, int port) {
-  static struct addrinfo static_ai;
-  static struct sockaddr_in static_addr4;
-
-  struct addrinfo* ai = &static_ai;
-  ai->ai_socktype = SOCK_STREAM;
-  memset(ai, 0, sizeof(static_ai));
-
-  ai->ai_family = AF_INET;
-  ai->ai_addrlen = sizeof(static_addr4);
-
-  struct sockaddr_in* addr4 = &static_addr4;
-  memset(addr4, 0, sizeof(static_addr4));
+void MakeIPv4Address(const uint8* bytes, int port, SockaddrStorage* storage) {
+  memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
+  storage->addr_len = sizeof(struct sockaddr_in);
+  struct sockaddr_in* addr4 = reinterpret_cast<sockaddr_in*>(storage->addr);
   addr4->sin_port = base::HostToNet16(port);
-  addr4->sin_family = ai->ai_family;
+  addr4->sin_family = AF_INET;
   memcpy(&addr4->sin_addr, bytes, 4);
-
-  ai->ai_addr = (sockaddr*)addr4;
-  return ai;
 }
 
-// Returns a addrinfo for the given 128-bit address (IPv6.)
-// The result lives in static storage, so don't delete it.
+// Fills in sockaddr for the given 128-bit address (IPv6.)
 // |bytes| should be an array of length 16.
-const struct addrinfo* GetIPv6Address(const uint8* bytes, int port) {
-  static struct addrinfo static_ai;
-  static struct sockaddr_in6 static_addr6;
-
-  struct addrinfo* ai = &static_ai;
-  ai->ai_socktype = SOCK_STREAM;
-  memset(ai, 0, sizeof(static_ai));
-
-  ai->ai_family = AF_INET6;
-  ai->ai_addrlen = sizeof(static_addr6);
-
-  struct sockaddr_in6* addr6 = &static_addr6;
-  memset(addr6, 0, sizeof(static_addr6));
+void MakeIPv6Address(const uint8* bytes, int port, SockaddrStorage* storage) {
+  memset(&storage->addr_storage, 0, sizeof(storage->addr_storage));
+  storage->addr_len = sizeof(struct sockaddr_in6);
+  struct sockaddr_in6* addr6 = reinterpret_cast<sockaddr_in6*>(storage->addr);
   addr6->sin6_port = base::HostToNet16(port);
-  addr6->sin6_family = ai->ai_family;
+  addr6->sin6_family = AF_INET6;
   memcpy(&addr6->sin6_addr, bytes, 16);
-
-  ai->ai_addr = (sockaddr*)addr6;
-  return ai;
 }
 
 // A helper for IDN*{Fast,Slow}.
@@ -2270,8 +2243,9 @@ TEST(NetUtilTest, NetAddressToString_IPv4) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    const addrinfo* ai = GetIPv4Address(tests[i].addr, 80);
-    std::string result = NetAddressToString(ai);
+    SockaddrStorage storage;
+    MakeIPv4Address(tests[i].addr, 80, &storage);
+    std::string result = NetAddressToString(storage.addr, storage.addr_len);
     EXPECT_EQ(std::string(tests[i].result), result);
   }
 }
@@ -2287,8 +2261,9 @@ TEST(NetUtilTest, NetAddressToString_IPv6) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
-    const addrinfo* ai = GetIPv6Address(tests[i].addr, 80);
-    std::string result = NetAddressToString(ai);
+    SockaddrStorage storage;
+    MakeIPv6Address(tests[i].addr, 80, &storage);
+    std::string result = NetAddressToString(storage.addr, storage.addr_len);
     // Allow NetAddressToString() to fail, in case the system doesn't
     // support IPv6.
     if (!result.empty())
@@ -2298,8 +2273,10 @@ TEST(NetUtilTest, NetAddressToString_IPv6) {
 
 TEST(NetUtilTest, NetAddressToStringWithPort_IPv4) {
   uint8 addr[] = {127, 0, 0, 1};
-  const addrinfo* ai = GetIPv4Address(addr, 166);
-  std::string result = NetAddressToStringWithPort(ai);
+  SockaddrStorage storage;
+  MakeIPv4Address(addr, 166, &storage);
+  std::string result = NetAddressToStringWithPort(storage.addr,
+                                                  storage.addr_len);
   EXPECT_EQ("127.0.0.1:166", result);
 }
 
@@ -2308,8 +2285,10 @@ TEST(NetUtilTest, NetAddressToStringWithPort_IPv6) {
       0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
       0x98, 0x76, 0x54, 0x32, 0x10
   };
-  const addrinfo* ai = GetIPv6Address(addr, 361);
-  std::string result = NetAddressToStringWithPort(ai);
+  SockaddrStorage storage;
+  MakeIPv6Address(addr, 361, &storage);
+  std::string result = NetAddressToStringWithPort(storage.addr,
+                                                  storage.addr_len);
 
   // May fail on systems that don't support IPv6.
   if (!result.empty())
diff --git a/net/base/single_request_host_resolver_unittest.cc b/net/base/single_request_host_resolver_unittest.cc
index 295a318..b23a722 100644
--- a/net/base/single_request_host_resolver_unittest.cc
+++ b/net/base/single_request_host_resolver_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -82,7 +82,8 @@ TEST(SingleRequestHostResolverTest, NormalResolve) {
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Verify that the result is what we specified in the MockHostResolver.
-  EXPECT_EQ("199.188.1.166", NetAddressToString(addrlist.head()));
+  ASSERT_FALSE(addrlist.empty());
+  EXPECT_EQ("199.188.1.166", addrlist.front().ToStringWithoutPort());
 }
 
 // Test that the Cancel() method cancels any outstanding request.
diff --git a/net/curvecp/client_packetizer.cc b/net/curvecp/client_packetizer.cc
index 4b75c6e..712a4e2 100644
--- a/net/curvecp/client_packetizer.cc
+++ b/net/curvecp/client_packetizer.cc
@@ -7,7 +7,6 @@
 #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"
 
@@ -33,7 +32,7 @@ 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(
@@ -290,25 +289,17 @@ void ClientPacketizer::DoCallback(int 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;
diff --git a/net/curvecp/client_packetizer.h b/net/curvecp/client_packetizer.h
index 1214463..691276f 100644
--- a/net/curvecp/client_packetizer.h
+++ b/net/curvecp/client_packetizer.h
@@ -85,7 +85,7 @@ class ClientPacketizer : public Packetizer {
   Packetizer::Listener* listener_;
   CompletionCallback user_callback_;
   AddressList addresses_;
-  const struct addrinfo* current_address_;
+  int current_address_index_;
   int hello_attempts_;  // Number of attempts to send a Hello Packet.
   bool initiate_sent_;  // Indicates whether the Initiate Packet was sent.
 
diff --git a/net/curvecp/curvecp_client_socket.cc b/net/curvecp/curvecp_client_socket.cc
index 30bb378..4aaea1b 100644
--- a/net/curvecp/curvecp_client_socket.cc
+++ b/net/curvecp/curvecp_client_socket.cc
@@ -4,7 +4,6 @@
 
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/curvecp/curvecp_client_socket.h"
 #include "net/curvecp/messenger.h"
 
@@ -47,17 +46,7 @@ int CurveCPClientSocket::GetPeerAddress(AddressList* address) const {
   int rv = packetizer_.GetPeerAddress(&endpoint);
   if (rv < 0)
     return rv;
-  struct sockaddr_storage sockaddr;
-  size_t sockaddr_length = sizeof(sockaddr);
-  bool success = endpoint.ToSockAddr(
-      reinterpret_cast<struct sockaddr*>(&sockaddr), &sockaddr_length);
-  if (!success)
-    return ERR_FAILED;
-  struct addrinfo ai;
-  memset(&ai, 0, sizeof(ai));
-  memcpy(&ai.ai_addr, &sockaddr, sockaddr_length);
-  ai.ai_addrlen = sockaddr_length;
-  *address = AddressList::CreateByCopying(&ai);
+  *address = AddressList(endpoint);
   return OK;
 }
 
diff --git a/net/curvecp/curvecp_server_socket.cc b/net/curvecp/curvecp_server_socket.cc
index d5d5b68..5951c19 100644
--- a/net/curvecp/curvecp_server_socket.cc
+++ b/net/curvecp/curvecp_server_socket.cc
@@ -1,10 +1,9 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/curvecp/curvecp_server_socket.h"
 #include "net/curvecp/messenger.h"
 
diff --git a/net/dns/dns_config_service.h b/net/dns/dns_config_service.h
index 8e7597d..6b3e9f3 100644
--- a/net/dns/dns_config_service.h
+++ b/net/dns/dns_config_service.h
@@ -15,6 +15,9 @@
 #include "base/threading/non_thread_safe.h"
 #include "base/time.h"
 #include "base/timer.h"
+// Needed on shared build with MSVS2010 to avoid multiple definitions of
+// std::vector<IPEndPoint>.
+#include "net/base/address_list.h"
 #include "net/base/ip_endpoint.h"  // win requires size of IPEndPoint
 #include "net/base/net_export.h"
 #include "net/dns/dns_hosts.h"
diff --git a/net/dns/dns_config_service_win_unittest.cc b/net/dns/dns_config_service_win_unittest.cc
index 796c942..63e4268 100644
--- a/net/dns/dns_config_service_win_unittest.cc
+++ b/net/dns/dns_config_service_win_unittest.cc
@@ -104,7 +104,7 @@ scoped_ptr_malloc<IP_ADAPTER_ADDRESSES> CreateAdapterAddresses(
       IPEndPoint ipe(ip, info.ports[j]);
       address->Address.lpSockaddr =
           reinterpret_cast<LPSOCKADDR>(storage + num_addresses);
-      size_t length = sizeof(struct sockaddr_storage);
+      socklen_t length = sizeof(struct sockaddr_storage);
       CHECK(ipe.ToSockAddr(address->Address.lpSockaddr, &length));
       address->Address.iSockaddrLength = static_cast<int>(length);
     }
diff --git a/net/dns/dns_response_unittest.cc b/net/dns/dns_response_unittest.cc
index 1861f10..bb053bc 100644
--- a/net/dns/dns_response_unittest.cc
+++ b/net/dns/dns_response_unittest.cc
@@ -8,7 +8,6 @@
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_query.h"
 #include "net/dns/dns_test_util.h"
@@ -248,21 +247,11 @@ TEST(DnsResponseTest, InitParse) {
 
 void VerifyAddressList(const std::vector<const char*>& ip_addresses,
                        const AddressList& addrlist) {
-  ASSERT_GT(ip_addresses.size(), 0u);
-  ASSERT_NE(static_cast<addrinfo*>(NULL), addrlist.head());
-
-  IPAddressNumber ip_number;
-  const struct addrinfo* ainfo = addrlist.head();
-  for (std::vector<const char*>::const_iterator i = ip_addresses.begin();
-       i != ip_addresses.end(); ++i, ainfo = ainfo->ai_next) {
-    ASSERT_NE(static_cast<addrinfo*>(NULL), ainfo);
-    EXPECT_EQ(sizeof(struct sockaddr_in),
-              static_cast<size_t>(ainfo->ai_addrlen));
-
-    const struct sockaddr* sa = ainfo->ai_addr;
-    EXPECT_STREQ(*i, NetAddressToString(sa, ainfo->ai_addrlen).c_str());
+  ASSERT_EQ(ip_addresses.size(), addrlist.size());
+
+  for (size_t i = 0; i < addrlist.size(); ++i) {
+    EXPECT_EQ(ip_addresses[i], addrlist[i].ToStringWithoutPort());
   }
-  ASSERT_EQ(static_cast<addrinfo*>(NULL), ainfo);
 }
 
 TEST(DnsResponseTest, ParseToAddressList) {
@@ -316,9 +305,7 @@ TEST(DnsResponseTest, ParseToAddressList) {
         t.expected_addresses,
         t.expected_addresses + t.num_expected_addresses);
     VerifyAddressList(expected_addresses, addr_list);
-    std::string cname;
-    ASSERT_TRUE(addr_list.GetCanonicalName(&cname));
-    EXPECT_EQ(t.expected_cname, cname);
+    EXPECT_EQ(t.expected_cname, addr_list.canonical_name());
     EXPECT_EQ(base::TimeDelta::FromSeconds(t.expected_ttl_sec), ttl);
   }
 }
diff --git a/net/dns/dns_transaction_unittest.cc b/net/dns/dns_transaction_unittest.cc
index 33ac404..4192ca8 100644
--- a/net/dns/dns_transaction_unittest.cc
+++ b/net/dns/dns_transaction_unittest.cc
@@ -13,7 +13,6 @@
 #include "net/base/big_endian.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_log.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_query.h"
 #include "net/dns/dns_response.h"
diff --git a/net/ftp/ftp_network_transaction.cc b/net/ftp/ftp_network_transaction.cc
index 322764f..a391cad 100644
--- a/net/ftp/ftp_network_transaction.cc
+++ b/net/ftp/ftp_network_transaction.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -654,7 +654,7 @@ int FtpNetworkTransaction::DoCtrlConnectComplete(int result) {
     AddressList address;
     result = ctrl_socket_->GetPeerAddress(&address);
     if (result == OK) {
-      response_.socket_address = HostPortPair::FromAddrInfo(address.head());
+      response_.socket_address = HostPortPair::FromIPEndPoint(address.front());
       next_state_ = STATE_CTRL_READ;
     }
   }
@@ -1194,7 +1194,8 @@ int FtpNetworkTransaction::DoDataConnect() {
   int rv = ctrl_socket_->GetPeerAddress(&data_address);
   if (rv != OK)
     return Stop(rv);
-  data_address.SetPort(data_connection_port_);
+  data_address = AddressList::CreateFromIPAddress(
+      data_address.front().address(), data_connection_port_);
   data_socket_.reset(socket_factory_->CreateTransportClientSocket(
         data_address, net_log_.net_log(), net_log_.source()));
   return data_socket_->Connect(io_callback_);
diff --git a/net/ftp/ftp_network_transaction_unittest.cc b/net/ftp/ftp_network_transaction_unittest.cc
index 5ec9139..8fc5682 100644
--- a/net/ftp/ftp_network_transaction_unittest.cc
+++ b/net/ftp/ftp_network_transaction_unittest.cc
@@ -14,7 +14,6 @@
 #include "net/base/io_buffer.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/ftp/ftp_network_session.h"
 #include "net/ftp/ftp_request_info.h"
@@ -1069,10 +1068,9 @@ TEST_F(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafeHost) {
   // Even if the PASV response specified some other address, we connect
   // to the address we used for control connection (which could be 127.0.0.1
   // or ::1 depending on whether we use IPv6).
-  const struct addrinfo* addrinfo = data_socket->addresses().head();
-  while (addrinfo) {
-    EXPECT_NE("10.1.2.3", NetAddressToString(addrinfo));
-    addrinfo = addrinfo->ai_next;
+  for (AddressList::const_iterator it = data_socket->addresses().begin();
+      it != data_socket->addresses().end(); ++it) {
+    EXPECT_NE("10.1.2.3", it->ToStringWithoutPort());
   }
 }
 
diff --git a/net/http/http_auth_handler_negotiate.cc b/net/http/http_auth_handler_negotiate.cc
index f2e8044..4e1c81d 100644
--- a/net/http/http_auth_handler_negotiate.cc
+++ b/net/http/http_auth_handler_negotiate.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -147,8 +147,8 @@ std::wstring HttpAuthHandlerNegotiate::CreateSPN(
   // and IE. Users can override the behavior so aliases are allowed and
   // non-standard ports are included.
   int port = origin.EffectiveIntPort();
-  std::string server;
-  if (!address_list.GetCanonicalName(&server))
+  std::string server = address_list.canonical_name();
+  if (server.empty())
     server = origin.host();
 #if defined(OS_WIN)
   static const char kSpnSeparator = '/';
diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_spdy2_unittest.cc
index de09262..746cbe9 100644
--- a/net/http/http_network_transaction_spdy2_unittest.cc
+++ b/net/http/http_network_transaction_spdy2_unittest.cc
@@ -9243,8 +9243,7 @@ void IPPoolingAddAlias(MockCachingHostResolver* host_resolver,
   // MockHostResolver returns 127.0.0.1 (MockHostResolverBase::Reset). So we use
   // the first address (127.0.0.1) returned by MockHostResolver as an alias for
   // the |pair|.
-  const addrinfo* address = addresses.head();
-  pool_peer->AddAlias(address, pair);
+  pool_peer->AddAlias(addresses.front(), pair);
 }
 
 }  // namespace
diff --git a/net/http/http_network_transaction_spdy3_unittest.cc b/net/http/http_network_transaction_spdy3_unittest.cc
index 63fcf69..2a9cbe0 100644
--- a/net/http/http_network_transaction_spdy3_unittest.cc
+++ b/net/http/http_network_transaction_spdy3_unittest.cc
@@ -9241,8 +9241,7 @@ void IPPoolingAddAlias(MockCachingHostResolver* host_resolver,
   // MockHostResolver returns 127.0.0.1 (MockHostResolverBase::Reset). So we use
   // the first address (127.0.0.1) returned by MockHostResolver as an alias for
   // the |pair|.
-  const addrinfo* address = addresses.head();
-  pool_peer->AddAlias(address, pair);
+  pool_peer->AddAlias(addresses.front(), pair);
 }
 
 }  // namespace
diff --git a/net/http/http_stream_parser.cc b/net/http/http_stream_parser.cc
index 31c7b73..6c38db7 100644
--- a/net/http/http_stream_parser.cc
+++ b/net/http/http_stream_parser.cc
@@ -213,7 +213,7 @@ int HttpStreamParser::SendRequest(const std::string& request_line,
   int result = connection_->socket()->GetPeerAddress(&address);
   if (result != OK)
     return result;
-  response_->socket_address = HostPortPair::FromAddrInfo(address.head());
+  response_->socket_address = HostPortPair::FromIPEndPoint(address.front());
 
   std::string request = request_line + headers.ToString();
   request_body_.reset(request_body);
diff --git a/net/proxy/proxy_resolver_js_bindings.cc b/net/proxy/proxy_resolver_js_bindings.cc
index 48dab35..dcffe3a 100644
--- a/net/proxy/proxy_resolver_js_bindings.cc
+++ b/net/proxy/proxy_resolver_js_bindings.cc
@@ -14,7 +14,6 @@
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 #include "net/proxy/proxy_resolver_request_context.h"
 #include "net/proxy/sync_host_resolver.h"
@@ -207,7 +206,7 @@ class DefaultJSBindings : public ProxyResolverJSBindings {
 
     // There may be multiple results; we will just use the first one.
     // This returns empty string on failure.
-    *first_ip_address = net::NetAddressToString(address_list.head());
+    *first_ip_address = address_list.front().ToStringWithoutPort();
     if (first_ip_address->empty())
       return false;
 
@@ -227,15 +226,14 @@ class DefaultJSBindings : public ProxyResolverJSBindings {
     // Stringify all of the addresses in the address list, separated
     // by semicolons.
     std::string address_list_str;
-    const struct addrinfo* current_address = address_list.head();
-    while (current_address) {
+    for (AddressList::const_iterator iter = address_list.begin();
+         iter != address_list.end(); ++iter) {
       if (!address_list_str.empty())
         address_list_str += ";";
-      const std::string address_string = NetAddressToString(current_address);
+      const std::string address_string = iter->ToStringWithoutPort();
       if (address_string.empty())
         return false;
       address_list_str += address_string;
-      current_address = current_address->ai_next;
     }
 
     *ip_address_list = address_list_str;
diff --git a/net/proxy/proxy_resolver_js_bindings_unittest.cc b/net/proxy/proxy_resolver_js_bindings_unittest.cc
index a1377a8..8122ef0 100644
--- a/net/proxy/proxy_resolver_js_bindings_unittest.cc
+++ b/net/proxy/proxy_resolver_js_bindings_unittest.cc
@@ -14,7 +14,6 @@
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/proxy/proxy_resolver_request_context.h"
 #include "net/proxy/sync_host_resolver.h"
@@ -168,11 +167,13 @@ TEST(ProxyResolverJSBindingsTest, RestrictAddressFamily) {
   HostResolver::RequestInfo info(HostPortPair("foo", 80));
   AddressList address_list;
   EXPECT_EQ(OK, host_resolver->Resolve(info, &address_list, BoundNetLog()));
-  EXPECT_EQ("192.168.2.1", NetAddressToString(address_list.head()));
+  ASSERT_FALSE(address_list.empty());
+  EXPECT_EQ("192.168.2.1", address_list.front().ToStringWithoutPort());
 
   info.set_address_family(ADDRESS_FAMILY_IPV4);
   EXPECT_EQ(OK, host_resolver->Resolve(info, &address_list, BoundNetLog()));
-  EXPECT_EQ("192.168.1.1", NetAddressToString(address_list.head()));
+  ASSERT_FALSE(address_list.empty());
+  EXPECT_EQ("192.168.1.1", address_list.front().ToStringWithoutPort());
 
   std::string ip_address;
   // Now the actual test.
diff --git a/net/socket/socket_test_util.h b/net/socket/socket_test_util.h
index d54e2ac..a0d0c65 100644
--- a/net/socket/socket_test_util.h
+++ b/net/socket/socket_test_util.h
@@ -627,7 +627,7 @@ class MockTCPClientSocket : public MockClientSocket, public AsyncSocket {
                       SocketDataProvider* socket);
   virtual ~MockTCPClientSocket();
 
-  AddressList addresses() const { return addresses_; }
+  const AddressList& addresses() const { return addresses_; }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf, int buf_len,
diff --git a/net/socket/socks5_client_socket.cc b/net/socket/socks5_client_socket.cc
index dd75a4d..5475313 100644
--- a/net/socket/socks5_client_socket.cc
+++ b/net/socket/socks5_client_socket.cc
@@ -13,7 +13,6 @@
 #include "net/base/io_buffer.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/socket/client_socket_handle.h"
 
 namespace net {
diff --git a/net/socket/socks5_client_socket_unittest.cc b/net/socket/socks5_client_socket_unittest.cc
index 39c86bf..b5fce50 100644
--- a/net/socket/socks5_client_socket_unittest.cc
+++ b/net/socket/socks5_client_socket_unittest.cc
@@ -13,7 +13,6 @@
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/mock_host_resolver.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/winsock_init.h"
 #include "net/socket/client_socket_factory.h"
diff --git a/net/socket/socks_client_socket.cc b/net/socket/socks_client_socket.cc
index 01983d9..025d1aa 100644
--- a/net/socket/socks_client_socket.cc
+++ b/net/socket/socks_client_socket.cc
@@ -11,7 +11,6 @@
 #include "net/base/io_buffer.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/socket/client_socket_handle.h"
 
 namespace net {
@@ -307,20 +306,19 @@ const std::string SOCKSClientSocket::BuildHandshakeWriteBuffer() const {
   request.command = kSOCKSStreamRequest;
   request.nw_port = base::HostToNet16(host_request_info_.port());
 
-  const struct addrinfo* ai = addresses_.head();
-  DCHECK(ai);
+  DCHECK(!addresses_.empty());
+  const IPEndPoint& endpoint = addresses_.front();
 
   // We disabled IPv6 results when resolving the hostname, so none of the
   // results in the list will be IPv6.
   // TODO(eroman): we only ever use the first address in the list. It would be
   //               more robust to try all the IP addresses we have before
   //               failing the connect attempt.
-  CHECK_EQ(AF_INET, ai->ai_addr->sa_family);
-  struct sockaddr_in* ipv4_host =
-      reinterpret_cast<struct sockaddr_in*>(ai->ai_addr);
-  memcpy(&request.ip, &ipv4_host->sin_addr, sizeof(ipv4_host->sin_addr));
+  CHECK_EQ(AF_INET, endpoint.GetFamily());
+  CHECK_LE(endpoint.address().size(), sizeof(request.ip));
+  memcpy(&request.ip, &endpoint.address()[0], endpoint.address().size());
 
-  DVLOG(1) << "Resolved Host is : " << NetAddressToString(ai);
+  DVLOG(1) << "Resolved Host is : " << endpoint.ToStringWithoutPort();
 
   std::string handshake_data(reinterpret_cast<char*>(&request),
                              sizeof(request));
diff --git a/net/socket/ssl_client_socket_mac.cc b/net/socket/ssl_client_socket_mac.cc
index e847c15..f84f3fb 100644
--- a/net/socket/ssl_client_socket_mac.cc
+++ b/net/socket/ssl_client_socket_mac.cc
@@ -880,10 +880,10 @@ int SSLClientSocketMac::InitializeSSLContext() {
   int rv = transport_->socket()->GetPeerAddress(&address);
   if (rv != OK)
     return rv;
-  const struct addrinfo* ai = address.head();
+  const IPEndPoint& endpoint = address.front();
   std::string peer_id(host_and_port_.ToString());
-  peer_id += std::string(reinterpret_cast<char*>(ai->ai_addr),
-                         ai->ai_addrlen);
+  peer_id += std::string(reinterpret_cast<const char*>(&endpoint.address()[0]),
+                         endpoint.address().size());
   // SSLSetPeerID() treats peer_id as a binary blob, and makes its
   // own copy.
   status = SSLSetPeerID(ssl_context_, peer_id.data(), peer_id.length());
diff --git a/net/socket/ssl_client_socket_nss.cc b/net/socket/ssl_client_socket_nss.cc
index b70365d..2a824f4 100644
--- a/net/socket/ssl_client_socket_nss.cc
+++ b/net/socket/ssl_client_socket_nss.cc
@@ -94,7 +94,6 @@
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/ssl_connection_status_flags.h"
 #include "net/base/ssl_info.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/x509_certificate_net_log_param.h"
 #include "net/ocsp/nss_ocsp.h"
 #include "net/socket/client_socket_handle.h"
@@ -1023,20 +1022,22 @@ int SSLClientSocketNSS::InitializeSSLPeerName() {
   if (err != OK)
     return err;
 
-  const struct addrinfo* ai = peer_address.head();
+  SockaddrStorage storage;
+  if (!peer_address.front().ToSockAddr(storage.addr, &storage.addr_len))
+    return ERR_UNEXPECTED;
 
   PRNetAddr peername;
   memset(&peername, 0, sizeof(peername));
-  DCHECK_LE(ai->ai_addrlen, sizeof(peername));
-  size_t len = std::min(static_cast<size_t>(ai->ai_addrlen),
+  DCHECK_LE(static_cast<size_t>(storage.addr_len), sizeof(peername));
+  size_t len = std::min(static_cast<size_t>(storage.addr_len),
                         sizeof(peername));
-  memcpy(&peername, ai->ai_addr, len);
+  memcpy(&peername, storage.addr, len);
 
   // Adjust the address family field for BSD, whose sockaddr
   // structure has a one-byte length and one-byte address family
   // field at the beginning.  PRNetAddr has a two-byte address
   // family field at the beginning.
-  peername.raw.family = ai->ai_addr->sa_family;
+  peername.raw.family = storage.addr->sa_family;
 
   memio_SetPeerName(nss_fd_, &peername);
 
diff --git a/net/socket/ssl_client_socket_pool_unittest.cc b/net/socket/ssl_client_socket_pool_unittest.cc
index 168365d..b841c02 100644
--- a/net/socket/ssl_client_socket_pool_unittest.cc
+++ b/net/socket/ssl_client_socket_pool_unittest.cc
@@ -14,7 +14,6 @@
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service_defaults.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_certificate_data.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_auth_handler_factory.h"
@@ -721,9 +720,8 @@ TEST_F(SSLClientSocketPoolTest, IPPooling) {
 
   // TODO(rtenneti): MockClientSocket::GetPeerAddress returns 0 as the port
   // number. Fix it to return port 80 and then use GetPeerAddress to AddAlias.
-  const addrinfo* address = test_hosts[0].addresses.head();
   SpdySessionPoolPeer pool_peer(session_->spdy_session_pool());
-  pool_peer.AddAlias(address, test_hosts[0].pair);
+  pool_peer.AddAlias(test_hosts[0].addresses.front(), test_hosts[0].pair);
 
   scoped_refptr<SpdySession> spdy_session;
   rv = session_->spdy_session_pool()->GetSpdySessionFromSocket(
@@ -807,9 +805,8 @@ TEST_F(SSLClientSocketPoolTest, IPPoolingClientCert) {
 
   // TODO(rtenneti): MockClientSocket::GetPeerAddress returns 0 as the port
   // number. Fix it to return port 80 and then use GetPeerAddress to AddAlias.
-  const addrinfo* address = test_hosts[0].addresses.head();
   SpdySessionPoolPeer pool_peer(session_->spdy_session_pool());
-  pool_peer.AddAlias(address, test_hosts[0].pair);
+  pool_peer.AddAlias(test_hosts[0].addresses.front(), test_hosts[0].pair);
 
   scoped_refptr<SpdySession> spdy_session;
   rv = session_->spdy_session_pool()->GetSpdySessionFromSocket(
diff --git a/net/socket/tcp_client_socket_libevent.cc b/net/socket/tcp_client_socket_libevent.cc
index b17f52f..972d75d 100644
--- a/net/socket/tcp_client_socket_libevent.cc
+++ b/net/socket/tcp_client_socket_libevent.cc
@@ -127,7 +127,7 @@ TCPClientSocketLibevent::TCPClientSocketLibevent(
     : socket_(kInvalidSocket),
       bound_socket_(kInvalidSocket),
       addresses_(addresses),
-      current_ai_(NULL),
+      current_address_index_(-1),
       read_watcher_(this),
       write_watcher_(this),
       next_connect_state_(CONNECT_STATE_NONE),
@@ -163,23 +163,21 @@ int TCPClientSocketLibevent::AdoptSocket(int socket) {
   // This is to make GetPeerAddress() work. It's up to the caller ensure
   // that |address_| contains a reasonable address for this
   // socket. (i.e. at least match IPv4 vs IPv6!).
-  current_ai_ = addresses_.head();
+  current_address_index_ = 0;
   use_history_.set_was_ever_connected();
 
   return OK;
 }
 
 int TCPClientSocketLibevent::Bind(const IPEndPoint& address) {
-  if (current_ai_ != NULL || bind_address_.get()) {
+  if (current_address_index_ >= 0 || bind_address_.get()) {
     // Cannot bind the socket if we are already bound connected or
     // connecting.
     return ERR_UNEXPECTED;
   }
 
-  sockaddr_storage addr_storage;
-  sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  size_t addr_len = sizeof(addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_INVALID_ARGUMENT;
 
   // Create |bound_socket_| and try to bound it to |address|.
@@ -187,7 +185,7 @@ int TCPClientSocketLibevent::Bind(const IPEndPoint& address) {
   if (error)
     return MapSystemError(error);
 
-  if (HANDLE_EINTR(bind(bound_socket_, addr, addr_len))) {
+  if (HANDLE_EINTR(bind(bound_socket_, storage.addr, storage.addr_len))) {
     error = errno;
     if (HANDLE_EINTR(close(bound_socket_)) < 0)
       PLOG(ERROR) << "close";
@@ -219,7 +217,7 @@ int TCPClientSocketLibevent::Connect(const CompletionCallback& callback) {
   // We will try to connect to each address in addresses_. Start with the
   // first one in the list.
   next_connect_state_ = CONNECT_STATE_CONNECT;
-  current_ai_ = addresses_.head();
+  current_address_index_ = 0;
 
   int rv = DoConnectLoop(OK);
   if (rv == ERR_IO_PENDING) {
@@ -259,10 +257,12 @@ int TCPClientSocketLibevent::DoConnectLoop(int result) {
 }
 
 int TCPClientSocketLibevent::DoConnect() {
-  DCHECK(current_ai_);
-
+  DCHECK_GE(current_address_index_, 0);
+  DCHECK_LT(current_address_index_, static_cast<int>(addresses_.size()));
   DCHECK_EQ(0, connect_os_error_);
 
+  const IPEndPoint& endpoint = addresses_[current_address_index_];
+
   if (previously_disconnected_) {
     use_history_.Reset();
     previously_disconnected_ = false;
@@ -270,7 +270,8 @@ int TCPClientSocketLibevent::DoConnect() {
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
                       make_scoped_refptr(new NetLogStringParameter(
-                          "address", NetAddressToStringWithPort(current_ai_))));
+                          "address",
+                          endpoint.ToString())));
 
   next_connect_state_ = CONNECT_STATE_CONNECT_COMPLETE;
 
@@ -280,26 +281,27 @@ int TCPClientSocketLibevent::DoConnect() {
     bound_socket_ = kInvalidSocket;
   } else {
     // Create a non-blocking socket.
-    connect_os_error_ = CreateSocket(current_ai_->ai_family, &socket_);
+    connect_os_error_ = CreateSocket(endpoint.GetFamily(), &socket_);
     if (connect_os_error_)
       return MapSystemError(connect_os_error_);
 
     if (bind_address_.get()) {
-      sockaddr_storage addr_storage;
-      sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-      size_t addr_len = sizeof(addr_storage);
-      if (!bind_address_->ToSockAddr(addr, &addr_len))
+      SockaddrStorage storage;
+      if (!bind_address_->ToSockAddr(storage.addr, &storage.addr_len))
         return ERR_INVALID_ARGUMENT;
-      if (HANDLE_EINTR(bind(socket_, addr, addr_len)))
+      if (HANDLE_EINTR(bind(socket_, storage.addr, storage.addr_len)))
         return MapSystemError(errno);
     }
   }
 
   // Connect the socket.
   if (!use_tcp_fastopen_) {
+    SockaddrStorage storage;
+    if (!endpoint.ToSockAddr(storage.addr, &storage.addr_len))
+      return ERR_INVALID_ARGUMENT;
+
     connect_start_time_ = base::TimeTicks::Now();
-    if (!HANDLE_EINTR(connect(socket_, current_ai_->ai_addr,
-                              static_cast<int>(current_ai_->ai_addrlen)))) {
+    if (!HANDLE_EINTR(connect(socket_, storage.addr, storage.addr_len))) {
       // Connected without waiting!
       return OK;
     }
@@ -347,9 +349,9 @@ int TCPClientSocketLibevent::DoConnectComplete(int result) {
   DoDisconnect();
 
   // Try to fall back to the next address in the list.
-  if (current_ai_->ai_next) {
+  if (current_address_index_ + 1 < static_cast<int>(addresses_.size())) {
     next_connect_state_ = CONNECT_STATE_CONNECT;
-    current_ai_ = current_ai_->ai_next;
+    ++current_address_index_;
     return OK;
   }
 
@@ -361,7 +363,7 @@ void TCPClientSocketLibevent::Disconnect() {
   DCHECK(CalledOnValidThread());
 
   DoDisconnect();
-  current_ai_ = NULL;
+  current_address_index_ = -1;
 }
 
 void TCPClientSocketLibevent::DoDisconnect() {
@@ -389,7 +391,7 @@ bool TCPClientSocketLibevent::IsConnected() const {
     // This allows GetPeerAddress() to return current_ai_ as the peer
     // address.  Since we don't fail over to the next address if
     // sendto() fails, current_ai_ is the only possible peer address.
-    CHECK(current_ai_);
+    CHECK_LT(current_address_index_, static_cast<int>(addresses_.size()));
     return true;
   }
 
@@ -505,6 +507,12 @@ int TCPClientSocketLibevent::Write(IOBuffer* buf,
 int TCPClientSocketLibevent::InternalWrite(IOBuffer* buf, int buf_len) {
   int nwrite;
   if (use_tcp_fastopen_ && !tcp_fastopen_connected_) {
+    SockaddrStorage storage;
+    if (!addresses_[current_address_index_].ToSockAddr(storage.addr,
+                                                       &storage.addr_len)) {
+      return ERR_INVALID_ARGUMENT;
+    }
+
     // We have a limited amount of data to send in the SYN packet.
     int kMaxFastOpenSendLength = 1420;
 
@@ -515,8 +523,8 @@ int TCPClientSocketLibevent::InternalWrite(IOBuffer* buf, int buf_len) {
                                  buf->data(),
                                  buf_len,
                                  flags,
-                                 current_ai_->ai_addr,
-                                 static_cast<int>(current_ai_->ai_addrlen)));
+                                 storage.addr,
+                                 storage.addr_len));
     tcp_fastopen_connected_ = true;
 
     if (nwrite < 0) {
@@ -561,10 +569,8 @@ void TCPClientSocketLibevent::LogConnectCompletion(int net_error) {
     return;
   }
 
-  struct sockaddr_storage source_address;
-  socklen_t addrlen = sizeof(source_address);
-  int rv = getsockname(
-      socket_, reinterpret_cast<struct sockaddr*>(&source_address), &addrlen);
+  SockaddrStorage storage;
+  int rv = getsockname(socket_, storage.addr, &storage.addr_len);
   if (rv != 0) {
     PLOG(ERROR) << "getsockname() [rv: " << rv << "] error: ";
     NOTREACHED();
@@ -573,9 +579,7 @@ void TCPClientSocketLibevent::LogConnectCompletion(int net_error) {
   }
 
   const std::string source_address_str =
-      NetAddressToStringWithPort(
-          reinterpret_cast<const struct sockaddr*>(&source_address),
-          sizeof(source_address));
+      NetAddressToStringWithPort(storage.addr, storage.addr_len);
   net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT,
                     make_scoped_refptr(new NetLogStringParameter(
                         "source address",
@@ -684,7 +688,7 @@ int TCPClientSocketLibevent::GetPeerAddress(AddressList* address) const {
   DCHECK(address);
   if (!IsConnected())
     return ERR_SOCKET_NOT_CONNECTED;
-  *address = AddressList::CreateByCopyingFirstAddress(current_ai_);
+  *address = AddressList(addresses_[current_address_index_]);
   return OK;
 }
 
@@ -694,12 +698,10 @@ int TCPClientSocketLibevent::GetLocalAddress(IPEndPoint* address) const {
   if (!IsConnected())
     return ERR_SOCKET_NOT_CONNECTED;
 
-  struct sockaddr_storage addr_storage;
-  socklen_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (getsockname(socket_, addr, &addr_len))
+  SockaddrStorage storage;
+  if (getsockname(socket_, storage.addr, &storage.addr_len))
     return MapSystemError(errno);
-  if (!address->FromSockAddr(addr, addr_len))
+  if (!address->FromSockAddr(storage.addr, storage.addr_len))
     return ERR_FAILED;
 
   return OK;
diff --git a/net/socket/tcp_client_socket_libevent.h b/net/socket/tcp_client_socket_libevent.h
index 5519f3c..b984649 100644
--- a/net/socket/tcp_client_socket_libevent.h
+++ b/net/socket/tcp_client_socket_libevent.h
@@ -123,7 +123,7 @@ class NET_EXPORT_PRIVATE TCPClientSocketLibevent : public StreamSocket,
   int DoConnectComplete(int result);
 
   // Helper used by Disconnect(), which disconnects minus the logging and
-  // resetting of current_ai_.
+  // resetting of current_address_index_.
   void DoDisconnect();
 
   void DoReadCallback(int rv);
@@ -155,8 +155,8 @@ class NET_EXPORT_PRIVATE TCPClientSocketLibevent : public StreamSocket,
   // The list of addresses we should try in order to establish a connection.
   AddressList addresses_;
 
-  // Where we are in above list, or NULL if all addrinfos have been tried.
-  const struct addrinfo* current_ai_;
+  // Where we are in above list. Set to -1 if uninitialized.
+  int current_address_index_;
 
   // The socket's libevent wrappers
   MessageLoopForIO::FileDescriptorWatcher read_socket_watcher_;
diff --git a/net/socket/tcp_client_socket_unittest.cc b/net/socket/tcp_client_socket_unittest.cc
index 991b645..c2589b8 100644
--- a/net/socket/tcp_client_socket_unittest.cc
+++ b/net/socket/tcp_client_socket_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -11,7 +11,6 @@
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/tcp_server_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -31,10 +30,7 @@ TEST(TCPClientSocketTest, BindLoopbackToLoopback) {
   IPEndPoint server_address;
   ASSERT_EQ(OK, server.GetLocalAddress(&server_address));
 
-  TCPClientSocket socket(
-      AddressList::CreateFromIPAddress(server_address.address(),
-                                       server_address.port()),
-      NULL, NetLog::Source());
+  TCPClientSocket socket(AddressList(server_address), NULL, NetLog::Source());
 
   EXPECT_EQ(OK, socket.Bind(IPEndPoint(lo_address, 0)));
 
@@ -88,10 +84,7 @@ TEST(TCPClientSocketTest, BindLoopbackToIPv6) {
 
   IPEndPoint server_address;
   ASSERT_EQ(OK, server.GetLocalAddress(&server_address));
-  TCPClientSocket socket(
-      AddressList::CreateFromIPAddress(server_address.address(),
-                                       server_address.port()),
-      NULL, NetLog::Source());
+  TCPClientSocket socket(AddressList(server_address), NULL, NetLog::Source());
 
   IPAddressNumber ipv4_lo_ip;
   ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &ipv4_lo_ip));
diff --git a/net/socket/tcp_client_socket_win.cc b/net/socket/tcp_client_socket_win.cc
index 28b0eef..4990887 100644
--- a/net/socket/tcp_client_socket_win.cc
+++ b/net/socket/tcp_client_socket_win.cc
@@ -20,7 +20,6 @@
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/winsock_init.h"
 #include "net/base/winsock_util.h"
 
@@ -317,7 +316,7 @@ TCPClientSocketWin::TCPClientSocketWin(const AddressList& addresses,
     : socket_(INVALID_SOCKET),
       bound_socket_(INVALID_SOCKET),
       addresses_(addresses),
-      current_ai_(NULL),
+      current_address_index_(-1),
       waiting_read_(false),
       waiting_write_(false),
       next_connect_state_(CONNECT_STATE_NONE),
@@ -349,22 +348,20 @@ int TCPClientSocketWin::AdoptSocket(SOCKET socket) {
 
   core_ = new Core(this);
 
-  current_ai_ = addresses_.head();
+  current_address_index_ = 0;
   use_history_.set_was_ever_connected();
 
   return OK;
 }
 
 int TCPClientSocketWin::Bind(const IPEndPoint& address) {
-  if (current_ai_ != NULL || bind_address_.get()) {
+  if (current_address_index_ >= 0 || bind_address_.get()) {
     // Cannot bind the socket if we are already connected or connecting.
     return ERR_UNEXPECTED;
   }
 
-  sockaddr_storage addr_storage;
-  sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  size_t addr_len = sizeof(addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_INVALID_ARGUMENT;
 
   // Create |bound_socket_| and try to bound it to |address|.
@@ -372,7 +369,7 @@ int TCPClientSocketWin::Bind(const IPEndPoint& address) {
   if (error)
     return MapSystemError(error);
 
-  if (bind(bound_socket_, addr, addr_len)) {
+  if (bind(bound_socket_, storage.addr, storage.addr_len)) {
     error = errno;
     if (closesocket(bound_socket_) < 0)
       PLOG(ERROR) << "closesocket";
@@ -402,7 +399,7 @@ int TCPClientSocketWin::Connect(const CompletionCallback& callback) {
   // We will try to connect to each address in addresses_. Start with the
   // first one in the list.
   next_connect_state_ = CONNECT_STATE_CONNECT;
-  current_ai_ = addresses_.head();
+  current_address_index_ = 0;
 
   int rv = DoConnectLoop(OK);
   if (rv == ERR_IO_PENDING) {
@@ -443,18 +440,20 @@ int TCPClientSocketWin::DoConnectLoop(int result) {
 }
 
 int TCPClientSocketWin::DoConnect() {
-  const struct addrinfo* ai = current_ai_;
-  DCHECK(ai);
+  DCHECK_GE(current_address_index_, 0);
+  DCHECK_LT(current_address_index_, static_cast<int>(addresses_.size()));
   DCHECK_EQ(0, connect_os_error_);
 
+  const IPEndPoint& endpoint = addresses_[current_address_index_];
+
   if (previously_disconnected_) {
     use_history_.Reset();
     previously_disconnected_ = false;
   }
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT_ATTEMPT,
-                      new NetLogStringParameter(
-                          "address", NetAddressToStringWithPort(current_ai_)));
+                      new NetLogStringParameter("address",
+                                                endpoint.ToString()));
 
   next_connect_state_ = CONNECT_STATE_CONNECT_COMPLETE;
 
@@ -463,17 +462,15 @@ int TCPClientSocketWin::DoConnect() {
     socket_ = bound_socket_;
     bound_socket_ = INVALID_SOCKET;
   } else {
-    connect_os_error_ = CreateSocket(ai->ai_family, &socket_);
+    connect_os_error_ = CreateSocket(endpoint.GetFamily(), &socket_);
     if (connect_os_error_ != 0)
       return MapSystemError(connect_os_error_);
 
     if (bind_address_.get()) {
-      sockaddr_storage addr_storage;
-      sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-      size_t addr_len = sizeof(addr_storage);
-      if (!bind_address_->ToSockAddr(addr, &addr_len))
+      SockaddrStorage storage;
+      if (!bind_address_->ToSockAddr(storage.addr, &storage.addr_len))
         return ERR_INVALID_ARGUMENT;
-      if (bind(socket_, addr, addr_len))
+      if (bind(socket_, storage.addr, storage.addr_len))
         return MapSystemError(errno);
     }
   }
@@ -484,8 +481,11 @@ int TCPClientSocketWin::DoConnect() {
   // Our connect() and recv() calls require that the socket be non-blocking.
   WSAEventSelect(socket_, core_->read_overlapped_.hEvent, FD_CONNECT);
 
+  SockaddrStorage storage;
+  if (!endpoint.ToSockAddr(storage.addr, &storage.addr_len))
+    return ERR_INVALID_ARGUMENT;
   connect_start_time_ = base::TimeTicks::Now();
-  if (!connect(socket_, ai->ai_addr, static_cast<int>(ai->ai_addrlen))) {
+  if (!connect(socket_, storage.addr, storage.addr_len)) {
     // Connected without waiting!
     //
     // The MSDN page for connect says:
@@ -532,9 +532,9 @@ int TCPClientSocketWin::DoConnectComplete(int result) {
   DoDisconnect();
 
   // Try to fall back to the next address in the list.
-  if (current_ai_->ai_next) {
+  if (current_address_index_ + 1 < static_cast<int>(addresses_.size())) {
     next_connect_state_ = CONNECT_STATE_CONNECT;
-    current_ai_ = current_ai_->ai_next;
+    ++current_address_index_;
     return OK;
   }
 
@@ -544,7 +544,7 @@ int TCPClientSocketWin::DoConnectComplete(int result) {
 
 void TCPClientSocketWin::Disconnect() {
   DoDisconnect();
-  current_ai_ = NULL;
+  current_address_index_ = -1;
 }
 
 void TCPClientSocketWin::DoDisconnect() {
@@ -629,7 +629,7 @@ int TCPClientSocketWin::GetPeerAddress(AddressList* address) const {
   DCHECK(address);
   if (!IsConnected())
     return ERR_SOCKET_NOT_CONNECTED;
-  *address = AddressList::CreateByCopyingFirstAddress(current_ai_);
+  *address = AddressList(addresses_[current_address_index_]);
   return OK;
 }
 
diff --git a/net/socket/tcp_client_socket_win.h b/net/socket/tcp_client_socket_win.h
index 9fffab8..c17a0b9 100644
--- a/net/socket/tcp_client_socket_win.h
+++ b/net/socket/tcp_client_socket_win.h
@@ -84,7 +84,7 @@ class NET_EXPORT TCPClientSocketWin : public StreamSocket,
   int DoConnectComplete(int result);
 
   // Helper used by Disconnect(), which disconnects minus the logging and
-  // resetting of current_ai_.
+  // resetting of current_address_index_.
   void DoDisconnect();
 
   // Returns true if a Connect() is in progress.
@@ -113,8 +113,8 @@ class NET_EXPORT TCPClientSocketWin : public StreamSocket,
   // The list of addresses we should try in order to establish a connection.
   AddressList addresses_;
 
-  // Where we are in above list, or NULL if all addrinfos have been tried.
-  const struct addrinfo* current_ai_;
+  // Where we are in above list. Set to -1 if uninitialized.
+  int current_address_index_;
 
   // The various states that the socket could be in.
   bool waiting_read_;
diff --git a/net/socket/tcp_server_socket_libevent.cc b/net/socket/tcp_server_socket_libevent.cc
index 904256a..34b8283 100644
--- a/net/socket/tcp_server_socket_libevent.cc
+++ b/net/socket/tcp_server_socket_libevent.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -64,13 +64,11 @@ int TCPServerSocketLibevent::Listen(const IPEndPoint& address, int backlog) {
     return result;
   }
 
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_INVALID_ARGUMENT;
 
-  int result = bind(socket_, addr, addr_len);
+  int result = bind(socket_, storage.addr, storage.addr_len);
   if (result < 0) {
     PLOG(ERROR) << "bind() returned an error";
     result = MapSystemError(errno);
@@ -93,12 +91,10 @@ int TCPServerSocketLibevent::GetLocalAddress(IPEndPoint* address) const {
   DCHECK(CalledOnValidThread());
   DCHECK(address);
 
-  struct sockaddr_storage addr_storage;
-  socklen_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (getsockname(socket_, addr, &addr_len) < 0)
+  SockaddrStorage storage;
+  if (getsockname(socket_, storage.addr, &storage.addr_len) < 0)
     return MapSystemError(errno);
-  if (!address->FromSockAddr(addr, addr_len))
+  if (!address->FromSockAddr(storage.addr, storage.addr_len))
     return ERR_FAILED;
 
   return OK;
@@ -132,11 +128,10 @@ int TCPServerSocketLibevent::Accept(
 
 int TCPServerSocketLibevent::AcceptInternal(
     scoped_ptr<StreamSocket>* socket) {
-  struct sockaddr_storage addr_storage;
-  socklen_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-
-  int new_socket = HANDLE_EINTR(accept(socket_, addr, &addr_len));
+  SockaddrStorage storage;
+  int new_socket = HANDLE_EINTR(accept(socket_,
+                                       storage.addr,
+                                       &storage.addr_len));
   if (new_socket < 0) {
     int net_error = MapSystemError(errno);
     if (net_error != ERR_IO_PENDING)
@@ -145,7 +140,7 @@ int TCPServerSocketLibevent::AcceptInternal(
   }
 
   IPEndPoint address;
-  if (!address.FromSockAddr(addr, addr_len)) {
+  if (!address.FromSockAddr(storage.addr, storage.addr_len)) {
     NOTREACHED();
     if (HANDLE_EINTR(close(new_socket)) < 0)
       PLOG(ERROR) << "close";
@@ -153,7 +148,7 @@ int TCPServerSocketLibevent::AcceptInternal(
     return ERR_FAILED;
   }
   scoped_ptr<TCPClientSocket> tcp_socket(new TCPClientSocket(
-      AddressList::CreateFromIPAddress(address.address(), address.port()),
+      AddressList(address),
       net_log_.net_log(), net_log_.source()));
   int adopt_result = tcp_socket->AdoptSocket(new_socket);
   if (adopt_result != OK) {
diff --git a/net/socket/tcp_server_socket_unittest.cc b/net/socket/tcp_server_socket_unittest.cc
index 9307297..a384b70 100644
--- a/net/socket/tcp_server_socket_unittest.cc
+++ b/net/socket/tcp_server_socket_unittest.cc
@@ -14,7 +14,6 @@
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/tcp_client_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -62,15 +61,11 @@ class TCPServerSocketTest : public PlatformTest {
   static IPEndPoint GetPeerAddress(StreamSocket* socket) {
     AddressList address;
     EXPECT_EQ(OK, socket->GetPeerAddress(&address));
-    IPEndPoint endpoint;
-    EXPECT_TRUE(endpoint.FromSockAddr(
-        address.head()->ai_addr, address.head()->ai_addrlen));
-    return endpoint;
+    return address.front();
   }
 
   AddressList local_address_list() const {
-    return AddressList::CreateFromIPAddress(
-        local_address_.address(), local_address_.port());
+    return AddressList(local_address_);
   }
 
   TCPServerSocket socket_;
diff --git a/net/socket/tcp_server_socket_win.cc b/net/socket/tcp_server_socket_win.cc
index 7e5cf4d..5b88233 100644
--- a/net/socket/tcp_server_socket_win.cc
+++ b/net/socket/tcp_server_socket_win.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -57,13 +57,11 @@ int TCPServerSocketWin::Listen(const IPEndPoint& address, int backlog) {
     return result;
   }
 
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_INVALID_ARGUMENT;
 
-  int result = bind(socket_, addr, addr_len);
+  int result = bind(socket_, storage.addr, storage.addr_len);
   if (result < 0) {
     PLOG(ERROR) << "bind() returned an error";
     result = MapSystemError(WSAGetLastError());
@@ -86,12 +84,10 @@ int TCPServerSocketWin::GetLocalAddress(IPEndPoint* address) const {
   DCHECK(CalledOnValidThread());
   DCHECK(address);
 
-  struct sockaddr_storage addr_storage;
-  socklen_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (getsockname(socket_, addr, &addr_len))
+  SockaddrStorage storage;
+  if (getsockname(socket_, storage.addr, &storage.addr_len))
     return MapSystemError(WSAGetLastError());
-  if (!address->FromSockAddr(addr, addr_len))
+  if (!address->FromSockAddr(storage.addr, storage.addr_len))
     return ERR_FAILED;
 
   return OK;
@@ -121,11 +117,8 @@ int TCPServerSocketWin::Accept(
 }
 
 int TCPServerSocketWin::AcceptInternal(scoped_ptr<StreamSocket>* socket) {
-  struct sockaddr_storage addr_storage;
-  socklen_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-
-  int new_socket = accept(socket_, addr, &addr_len);
+  SockaddrStorage storage;
+  int new_socket = accept(socket_, storage.addr, &storage.addr_len);
   if (new_socket < 0) {
     int net_error = MapSystemError(WSAGetLastError());
     if (net_error != ERR_IO_PENDING)
@@ -134,7 +127,7 @@ int TCPServerSocketWin::AcceptInternal(scoped_ptr<StreamSocket>* socket) {
   }
 
   IPEndPoint address;
-  if (!address.FromSockAddr(addr, addr_len)) {
+  if (!address.FromSockAddr(storage.addr, storage.addr_len)) {
     NOTREACHED();
     if (closesocket(new_socket) < 0)
       PLOG(ERROR) << "closesocket";
@@ -142,7 +135,7 @@ int TCPServerSocketWin::AcceptInternal(scoped_ptr<StreamSocket>* socket) {
     return ERR_FAILED;
   }
   scoped_ptr<TCPClientSocket> tcp_socket(new TCPClientSocket(
-      AddressList::CreateFromIPAddress(address.address(), address.port()),
+      AddressList(address),
       net_log_.net_log(), net_log_.source()));
   int adopt_result = tcp_socket->AdoptSocket(new_socket);
   if (adopt_result != OK) {
diff --git a/net/socket/transport_client_socket_pool.cc b/net/socket/transport_client_socket_pool.cc
index a00e810..b2ca683 100644
--- a/net/socket/transport_client_socket_pool.cc
+++ b/net/socket/transport_client_socket_pool.cc
@@ -4,6 +4,8 @@
 
 #include "net/socket/transport_client_socket_pool.h"
 
+#include <algorithm>
+
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ -14,7 +16,6 @@
 #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"
@@ -31,28 +32,14 @@ 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;
 }
 
@@ -123,35 +110,13 @@ LoadState TransportConnectJob::GetLoadState() const {
 }
 
 // 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());
       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) {
@@ -214,7 +179,8 @@ int TransportConnectJob::DoTransportConnect() {
   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);
@@ -224,7 +190,7 @@ int TransportConnectJob::DoTransportConnect() {
 
 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();
@@ -250,7 +216,7 @@ int TransportConnectJob::DoTransportConnectComplete(int result) {
                                  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),
@@ -287,7 +253,7 @@ void TransportConnectJob::DoIPv6FallbackTransportConnect() {
   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()));
diff --git a/net/socket/transport_client_socket_pool.h b/net/socket/transport_client_socket_pool.h
index ef3f6fa..fc9ee22 100644
--- a/net/socket/transport_client_socket_pool.h
+++ b/net/socket/transport_client_socket_pool.h
@@ -69,12 +69,9 @@ class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob {
   // ConnectJob methods.
   virtual LoadState GetLoadState() const OVERRIDE;
 
-  // Makes |addrlist| start with an IPv4 address if |addrlist| contains any
-  // IPv4 address.
-  //
-  // WARNING: this method should only be used to implement the prefer-IPv4
-  // hack.  It is a public method for the unit tests.
-  static void MakeAddrListStartWithIPv4(AddressList* addrlist);
+  // Rolls |addrlist| forward until the first IPv4 address, if any.
+  // WARNING: this method should only be used to implement the prefer-IPv4 hack.
+  static void MakeAddressListStartWithIPv4(AddressList* addrlist);
 
   static const int kIPv6FallbackTimerInMs;
 
diff --git a/net/socket/transport_client_socket_pool_unittest.cc b/net/socket/transport_client_socket_pool_unittest.cc
index 0b31083..c335e33 100644
--- a/net/socket/transport_client_socket_pool_unittest.cc
+++ b/net/socket/transport_client_socket_pool_unittest.cc
@@ -15,7 +15,6 @@
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
@@ -73,7 +72,7 @@ class MockClientSocket : public StreamSocket {
   virtual int GetLocalAddress(IPEndPoint* address) const {
     if (!connected_)
       return ERR_SOCKET_NOT_CONNECTED;
-    if (addrlist_.head()->ai_family == AF_INET)
+    if (addrlist_.front().GetFamily() == AF_INET)
       SetIPv4Address(address);
     else
       SetIPv6Address(address);
@@ -212,7 +211,7 @@ class MockPendingClientSocket : public StreamSocket {
   virtual int GetLocalAddress(IPEndPoint* address) const {
     if (!is_connected_)
       return ERR_SOCKET_NOT_CONNECTED;
-    if (addrlist_.head()->ai_family == AF_INET)
+    if (addrlist_.front().GetFamily() == AF_INET)
       SetIPv4Address(address);
     else
       SetIPv6Address(address);
@@ -435,84 +434,72 @@ class TransportClientSocketPoolTest : public testing::Test {
 TEST(TransportConnectJobTest, MakeAddrListStartWithIPv4) {
   IPAddressNumber ip_number;
   ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.1", &ip_number));
-  AddressList addrlist_v4_1 = AddressList::CreateFromIPAddress(ip_number, 80);
+  IPEndPoint addrlist_v4_1(ip_number, 80);
   ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.2", &ip_number));
-  AddressList addrlist_v4_2 = AddressList::CreateFromIPAddress(ip_number, 80);
+  IPEndPoint addrlist_v4_2(ip_number, 80);
   ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::64", &ip_number));
-  AddressList addrlist_v6_1 = AddressList::CreateFromIPAddress(ip_number, 80);
+  IPEndPoint addrlist_v6_1(ip_number, 80);
   ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::66", &ip_number));
-  AddressList addrlist_v6_2 = AddressList::CreateFromIPAddress(ip_number, 80);
+  IPEndPoint addrlist_v6_2(ip_number, 80);
 
   AddressList addrlist;
-  const struct addrinfo* ai;
 
   // Test 1: IPv4 only.  Expect no change.
-  addrlist = addrlist_v4_1;
-  addrlist.Append(addrlist_v4_2.head());
-  TransportConnectJob::MakeAddrListStartWithIPv4(&addrlist);
-  ai = addrlist.head();
-  EXPECT_EQ(AF_INET, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET, ai->ai_family);
-  EXPECT_TRUE(ai->ai_next == NULL);
+  addrlist.clear();
+  addrlist.push_back(addrlist_v4_1);
+  addrlist.push_back(addrlist_v4_2);
+  TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
+  ASSERT_EQ(2u, addrlist.size());
+  EXPECT_EQ(AF_INET, addrlist[0].GetFamily());
+  EXPECT_EQ(AF_INET, addrlist[1].GetFamily());
 
   // Test 2: IPv6 only.  Expect no change.
-  addrlist = addrlist_v6_1;
-  addrlist.Append(addrlist_v6_2.head());
-  TransportConnectJob::MakeAddrListStartWithIPv4(&addrlist);
-  ai = addrlist.head();
-  EXPECT_EQ(AF_INET6, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET6, ai->ai_family);
-  EXPECT_TRUE(ai->ai_next == NULL);
+  addrlist.clear();
+  addrlist.push_back(addrlist_v6_1);
+  addrlist.push_back(addrlist_v6_2);
+  TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
+  ASSERT_EQ(2u, addrlist.size());
+  EXPECT_EQ(AF_INET6, addrlist[0].GetFamily());
+  EXPECT_EQ(AF_INET6, addrlist[1].GetFamily());
 
   // Test 3: IPv4 then IPv6.  Expect no change.
-  addrlist = addrlist_v4_1;
-  addrlist.Append(addrlist_v4_2.head());
-  addrlist.Append(addrlist_v6_1.head());
-  addrlist.Append(addrlist_v6_2.head());
-  TransportConnectJob::MakeAddrListStartWithIPv4(&addrlist);
-  ai = addrlist.head();
-  EXPECT_EQ(AF_INET, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET6, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET6, ai->ai_family);
-  EXPECT_TRUE(ai->ai_next == NULL);
+  addrlist.clear();
+  addrlist.push_back(addrlist_v4_1);
+  addrlist.push_back(addrlist_v4_2);
+  addrlist.push_back(addrlist_v6_1);
+  addrlist.push_back(addrlist_v6_2);
+  TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
+  ASSERT_EQ(4u, addrlist.size());
+  EXPECT_EQ(AF_INET, addrlist[0].GetFamily());
+  EXPECT_EQ(AF_INET, addrlist[1].GetFamily());
+  EXPECT_EQ(AF_INET6, addrlist[2].GetFamily());
+  EXPECT_EQ(AF_INET6, addrlist[3].GetFamily());
 
   // Test 4: IPv6, IPv4, IPv6, IPv4.  Expect first IPv6 moved to the end.
-  addrlist = addrlist_v6_1;
-  addrlist.Append(addrlist_v4_1.head());
-  addrlist.Append(addrlist_v6_2.head());
-  addrlist.Append(addrlist_v4_2.head());
-  TransportConnectJob::MakeAddrListStartWithIPv4(&addrlist);
-  ai = addrlist.head();
-  EXPECT_EQ(AF_INET, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET6, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET6, ai->ai_family);
-  EXPECT_TRUE(ai->ai_next == NULL);
+  addrlist.clear();
+  addrlist.push_back(addrlist_v6_1);
+  addrlist.push_back(addrlist_v4_1);
+  addrlist.push_back(addrlist_v6_2);
+  addrlist.push_back(addrlist_v4_2);
+  TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
+  ASSERT_EQ(4u, addrlist.size());
+  EXPECT_EQ(AF_INET, addrlist[0].GetFamily());
+  EXPECT_EQ(AF_INET6, addrlist[1].GetFamily());
+  EXPECT_EQ(AF_INET, addrlist[2].GetFamily());
+  EXPECT_EQ(AF_INET6, addrlist[3].GetFamily());
 
   // Test 5: IPv6, IPv6, IPv4, IPv4.  Expect first two IPv6's moved to the end.
-  addrlist = addrlist_v6_1;
-  addrlist.Append(addrlist_v6_2.head());
-  addrlist.Append(addrlist_v4_1.head());
-  addrlist.Append(addrlist_v4_2.head());
-  TransportConnectJob::MakeAddrListStartWithIPv4(&addrlist);
-  ai = addrlist.head();
-  EXPECT_EQ(AF_INET, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET6, ai->ai_family);
-  ai = ai->ai_next;
-  EXPECT_EQ(AF_INET6, ai->ai_family);
-  EXPECT_TRUE(ai->ai_next == NULL);
+  addrlist.clear();
+  addrlist.push_back(addrlist_v6_1);
+  addrlist.push_back(addrlist_v6_2);
+  addrlist.push_back(addrlist_v4_1);
+  addrlist.push_back(addrlist_v4_2);
+  TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
+  ASSERT_EQ(4u, addrlist.size());
+  EXPECT_EQ(AF_INET, addrlist[0].GetFamily());
+  EXPECT_EQ(AF_INET, addrlist[1].GetFamily());
+  EXPECT_EQ(AF_INET6, addrlist[2].GetFamily());
+  EXPECT_EQ(AF_INET6, addrlist[3].GetFamily());
 }
 
 TEST_F(TransportClientSocketPoolTest, Basic) {
diff --git a/net/socket_stream/socket_stream.cc b/net/socket_stream/socket_stream.cc
index 51e92907..fb8984e 100644
--- a/net/socket_stream/socket_stream.cc
+++ b/net/socket_stream/socket_stream.cc
@@ -278,8 +278,8 @@ SocketStream::~SocketStream() {
   DCHECK(!pac_request_);
 }
 
-void SocketStream::CopyAddrInfo(struct addrinfo* head) {
-  addresses_ = AddressList::CreateByCopying(head);
+void SocketStream::set_addresses(const AddressList& addresses) {
+  addresses_ = addresses;
 }
 
 void SocketStream::DoClose() {
diff --git a/net/socket_stream/socket_stream.h b/net/socket_stream/socket_stream.h
index 7f07196..c207d3b 100644
--- a/net/socket_stream/socket_stream.h
+++ b/net/socket_stream/socket_stream.h
@@ -265,9 +265,8 @@ class NET_EXPORT SocketStream
   // Use the same number as HttpNetworkTransaction::kMaxHeaderBufSize.
   enum { kMaxTunnelResponseHeadersSize = 32768 };  // 32 kilobytes.
 
-  // Copies the given addrinfo list in |addresses_|.
   // Used for WebSocketThrottleTest.
-  void CopyAddrInfo(struct addrinfo* head);
+  void set_addresses(const AddressList& addresses);
 
   void DoClose();
 
diff --git a/net/spdy/spdy_http_stream.cc b/net/spdy/spdy_http_stream.cc
index cdda4f2..9a498b9 100644
--- a/net/spdy/spdy_http_stream.cc
+++ b/net/spdy/spdy_http_stream.cc
@@ -254,7 +254,8 @@ int SpdyHttpStream::SendRequest(const HttpRequestHeaders& request_headers,
   int result = stream_->GetPeerAddress(&address);
   if (result != OK)
     return result;
-  response_info_->socket_address = HostPortPair::FromAddrInfo(address.head());
+  response_info_->socket_address =
+      HostPortPair::FromIPEndPoint(address.front());
 
   bool has_upload_data = request_body_stream_.get() != NULL;
   result = stream_->SendRequest(has_upload_data);
diff --git a/net/spdy/spdy_session_pool.cc b/net/spdy/spdy_session_pool.cc
index 430a233..7fc617e 100644
--- a/net/spdy/spdy_session_pool.cc
+++ b/net/spdy/spdy_session_pool.cc
@@ -8,7 +8,6 @@
 #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"
@@ -173,7 +172,7 @@ net::Error SpdySessionPool::GetSpdySessionFromSocket(
   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.
@@ -275,18 +274,15 @@ scoped_refptr<SpdySession> SpdySessionPool::GetFromAlias(
   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))
@@ -382,12 +378,9 @@ bool SpdySessionPool::LookupAddresses(const HostPortProxyPair& pair,
   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;
 }
 
diff --git a/net/spdy/spdy_session_pool.h b/net/spdy/spdy_session_pool.h
index 567f2d8..2ab32f0 100644
--- a/net/spdy/spdy_session_pool.h
+++ b/net/spdy/spdy_session_pool.h
@@ -182,7 +182,7 @@ class NET_EXPORT SpdySessionPool
                        AddressList* addresses) const;
 
   // Add |address| as an IP-equivalent address for |pair|.
-  void AddAlias(const addrinfo* address, const HostPortProxyPair& pair);
+  void AddAlias(const IPEndPoint& address, const HostPortProxyPair& pair);
 
   // Remove all aliases for |pair| from the aliases table.
   void RemoveAliases(const HostPortProxyPair& pair);
diff --git a/net/spdy/spdy_session_spdy2_unittest.cc b/net/spdy/spdy_session_spdy2_unittest.cc
index a4afe3a..03bb6ae 100644
--- a/net/spdy/spdy_session_spdy2_unittest.cc
+++ b/net/spdy/spdy_session_spdy2_unittest.cc
@@ -810,9 +810,8 @@ void IPPoolingTest(bool clean_via_close_current_sessions) {
 
   // TODO(rtenneti): MockClientSocket::GetPeerAddress return's 0 as the port
   // number. Fix it to return port 80 and then use GetPeerAddress to AddAlias.
-  const addrinfo* address = test_hosts[0].addresses.head();
   SpdySessionPoolPeer pool_peer(spdy_session_pool);
-  pool_peer.AddAlias(address, test_hosts[0].pair);
+  pool_peer.AddAlias(test_hosts[0].addresses.front(), test_hosts[0].pair);
 
   // Flush the SpdySession::OnReadComplete() task.
   MessageLoop::current()->RunAllPending();
diff --git a/net/spdy/spdy_session_spdy3_unittest.cc b/net/spdy/spdy_session_spdy3_unittest.cc
index 7ac41c3..82b2342 100644
--- a/net/spdy/spdy_session_spdy3_unittest.cc
+++ b/net/spdy/spdy_session_spdy3_unittest.cc
@@ -810,9 +810,8 @@ void IPPoolingTest(bool clean_via_close_current_sessions) {
 
   // TODO(rtenneti): MockClientSocket::GetPeerAddress return's 0 as the port
   // number. Fix it to return port 80 and then use GetPeerAddress to AddAlias.
-  const addrinfo* address = test_hosts[0].addresses.head();
   SpdySessionPoolPeer pool_peer(spdy_session_pool);
-  pool_peer.AddAlias(address, test_hosts[0].pair);
+  pool_peer.AddAlias(test_hosts[0].addresses.front(), test_hosts[0].pair);
 
   // Flush the SpdySession::OnReadComplete() task.
   MessageLoop::current()->RunAllPending();
diff --git a/net/spdy/spdy_test_util_spdy2.h b/net/spdy/spdy_test_util_spdy2.h
index 2dcd999..f20e07e 100644
--- a/net/spdy/spdy_test_util_spdy2.h
+++ b/net/spdy/spdy_test_util_spdy2.h
@@ -12,7 +12,6 @@
 #include "net/base/mock_host_resolver.h"
 #include "net/base/request_priority.h"
 #include "net/base/ssl_config_service_defaults.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
@@ -392,7 +391,7 @@ class SpdySessionPoolPeer {
   explicit SpdySessionPoolPeer(SpdySessionPool* pool)
       : pool_(pool) {}
 
-  void AddAlias(const addrinfo* address, const HostPortProxyPair& pair) {
+  void AddAlias(const IPEndPoint& address, const HostPortProxyPair& pair) {
     pool_->AddAlias(address, pair);
   }
 
diff --git a/net/spdy/spdy_test_util_spdy3.h b/net/spdy/spdy_test_util_spdy3.h
index 11d2e62..2b11041 100644
--- a/net/spdy/spdy_test_util_spdy3.h
+++ b/net/spdy/spdy_test_util_spdy3.h
@@ -12,7 +12,6 @@
 #include "net/base/mock_host_resolver.h"
 #include "net/base/request_priority.h"
 #include "net/base/ssl_config_service_defaults.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
@@ -393,7 +392,7 @@ class SpdySessionPoolPeer {
   explicit SpdySessionPoolPeer(SpdySessionPool* pool)
       : pool_(pool) {}
 
-  void AddAlias(const addrinfo* address, const HostPortProxyPair& pair) {
+  void AddAlias(const IPEndPoint& address, const HostPortProxyPair& pair) {
     pool_->AddAlias(address, pair);
   }
 
diff --git a/net/udp/udp_socket_libevent.cc b/net/udp/udp_socket_libevent.cc
index f8ef7e3..13196d2 100644
--- a/net/udp/udp_socket_libevent.cc
+++ b/net/udp/udp_socket_libevent.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -95,13 +95,11 @@ int UDPSocketLibevent::GetPeerAddress(IPEndPoint* address) const {
     return ERR_SOCKET_NOT_CONNECTED;
 
   if (!remote_address_.get()) {
-    struct sockaddr_storage addr_storage;
-    socklen_t addr_len = sizeof(addr_storage);
-    struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-    if (getpeername(socket_, addr, &addr_len))
+    SockaddrStorage storage;
+    if (getpeername(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(errno);
     scoped_ptr<IPEndPoint> address(new IPEndPoint());
-    if (!address->FromSockAddr(addr, addr_len))
+    if (!address->FromSockAddr(storage.addr, storage.addr_len))
       return ERR_FAILED;
     remote_address_.reset(address.release());
   }
@@ -117,13 +115,11 @@ int UDPSocketLibevent::GetLocalAddress(IPEndPoint* address) const {
     return ERR_SOCKET_NOT_CONNECTED;
 
   if (!local_address_.get()) {
-    struct sockaddr_storage addr_storage;
-    socklen_t addr_len = sizeof(addr_storage);
-    struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-    if (getsockname(socket_, addr, &addr_len))
+    SockaddrStorage storage;
+    if (getsockname(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(errno);
     scoped_ptr<IPEndPoint> address(new IPEndPoint());
-    if (!address->FromSockAddr(addr, addr_len))
+    if (!address->FromSockAddr(storage.addr, storage.addr_len))
       return ERR_FAILED;
     local_address_.reset(address.release());
   }
@@ -240,13 +236,11 @@ int UDPSocketLibevent::InternalConnect(const IPEndPoint& address) {
   if (rv < 0)
     return rv;
 
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_FAILED;
 
-  rv = HANDLE_EINTR(connect(socket_, addr, addr_len));
+  rv = HANDLE_EINTR(connect(socket_, storage.addr, storage.addr_len));
   if (rv < 0)
     return MapSystemError(errno);
 
@@ -393,41 +387,37 @@ int UDPSocketLibevent::InternalRecvFrom(IOBuffer* buf, int buf_len,
   int bytes_transferred;
   int flags = 0;
 
-  struct sockaddr_storage addr_storage;
-  socklen_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
+  SockaddrStorage storage;
 
   bytes_transferred =
       HANDLE_EINTR(recvfrom(socket_,
                             buf->data(),
                             buf_len,
                             flags,
-                            addr,
-                            &addr_len));
+                            storage.addr,
+                            &storage.addr_len));
   int result;
   if (bytes_transferred >= 0) {
     result = bytes_transferred;
-    if (address && !address->FromSockAddr(addr, addr_len))
+    if (address && !address->FromSockAddr(storage.addr, storage.addr_len))
       result = ERR_FAILED;
   } else {
     result = MapSystemError(errno);
   }
   if (result != ERR_IO_PENDING)
-    LogRead(result, buf->data(), addr_len, addr);
+    LogRead(result, buf->data(), storage.addr_len, storage.addr);
   return result;
 }
 
 int UDPSocketLibevent::InternalSendTo(IOBuffer* buf, int buf_len,
                                       const IPEndPoint* address) {
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-
+  SockaddrStorage storage;
+  struct sockaddr* addr = storage.addr;
   if (!address) {
     addr = NULL;
-    addr_len = 0;
+    storage.addr_len = 0;
   } else {
-    if (!address->ToSockAddr(addr, &addr_len)) {
+    if (!address->ToSockAddr(storage.addr, &storage.addr_len)) {
       int result = ERR_FAILED;
       LogWrite(result, NULL, NULL);
       return result;
@@ -439,7 +429,7 @@ int UDPSocketLibevent::InternalSendTo(IOBuffer* buf, int buf_len,
                             buf_len,
                             0,
                             addr,
-                            addr_len));
+                            storage.addr_len));
   if (result < 0)
     result = MapSystemError(errno);
   if (result != ERR_IO_PENDING)
@@ -448,12 +438,10 @@ int UDPSocketLibevent::InternalSendTo(IOBuffer* buf, int buf_len,
 }
 
 int UDPSocketLibevent::DoBind(const IPEndPoint& address) {
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_UNEXPECTED;
-  int rv = bind(socket_, addr, addr_len);
+  int rv = bind(socket_, storage.addr, storage.addr_len);
   return rv < 0 ? MapSystemError(errno) : rv;
 }
 
diff --git a/net/udp/udp_socket_unittest.cc b/net/udp/udp_socket_unittest.cc
index 5165d3d..ea8791a 100644
--- a/net/udp/udp_socket_unittest.cc
+++ b/net/udp/udp_socket_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -15,7 +15,6 @@
 #include "net/base/net_log_unittest.h"
 #include "net/base/net_test_suite.h"
 #include "net/base/net_util.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
diff --git a/net/udp/udp_socket_win.cc b/net/udp/udp_socket_win.cc
index 06f5e3d..423ba00 100644
--- a/net/udp/udp_socket_win.cc
+++ b/net/udp/udp_socket_win.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -94,14 +94,13 @@ int UDPSocketWin::GetPeerAddress(IPEndPoint* address) const {
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
+  // TODO(szym): Simplify. http://crbug.com/126152
   if (!remote_address_.get()) {
-    struct sockaddr_storage addr_storage;
-    int addr_len = sizeof(addr_storage);
-    struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-    if (getpeername(socket_, addr, &addr_len))
+    SockaddrStorage storage;
+    if (getpeername(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(WSAGetLastError());
     scoped_ptr<IPEndPoint> address(new IPEndPoint());
-    if (!address->FromSockAddr(addr, addr_len))
+    if (!address->FromSockAddr(storage.addr, storage.addr_len))
       return ERR_FAILED;
     remote_address_.reset(address.release());
   }
@@ -116,14 +115,13 @@ int UDPSocketWin::GetLocalAddress(IPEndPoint* address) const {
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
+  // TODO(szym): Simplify. http://crbug.com/126152
   if (!local_address_.get()) {
-    struct sockaddr_storage addr_storage;
-    socklen_t addr_len = sizeof(addr_storage);
-    struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-    if (getsockname(socket_, addr, &addr_len))
+    SockaddrStorage storage;
+    if (getsockname(socket_, storage.addr, &storage.addr_len))
       return MapSystemError(WSAGetLastError());
     scoped_ptr<IPEndPoint> address(new IPEndPoint());
-    if (!address->FromSockAddr(addr, addr_len))
+    if (!address->FromSockAddr(storage.addr, storage.addr_len))
       return ERR_FAILED;
     local_address_.reset(address.release());
   }
@@ -218,13 +216,11 @@ int UDPSocketWin::InternalConnect(const IPEndPoint& address) {
   if (rv < 0)
     return rv;
 
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_FAILED;
 
-  rv = connect(socket_, addr, addr_len);
+  rv = connect(socket_, storage.addr, storage.addr_len);
   if (rv < 0)
     return MapSystemError(WSAGetLastError());
 
@@ -401,16 +397,14 @@ int UDPSocketWin::InternalRecvFrom(IOBuffer* buf, int buf_len,
 
 int UDPSocketWin::InternalSendTo(IOBuffer* buf, int buf_len,
                                  const IPEndPoint* address) {
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-
+  SockaddrStorage storage;
+  struct sockaddr* addr = storage.addr;
   // Convert address.
   if (!address) {
     addr = NULL;
-    addr_len = 0;
+    storage.addr_len = 0;
   } else {
-    if (!address->ToSockAddr(addr, &addr_len)) {
+    if (!address->ToSockAddr(addr, &storage.addr_len)) {
       int result = ERR_FAILED;
       LogWrite(result, NULL, NULL);
       return result;
@@ -425,7 +419,7 @@ int UDPSocketWin::InternalSendTo(IOBuffer* buf, int buf_len,
   DWORD num;
   AssertEventNotSignaled(write_overlapped_.hEvent);
   int rv = WSASendTo(socket_, &write_buffer, 1, &num, flags,
-                     addr, addr_len, &write_overlapped_, NULL);
+                     addr, storage.addr_len, &write_overlapped_, NULL);
   if (rv == 0) {
     if (ResetEventIfSignaled(write_overlapped_.hEvent)) {
       int result = num;
@@ -446,12 +440,10 @@ int UDPSocketWin::InternalSendTo(IOBuffer* buf, int buf_len,
 }
 
 int UDPSocketWin::DoBind(const IPEndPoint& address) {
-  struct sockaddr_storage addr_storage;
-  size_t addr_len = sizeof(addr_storage);
-  struct sockaddr* addr = reinterpret_cast<struct sockaddr*>(&addr_storage);
-  if (!address.ToSockAddr(addr, &addr_len))
+  SockaddrStorage storage;
+  if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_UNEXPECTED;
-  int rv = bind(socket_, addr, addr_len);
+  int rv = bind(socket_, storage.addr, storage.addr_len);
   return rv < 0 ? MapSystemError(WSAGetLastError()) : rv;
 }
 
diff --git a/net/websockets/websocket_job_spdy2_unittest.cc b/net/websockets/websocket_job_spdy2_unittest.cc
index 05731f5..506056b 100644
--- a/net/websockets/websocket_job_spdy2_unittest.cc
+++ b/net/websockets/websocket_job_spdy2_unittest.cc
@@ -18,7 +18,6 @@
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/transport_security_state.h"
 #include "net/cookies/cookie_store.h"
@@ -407,16 +406,9 @@ class WebSocketJobSpdy2Test : public PlatformTest {
 
     websocket_->InitSocketStream(socket_.get());
     websocket_->set_context(context_.get());
-    struct addrinfo addr;
-    memset(&addr, 0, sizeof(struct addrinfo));
-    addr.ai_family = AF_INET;
-    addr.ai_addrlen = sizeof(struct sockaddr_in);
-    struct sockaddr_in sa_in;
-    memset(&sa_in, 0, sizeof(struct sockaddr_in));
-    memcpy(&sa_in.sin_addr, "\x7f\0\0\1", 4);
-    addr.ai_addr = reinterpret_cast<sockaddr*>(&sa_in);
-    addr.ai_next = NULL;
-    websocket_->addresses_ = AddressList::CreateByCopying(&addr);
+    IPAddressNumber ip;
+    ParseIPLiteralToNumber("127.0.0.1", &ip);
+    websocket_->addresses_ = AddressList::CreateFromIPAddress(ip, 0);
   }
   void SkipToConnecting() {
     websocket_->state_ = WebSocketJob::CONNECTING;
diff --git a/net/websockets/websocket_job_spdy3_unittest.cc b/net/websockets/websocket_job_spdy3_unittest.cc
index 9c908c8..e993289 100644
--- a/net/websockets/websocket_job_spdy3_unittest.cc
+++ b/net/websockets/websocket_job_spdy3_unittest.cc
@@ -18,7 +18,6 @@
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/transport_security_state.h"
 #include "net/cookies/cookie_store.h"
@@ -406,16 +405,9 @@ class WebSocketJobSpdy3Test : public PlatformTest {
 
     websocket_->InitSocketStream(socket_.get());
     websocket_->set_context(context_.get());
-    struct addrinfo addr;
-    memset(&addr, 0, sizeof(struct addrinfo));
-    addr.ai_family = AF_INET;
-    addr.ai_addrlen = sizeof(struct sockaddr_in);
-    struct sockaddr_in sa_in;
-    memset(&sa_in, 0, sizeof(struct sockaddr_in));
-    memcpy(&sa_in.sin_addr, "\x7f\0\0\1", 4);
-    addr.ai_addr = reinterpret_cast<sockaddr*>(&sa_in);
-    addr.ai_next = NULL;
-    websocket_->addresses_ = AddressList::CreateByCopying(&addr);
+    IPAddressNumber ip;
+    ParseIPLiteralToNumber("127.0.0.1", &ip);
+    websocket_->addresses_ = AddressList::CreateFromIPAddress(ip, 0);
   }
   void SkipToConnecting() {
     websocket_->state_ = WebSocketJob::CONNECTING;
diff --git a/net/websockets/websocket_throttle.cc b/net/websockets/websocket_throttle.cc
index 510dea4..61b4086 100644
--- a/net/websockets/websocket_throttle.cc
+++ b/net/websockets/websocket_throttle.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -14,36 +14,16 @@
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/socket_stream/socket_stream.h"
 #include "net/websockets/websocket_job.h"
 
 namespace net {
 
-static std::string AddrinfoToHashkey(const struct addrinfo* addrinfo) {
-  switch (addrinfo->ai_family) {
-    case AF_INET: {
-      const struct sockaddr_in* const addr =
-          reinterpret_cast<const sockaddr_in*>(addrinfo->ai_addr);
-      return base::StringPrintf("%d:%s",
-                                addrinfo->ai_family,
-                                base::HexEncode(&addr->sin_addr, 4).c_str());
-      }
-    case AF_INET6: {
-      const struct sockaddr_in6* const addr6 =
-          reinterpret_cast<const sockaddr_in6*>(addrinfo->ai_addr);
-      return base::StringPrintf(
-          "%d:%s",
-          addrinfo->ai_family,
-          base::HexEncode(&addr6->sin6_addr,
-                          sizeof(addr6->sin6_addr)).c_str());
-      }
-    default:
-      return base::StringPrintf("%d:%s",
-                                addrinfo->ai_family,
-                                base::HexEncode(addrinfo->ai_addr,
-                                                addrinfo->ai_addrlen).c_str());
-  }
+static std::string IPEndPointToHashkey(const IPEndPoint& endpoint) {
+  return base::StringPrintf("%d:%s",
+                            endpoint.GetFamily(),
+                            base::HexEncode(&endpoint.address()[0],
+                                            endpoint.address().size()).c_str());
 }
 
 WebSocketThrottle::WebSocketThrottle() {
@@ -63,10 +43,10 @@ void WebSocketThrottle::PutInQueue(WebSocketJob* job) {
   queue_.push_back(job);
   const AddressList& address_list = job->address_list();
   base::hash_set<std::string> address_set;
-  for (const struct addrinfo* addrinfo = address_list.head();
-       addrinfo != NULL;
-       addrinfo = addrinfo->ai_next) {
-    std::string addrkey = AddrinfoToHashkey(addrinfo);
+  for (AddressList::const_iterator addr_iter = address_list.begin();
+       addr_iter != address_list.end();
+       ++addr_iter) {
+    std::string addrkey = IPEndPointToHashkey(*addr_iter);
 
     // If |addrkey| is already processed, don't do it again.
     if (address_set.find(addrkey) != address_set.end())
@@ -101,10 +81,10 @@ void WebSocketThrottle::RemoveFromQueue(WebSocketJob* job) {
     return;
   const AddressList& address_list = job->address_list();
   base::hash_set<std::string> address_set;
-  for (const struct addrinfo* addrinfo = address_list.head();
-       addrinfo != NULL;
-       addrinfo = addrinfo->ai_next) {
-    std::string addrkey = AddrinfoToHashkey(addrinfo);
+  for (AddressList::const_iterator addr_iter = address_list.begin();
+       addr_iter != address_list.end();
+       ++addr_iter) {
+    std::string addrkey = IPEndPointToHashkey(*addr_iter);
     // If |addrkey| is already processed, don't do it again.
     if (address_set.find(addrkey) != address_set.end())
       continue;
@@ -140,10 +120,10 @@ void WebSocketThrottle::WakeupSocketIfNecessary() {
 
     bool should_wakeup = true;
     const AddressList& address_list = job->address_list();
-    for (const struct addrinfo* addrinfo = address_list.head();
-         addrinfo != NULL;
-         addrinfo = addrinfo->ai_next) {
-      std::string addrkey = AddrinfoToHashkey(addrinfo);
+    for (AddressList::const_iterator addr_iter = address_list.begin();
+         addr_iter != address_list.end();
+         ++addr_iter) {
+      std::string addrkey = IPEndPointToHashkey(*addr_iter);
       ConnectingAddressMap::iterator iter = addr_map_.find(addrkey);
       DCHECK(iter != addr_map_.end());
       ConnectingQueue* queue = iter->second;
diff --git a/net/websockets/websocket_throttle_unittest.cc b/net/websockets/websocket_throttle_unittest.cc
index 4044044..734a9f9 100644
--- a/net/websockets/websocket_throttle_unittest.cc
+++ b/net/websockets/websocket_throttle_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -9,7 +9,6 @@
 #include "base/message_loop.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/address_list.h"
-#include "net/base/sys_addrinfo.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket_stream/socket_stream.h"
 #include "net/url_request/url_request_test_util.h"
@@ -33,39 +32,18 @@ namespace net {
 
 class WebSocketThrottleTest : public PlatformTest {
  protected:
-  struct addrinfo *AddAddr(int a1, int a2, int a3, int a4,
-                           struct addrinfo* next) {
-    struct addrinfo* addrinfo = new struct addrinfo;
-    memset(addrinfo, 0, sizeof(struct addrinfo));
-    addrinfo->ai_family = AF_INET;
-    int addrlen = sizeof(struct sockaddr_in);
-    addrinfo->ai_addrlen = addrlen;
-    addrinfo->ai_addr = reinterpret_cast<sockaddr*>(new char[addrlen]);
-    memset(addrinfo->ai_addr, 0, sizeof(addrlen));
-    struct sockaddr_in* addr =
-        reinterpret_cast<sockaddr_in*>(addrinfo->ai_addr);
-    int addrint = ((a1 & 0xff) << 24) |
-        ((a2 & 0xff) << 16) |
-        ((a3 & 0xff) <<  8) |
-        ((a4 & 0xff));
-    memcpy(&addr->sin_addr, &addrint, sizeof(int));
-    addrinfo->ai_next = next;
-    return addrinfo;
-  }
-  void DeleteAddrInfo(struct addrinfo* head) {
-    if (!head)
-      return;
-    struct addrinfo* next;
-    for (struct addrinfo* a = head; a != NULL; a = next) {
-      next = a->ai_next;
-      delete [] a->ai_addr;
-      delete a;
-    }
+  IPEndPoint MakeAddr(int a1, int a2, int a3, int a4) {
+    IPAddressNumber ip;
+    ip.push_back(a1);
+    ip.push_back(a2);
+    ip.push_back(a3);
+    ip.push_back(a4);
+    return IPEndPoint(ip, 0);
   }
 
   static void MockSocketStreamConnect(
-      SocketStream* socket, struct addrinfo* head) {
-    socket->CopyAddrInfo(head);
+      SocketStream* socket, const AddressList& list) {
+    socket->set_addresses(list);
     // TODO(toyoshim): We should introduce additional tests on cases via proxy.
     socket->proxy_info_.UseDirect();
     // In SocketStream::Connect(), it adds reference to socket, which is
@@ -88,16 +66,16 @@ TEST_F(WebSocketThrottleTest, Throttle) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
 
   // For host1: 1.2.3.4, 1.2.3.5, 1.2.3.6
-  struct addrinfo* addr = AddAddr(1, 2, 3, 4, NULL);
-  addr = AddAddr(1, 2, 3, 5, addr);
-  addr = AddAddr(1, 2, 3, 6, addr);
+  AddressList addr;
+  addr.push_back(MakeAddr(1, 2, 3, 4));
+  addr.push_back(MakeAddr(1, 2, 3, 5));
+  addr.push_back(MakeAddr(1, 2, 3, 6));
   scoped_refptr<WebSocketJob> w1(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s1(
       new SocketStream(GURL("ws://host1/"), w1.get()));
   s1->set_context(context.get());
   w1->InitSocketStream(s1.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s1, addr);
-  DeleteAddrInfo(addr);
 
   DVLOG(1) << "socket1";
   TestCompletionCallback callback_s1;
@@ -111,14 +89,14 @@ TEST_F(WebSocketThrottleTest, Throttle) {
   // 1.2.3.6 | w1
 
   // For host2: 1.2.3.4
-  addr = AddAddr(1, 2, 3, 4, NULL);
+  addr.clear();
+  addr.push_back(MakeAddr(1, 2, 3, 4));
   scoped_refptr<WebSocketJob> w2(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s2(
       new SocketStream(GURL("ws://host2/"), w2.get()));
   s2->set_context(context.get());
   w2->InitSocketStream(s2.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s2, addr);
-  DeleteAddrInfo(addr);
 
   DVLOG(1) << "socket2";
   TestCompletionCallback callback_s2;
@@ -132,14 +110,14 @@ TEST_F(WebSocketThrottleTest, Throttle) {
   // 1.2.3.6 | w1
 
   // For host3: 1.2.3.5
-  addr = AddAddr(1, 2, 3, 5, NULL);
+  addr.clear();
+  addr.push_back(MakeAddr(1, 2, 3, 5));
   scoped_refptr<WebSocketJob> w3(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s3(
       new SocketStream(GURL("ws://host3/"), w3.get()));
   s3->set_context(context.get());
   w3->InitSocketStream(s3.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s3, addr);
-  DeleteAddrInfo(addr);
 
   DVLOG(1) << "socket3";
   TestCompletionCallback callback_s3;
@@ -152,15 +130,15 @@ TEST_F(WebSocketThrottleTest, Throttle) {
   // 1.2.3.6 | w1
 
   // For host4: 1.2.3.4, 1.2.3.6
-  addr = AddAddr(1, 2, 3, 4, NULL);
-  addr = AddAddr(1, 2, 3, 6, addr);
+  addr.clear();
+  addr.push_back(MakeAddr(1, 2, 3, 4));
+  addr.push_back(MakeAddr(1, 2, 3, 6));
   scoped_refptr<WebSocketJob> w4(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s4(
       new SocketStream(GURL("ws://host4/"), w4.get()));
   s4->set_context(context.get());
   w4->InitSocketStream(s4.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s4, addr);
-  DeleteAddrInfo(addr);
 
   DVLOG(1) << "socket4";
   TestCompletionCallback callback_s4;
@@ -173,14 +151,14 @@ TEST_F(WebSocketThrottleTest, Throttle) {
   // 1.2.3.6 | w1       w4
 
   // For host5: 1.2.3.6
-  addr = AddAddr(1, 2, 3, 6, NULL);
+  addr.clear();
+  addr.push_back(MakeAddr(1, 2, 3, 6));
   scoped_refptr<WebSocketJob> w5(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s5(
       new SocketStream(GURL("ws://host5/"), w5.get()));
   s5->set_context(context.get());
   w5->InitSocketStream(s5.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s5, addr);
-  DeleteAddrInfo(addr);
 
   DVLOG(1) << "socket5";
   TestCompletionCallback callback_s5;
@@ -193,14 +171,14 @@ TEST_F(WebSocketThrottleTest, Throttle) {
   // 1.2.3.6 | w1       w4 w5
 
   // For host6: 1.2.3.6
-  addr = AddAddr(1, 2, 3, 6, NULL);
+  addr.clear();
+  addr.push_back(MakeAddr(1, 2, 3, 6));
   scoped_refptr<WebSocketJob> w6(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s6(
       new SocketStream(GURL("ws://host6/"), w6.get()));
   s6->set_context(context.get());
   w6->InitSocketStream(s6.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s6, addr);
-  DeleteAddrInfo(addr);
 
   DVLOG(1) << "socket6";
   TestCompletionCallback callback_s6;
@@ -305,15 +283,15 @@ TEST_F(WebSocketThrottleTest, NoThrottleForDuplicateAddress) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
 
   // For localhost: 127.0.0.1, 127.0.0.1
-  struct addrinfo* addr = AddAddr(127, 0, 0, 1, NULL);
-  addr = AddAddr(127, 0, 0, 1, addr);
+  AddressList addr;
+  addr.push_back(MakeAddr(127, 0, 0, 1));
+  addr.push_back(MakeAddr(127, 0, 0, 1));
   scoped_refptr<WebSocketJob> w1(new WebSocketJob(&delegate));
   scoped_refptr<SocketStream> s1(
       new SocketStream(GURL("ws://localhost/"), w1.get()));
   s1->set_context(context.get());
   w1->InitSocketStream(s1.get());
   WebSocketThrottleTest::MockSocketStreamConnect(s1, addr);
-  DeleteAddrInfo(addr);
 
   DVLOG(1) << "socket1";
   TestCompletionCallback callback_s1;