[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 91236b3c622369e69cec99a4fdae3e5c328c6a67..0922e5c63d57a0292e83b9cefa573006337fa38f 100644
--- a/net/base/host_resolver_impl_unittest.cc
+++ b/net/base/host_resolver_impl_unittest.cc
@@ -1236,21 +1236,43 @@ DnsConfig CreateValidDnsConfig() {
 class HostResolverImplDnsTest : public HostResolverImplTest {
  protected:
   virtual void SetUp() OVERRIDE {
+    AddDnsRule("er", dns_protocol::kTypeA, MockDnsClientRule::FAIL_SYNC);
+    AddDnsRule("er", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL_SYNC);
+    AddDnsRule("nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL_ASYNC);
+    AddDnsRule("nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL_ASYNC);
+    AddDnsRule("ok", dns_protocol::kTypeA, MockDnsClientRule::OK);
+    AddDnsRule("ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK);
+    AddDnsRule("4ok", dns_protocol::kTypeA, MockDnsClientRule::OK);
+    AddDnsRule("4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY);
+    AddDnsRule("6ok", dns_protocol::kTypeA, MockDnsClientRule::EMPTY);
+    AddDnsRule("6ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK);
+    CreateResolver();
+  }
+
+  void CreateResolver() {
     config_service_ = new MockDnsConfigService();
     resolver_.reset(new HostResolverImpl(
         HostCache::CreateDefaultCache(),
         DefaultLimits(),
         DefaultParams(proc_),
         scoped_ptr<DnsConfigService>(config_service_),
-        CreateMockDnsClient(DnsConfig()),
+        CreateMockDnsClient(DnsConfig(), dns_rules_),
         NULL));
   }
 
+  void AddDnsRule(const std::string& prefix,
+                  uint16 qtype,
+                  MockDnsClientRule::Result result) {
+    MockDnsClientRule rule = { prefix, qtype, result };
+    dns_rules_.push_back(rule);
+  }
+
   void ChangeDnsConfig(const DnsConfig& config) {
     config_service_->ChangeConfig(config);
     config_service_->ChangeHosts(config.hosts);
   }
 
+  MockDnsClientRuleList dns_rules_;
   // Owned by |resolver_|.
   MockDnsConfigService* config_service_;
 };
@@ -1298,6 +1320,24 @@ TEST_F(HostResolverImplDnsTest, DnsTask) {
   EXPECT_TRUE(requests_[5]->HasOneAddress("192.168.1.102", 80));
 }
 
+TEST_F(HostResolverImplDnsTest, DnsTaskUnspec) {

[mmenke, 2012/07/30 15:37:00]

Should we do any verification of sort order?

[szym, 2012/07/30 16:28:45]

In this test, the AddressSorter is a mock so it does not perform any sorting. We
could verify that IPv6 are expected before IPv4 (see DnsTask), but are we fully
certain that we will be keeping this behavior?

[mmenke1, 2012/07/30 17:19:06]

I was thinking more along the lines of Linux-specific tests for ordering, and
maybe a general Windows one just to exercise the code and make sure we get out
what we put in.

+  ChangeDnsConfig(CreateValidDnsConfig());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4ok", 80)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("6ok", 80)->Resolve());
+
+  for (size_t i = 0; i < requests_.size(); ++i)
+    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
+
+  EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
+  EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
+  EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
+  EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
+  EXPECT_EQ(1u, requests_[1]->NumberOfAddresses());
+  EXPECT_TRUE(requests_[2]->HasAddress("::1", 80));
+  EXPECT_EQ(1u, requests_[2]->NumberOfAddresses());

[mmenke, 2012/07/30 15:37:00]

nit:  The general convention (Both in Chrome and elsewhere in this file) is to
check the number before individual items.

+}
+
 TEST_F(HostResolverImplDnsTest, ServeFromHosts) {
   // Initially, use empty HOSTS file.
   ChangeDnsConfig(CreateValidDnsConfig());