[net/dns] Resolve AF_UNSPEC on dual-stacked systems. Sort addresses according to RFC3484.

net/base/host_resolver_impl_unittest.cc

Index: net/base/host_resolver_impl_unittest.cc
diff --git a/net/base/host_resolver_impl_unittest.cc b/net/base/host_resolver_impl_unittest.cc
index 60d6ed116693621d4031e268851d4e008984de91..14774663448352ffe85debd00efb57107e0e114f 100644
--- a/net/base/host_resolver_impl_unittest.cc
+++ b/net/base/host_resolver_impl_unittest.cc
@@ -43,46 +43,6 @@ HostResolverImpl::ProcTaskParams DefaultParams(
   return HostResolverImpl::ProcTaskParams(resolver_proc, kMaxRetryAttempts);
 }
 
-HostResolverImpl* CreateHostResolverImpl(HostResolverProc* resolver_proc) {
-  return new HostResolverImpl(
-      HostCache::CreateDefaultCache(),
-      DefaultLimits(),
-      DefaultParams(resolver_proc),
-      scoped_ptr<DnsConfigService>(NULL),
-      scoped_ptr<DnsClient>(NULL),
-      NULL);
-}
-
-HostResolverImpl* CreateHostResolverImplWithDnsClient(
-    HostResolverProc* resolver_proc,
-    scoped_ptr<DnsConfigService> dns_config_service) {
-  // Initially with empty DnsConfig. Use |dns_config_service| to update it.
-  return new HostResolverImpl(
-      HostCache::CreateDefaultCache(),
-      DefaultLimits(),
-      DefaultParams(resolver_proc),
-      dns_config_service.Pass(),
-      CreateMockDnsClient(DnsConfig()),
-      NULL);
-}
-
-// This HostResolverImpl will only allow 1 outstanding resolve at a time.
-HostResolverImpl* CreateSerialHostResolverImpl(
-    HostResolverProc* resolver_proc) {
-  HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc);
-  params.max_retry_attempts = 0u;
-
-  PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
-
-  return new HostResolverImpl(
-      HostCache::CreateDefaultCache(),
-      limits,
-      params,
-      scoped_ptr<DnsConfigService>(NULL),
-      scoped_ptr<DnsClient>(NULL),
-      NULL);
-}
-
 // A HostResolverProc that pushes each host mapped into a list and allows
 // waiting for a specific number of requests. Unlike RuleBasedHostResolverProc
 // it never calls SystemHostResolverProc. By default resolves all hostnames to
@@ -447,8 +407,7 @@ class HostResolverImplTest : public testing::Test {
   static const int kDefaultPort = 80;
 
   HostResolverImplTest()
-      : proc_(new MockHostResolverProc()),
-        resolver_(CreateHostResolverImpl(proc_)) {
+      : proc_(new MockHostResolverProc()) {

[mmenke, 2012/06/07 18:32:34]

nit:  Think this can all fit on one line now.

   }
 
  protected:
@@ -473,8 +432,29 @@ class HostResolverImplTest : public testing::Test {
     HostResolverImplTest* test;
   };
 
+  void CreateResolver() {
+    resolver_.reset(new HostResolverImpl(
+        HostCache::CreateDefaultCache(),
+        DefaultLimits(),
+        DefaultParams(proc_),
+        scoped_ptr<DnsConfigService>(NULL),
+        scoped_ptr<DnsClient>(NULL),
+        NULL));
+  }
+
+  // This HostResolverImpl will only allow 1 outstanding resolve at a time and
+  // perform no retries.
   void CreateSerialResolver() {
-    resolver_.reset(CreateSerialHostResolverImpl(proc_));
+    HostResolverImpl::ProcTaskParams params = DefaultParams(proc_);
+    params.max_retry_attempts = 0u;
+    PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
+    resolver_.reset(new HostResolverImpl(
+        HostCache::CreateDefaultCache(),
+        limits,
+        params,
+        scoped_ptr<DnsConfigService>(NULL),
+        scoped_ptr<DnsClient>(NULL),
+        NULL));
   }
 
   // The Request will not be made until a call to |Resolve()|, and the Job will
@@ -510,7 +490,11 @@ class HostResolverImplTest : public testing::Test {
     return CreateRequest(hostname, kDefaultPort);
   }
 
-  void TearDown() OVERRIDE {
+  virtual void SetUp() OVERRIDE {
+    CreateResolver();
+  }
+
+  virtual void TearDown() OVERRIDE {
     if (resolver_.get())
       EXPECT_EQ(0u, resolver_->num_running_jobs_for_tests());
     EXPECT_FALSE(proc_->HasBlockedRequests());
@@ -573,7 +557,7 @@ TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) {
   proc_->SignalAll();
 
   // To ensure there was no spurious callback, complete with a new resolver.
-  resolver_.reset(CreateHostResolverImpl(proc_));
+  CreateResolver();
   Request* req1 = CreateRequest("just.testing", 80);
   EXPECT_EQ(ERR_IO_PENDING, req1->Resolve());
 
@@ -1250,19 +1234,36 @@ DnsConfig CreateValidDnsConfig() {
   return config;
 }
 
+// Specialized fixture for tests of DnsTask.
+class HostResolverImplDnsTest : public HostResolverImplTest {
+ protected:
+  virtual void SetUp() OVERRIDE {
+    config_service_ = new MockDnsConfigService();
+    resolver_.reset(new HostResolverImpl(
+        HostCache::CreateDefaultCache(),
+        DefaultLimits(),
+        DefaultParams(proc_),
+        scoped_ptr<DnsConfigService>(config_service_),
+        CreateMockDnsClient(DnsConfig()),
+        NULL));
+  }
+
+  void ChangeDnsConfig(const DnsConfig& config) {
+    config_service_->ChangeConfig(config);
+    config_service_->ChangeHosts(config.hosts);
+  }
+
+  // Owned by |resolver_|.
+  MockDnsConfigService* config_service_;
+};
+
 // TODO(szym): Test AbortAllInProgressJobs due to DnsConfig change.
 
 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
 
 // Test successful and fallback resolutions in HostResolverImpl::DnsTask.
-TEST_F(HostResolverImplTest, DnsTask) {
-  // Initially, there's DnsConfigService, but no DnsConfig.
-  // Note, |config_service| will be owned by |resolver_|.
-  MockDnsConfigService* config_service = new MockDnsConfigService();
-  resolver_.reset(
-      CreateHostResolverImplWithDnsClient(
-          proc_,
-          scoped_ptr<DnsConfigService>(config_service)));
+TEST_F(HostResolverImplDnsTest, DnsTask) {
+  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
   proc_->AddRuleForAllFamilies("er_succeed", "192.168.1.101");
   proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
@@ -1274,9 +1275,7 @@ TEST_F(HostResolverImplTest, DnsTask) {
 
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
 
-  DnsConfig config = CreateValidDnsConfig();
-  config_service->ChangeHosts(config.hosts);
-  config_service->ChangeConfig(config);
+  ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("er_fail", 80)->Resolve());
@@ -1301,18 +1300,19 @@ TEST_F(HostResolverImplTest, DnsTask) {
   EXPECT_TRUE(requests_[5]->HasOneAddress("192.168.1.102", 80));
 }
 
-TEST_F(HostResolverImplTest, ServeFromHosts) {
-  // Note, |config_service| will be owned by |resolver_|.
-  MockDnsConfigService* config_service = new MockDnsConfigService();
-  resolver_.reset(
-      CreateHostResolverImplWithDnsClient(
-          proc_,
-          scoped_ptr<DnsConfigService>(config_service)));
+TEST_F(HostResolverImplDnsTest, DnsTaskDual) {
+  ChangeDnsConfig(CreateValidDnsConfig());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());

[mmenke, 2012/06/07 18:32:34]

I think "ok_fail" is a somewhat strange name for a request that succeeds.  Only
makes sense in that above test because it fails the first time.

+
+  EXPECT_EQ(OK, requests_[0]->WaitForResult());
+  EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
+  EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
+  EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
+}

[mmenke, 2012/06/07 18:32:34]

I'd like to see test where the MockDnsTransaction succeeds with only an IPv4
result, and only an ipv6 result.

 
+TEST_F(HostResolverImplDnsTest, ServeFromHosts) {
   // Initially, use empty HOSTS file.
-  DnsConfig config = CreateValidDnsConfig();
-  config_service->ChangeHosts(DnsHosts());
-  config_service->ChangeConfig(config);
+  ChangeDnsConfig(CreateValidDnsConfig());
 
   proc_->AddRuleForAllFamilies("", "0.0.0.0");  // Default to failures.
   proc_->SignalMultiple(1u);  // For the first request which misses.
@@ -1332,8 +1332,7 @@ TEST_F(HostResolverImplTest, ServeFromHosts) {
   hosts[DnsHostsKey("er_both", ADDRESS_FAMILY_IPV6)] = local_ipv6;
 
   // Update HOSTS file.
-  config_service->ChangeConfig(config);
-  config_service->ChangeHosts(hosts);
+  config_service_->ChangeHosts(hosts);
 
   Request* req1 = CreateRequest("er_ipv4", 80);
   EXPECT_EQ(OK, req1->Resolve());