[net] HostResolverImpl + DnsTransaction + DnsConfigService = Asynchronous DNS ready for experiments.

net/base/address_list_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/base/address_list.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "net/base/host_resolver_proc.h"
 #include "net/base/net_util.h"
@@ skipping 198 matching lines @@
                                &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();
 
     IPAddressNumber ip_number;
-    ParseIPLiteralToNumber(tests[i].ip_address, &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();
 
     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;
@@ skipping 68 matching lines @@
       sizeof(struct in6_addr),
     },
     { "192.168.1.1",
       "\xc0\xa8\x01\x01",
       AF_INET,
       sizeof(struct sockaddr_in),
       offsetof(struct sockaddr_in, sin_addr),
       sizeof(struct in_addr),
     },
   };
-  const uint16 kPort = 80;
+  const std::string kCanonicalName = "canonical.example.com";
 
   // Construct a list of ip addresses.
   IPAddressList ip_list;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     IPAddressNumber ip_number;
-    ParseIPLiteralToNumber(tests[i].ip_address, &ip_number);
+    ASSERT_TRUE(ParseIPLiteralToNumber(tests[i].ip_address, &ip_number));
     ip_list.push_back(ip_number);
   }
 
-  AddressList test_list = AddressList::CreateFromIPAddressList(ip_list, kPort);
-  EXPECT_EQ(kPort, test_list.GetPort());
+  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);
 }
 
 }  // namespace
 }  // namespace net