Reimplements net::AddressList without struct addrinfo.

net/dns/dns_response_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/dns/dns_response.h"
 
 #include "base/time.h"
 #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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 TEST(DnsRecordParserTest, Constructor) {
@@ skipping 219 matching lines @@
   DnsRecordParser parser = resp.Parser();
   EXPECT_TRUE(parser.ReadRecord(&record));
   EXPECT_FALSE(parser.AtEnd());
   EXPECT_TRUE(parser.ReadRecord(&record));
   EXPECT_TRUE(parser.AtEnd());
   EXPECT_FALSE(parser.ReadRecord(&record));
 }
 
 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());
+  ASSERT_EQ(ip_addresses.size(), addrlist.size());
 
-  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());
+  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) {
   const struct TestCase {
     size_t query_size;
     const uint8* response_data;
     size_t response_size;
     const char* const* expected_addresses;
     size_t num_expected_addresses;
     const char* expected_cname;
@@ skipping 33 matching lines @@
     const TestCase& t = cases[i];
     DnsResponse response(t.response_data, t.response_size, t.query_size);
     AddressList addr_list;
     base::TimeDelta ttl;
     EXPECT_EQ(DnsResponse::DNS_SUCCESS,
               response.ParseToAddressList(&addr_list, &ttl));
     std::vector<const char*> expected_addresses(
         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);
   }
 }
 
 const uint8 kResponseTruncatedRecord[] = {
   // Header: 1 question, 1 answer RR
   0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
   // Question: name = 'a', type = A (0x1)
   0x01,  'a', 0x00, 0x00, 0x01, 0x00, 0x01,
   // Answer: name = 'a', type = A, TTL = 0xFF, RDATA = 10.10.10.10
@@ skipping 123 matching lines @@
     AddressList addr_list;
     base::TimeDelta ttl;
     EXPECT_EQ(t.expected_result,
               response.ParseToAddressList(&addr_list, &ttl));
   }
 }
 
 }  // namespace
 
 }  // namespace net