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

net/base/host_resolver_impl_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/host_resolver_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 25 matching lines @@
 PrioritizedDispatcher::Limits DefaultLimits() {
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, kMaxJobs);
   return limits;
 }
 
 HostResolverImpl::ProcTaskParams DefaultParams(
     HostResolverProc* resolver_proc) {
   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
 // "127.0.0.1". After AddRule(), it resolves only names explicitly specified.
 class MockHostResolverProc : public HostResolverProc {
  public:
   struct ResolveKey {
     ResolveKey(const std::string& hostname, AddressFamily address_family)
         : hostname(hostname), address_family(address_family) {}
     bool operator<(const ResolveKey& other) const {
@@ skipping 344 matching lines @@
   base::ConditionVariable all_done_;
 };
 
 }  // namespace
 
 class HostResolverImplTest : public testing::Test {
  public:
   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:
   // A Request::Handler which is a proxy to the HostResolverImplTest fixture.
   struct Handler : public Request::Handler {
     virtual ~Handler() {}
 
     // Proxy functions so that classes derived from Handler can access them.
     Request* CreateRequest(const HostResolver::RequestInfo& info) {
       return test->CreateRequest(info);
     }
     Request* CreateRequest(const std::string& hostname, int port) {
       return test->CreateRequest(hostname, port);
     }
     Request* CreateRequest(const std::string& hostname) {
       return test->CreateRequest(hostname);
     }
     ScopedVector<Request>& requests() { return test->requests_; }
 
     void DeleteResolver() { test->resolver_.reset(); }
 
     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
   // not start until released by |proc_->SignalXXX|.
   Request* CreateRequest(const HostResolver::RequestInfo& info) {
     Request* req = new Request(info, requests_.size(), resolver_.get(),
                                handler_.get());
     requests_.push_back(req);
     return req;
   }
@@ skipping 15 matching lines @@
   }
 
   Request* CreateRequest(const std::string& hostname, int port) {
     return CreateRequest(hostname, port, MEDIUM);
   }
 
   Request* CreateRequest(const std::string& hostname) {
     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());
   }
 
   void set_handler(Handler* handler) {
     handler_.reset(handler);
     handler_->test = this;
   }
 
@@ skipping 42 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());
 
   EXPECT_TRUE(proc_->WaitFor(1u));
 
   // Resolver is destroyed while job is running on WorkerPool.
   resolver_.reset();
 
   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());
 
   proc_->SignalMultiple(2u);
 
   EXPECT_EQ(OK, req1->WaitForResult());
 
   // This request was canceled.
   EXPECT_FALSE(req0->completed());
 }
@@ skipping 656 matching lines @@
   IPAddressNumber dns_ip;
   bool rv = ParseIPLiteralToNumber("192.168.1.0", &dns_ip);
   EXPECT_TRUE(rv);
 
   DnsConfig config;
   config.nameservers.push_back(IPEndPoint(dns_ip, dns_protocol::kDefaultPort));
   EXPECT_TRUE(config.IsValid());
   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");
   // All other hostnames will fail in proc_.
 
   // Initially there is no config, so client should not be invoked.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
   proc_->SignalMultiple(requests_->size());
 
   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());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("er_succeed", 80)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve());
 
   proc_->SignalMultiple(requests_.size());
 
   for (size_t i = 0; i < requests_.size(); ++i) {
     EXPECT_NE(ERR_UNEXPECTED, requests_[i]->WaitForResult()) << 1;
   }
 
   EXPECT_EQ(OK, requests_[1]->result());
   // Resolved by MockDnsClient.
   EXPECT_TRUE(requests_[1]->HasOneAddress("127.0.0.1", 80));
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[2]->result());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[3]->result());
   EXPECT_EQ(OK, requests_[4]->result());
   EXPECT_TRUE(requests_[4]->HasOneAddress("192.168.1.101", 80));
   EXPECT_EQ(OK, requests_[5]->result());
   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.
 
   Request* req0 = CreateRequest("er_ipv4", 80);
   EXPECT_EQ(ERR_IO_PENDING, req0->Resolve());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req0->WaitForResult());
 
   IPAddressNumber local_ipv4, local_ipv6;
   ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4));
   ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6));
 
   DnsHosts hosts;
   hosts[DnsHostsKey("er_ipv4", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   hosts[DnsHostsKey("er_ipv6", ADDRESS_FAMILY_IPV6)] = local_ipv6;
   hosts[DnsHostsKey("er_both", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   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());
   EXPECT_TRUE(req1->HasOneAddress("127.0.0.1", 80));
 
   Request* req2 = CreateRequest("er_ipv6", 80);
   EXPECT_EQ(OK, req2->Resolve());
   EXPECT_TRUE(req2->HasOneAddress("::1", 80));
 
   Request* req3 = CreateRequest("er_both", 80);
@@ skipping 10 matching lines @@
   EXPECT_EQ(OK, req5->Resolve());
   EXPECT_TRUE(req5->HasOneAddress("::1", 80));
 
   // Request with upper case.
   Request* req6 = CreateRequest("er_IPV4", 80);
   EXPECT_EQ(OK, req6->Resolve());
   EXPECT_TRUE(req6->HasOneAddress("127.0.0.1", 80));
 }
 
 }  // namespace net