Make ERR_ICANN_NAME_COLLISION work for async DNS resolver.

net/dns/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/dns/host_resolver_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <tuple>
@@ skipping 1468 matching lines @@
   resolver_proc->WaitForAllAttemptsToFinish(
       base::TimeDelta::FromMilliseconds(60000));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts);
   EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve);
 }
 
 // If a host resolves to a list that includes 127.0.53.53, this is treated as
 // an error. 127.0.53.53 is a localhost address, however it has been given a
-// special significance by ICANN to help surfance name collision resulting from
+// special significance by ICANN to help surface name collision resulting from
 // the new gTLDs.
-TEST_F(HostResolverImplTest, NameCollision127_0_53_53) {
+TEST_F(HostResolverImplTest, NameCollisionIcann) {
   proc_->AddRuleForAllFamilies("single", "127.0.53.53");
   proc_->AddRuleForAllFamilies("multiple", "127.0.0.1,127.0.53.53");
   proc_->AddRuleForAllFamilies("ipv6", "::127.0.53.53");
   proc_->AddRuleForAllFamilies("not_reserved1", "53.53.0.127");
   proc_->AddRuleForAllFamilies("not_reserved2", "127.0.53.54");
   proc_->AddRuleForAllFamilies("not_reserved3", "10.0.53.53");
   proc_->SignalMultiple(6u);
 
   Request* request;
 
@@ skipping 106 matching lines @@
     AddDnsRule("4slow_4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY,
                false);
     AddDnsRule("4slow_4timeout", dns_protocol::kTypeA,
                MockDnsClientRule::TIMEOUT, true);
     AddDnsRule("4slow_4timeout", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
                false);
     AddDnsRule("4slow_6timeout", dns_protocol::kTypeA,
                MockDnsClientRule::OK, true);
     AddDnsRule("4slow_6timeout", dns_protocol::kTypeAAAA,
                MockDnsClientRule::TIMEOUT, false);
+    AddDnsRule("4collision", dns_protocol::kTypeA, IPAddress(127, 0, 53, 53),
+               false);
+    AddDnsRule("4collision", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY,
+               false);
+    AddDnsRule("6collision", dns_protocol::kTypeA, MockDnsClientRule::EMPTY,
+               false);
+    // This isn't the expected IP for collisions (but looks close to it).
+    AddDnsRule("6collision", dns_protocol::kTypeAAAA,
+               IPAddress(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 0, 53, 53),
+               false);
     CreateResolver();
   }
 
   // HostResolverImplTest implementation:
   void CreateResolverWithLimitsAndParams(
       size_t max_concurrent_resolves,
       const HostResolverImpl::ProcTaskParams& params) override {
     HostResolverImpl::Options options = DefaultOptions();
     options.max_concurrent_resolves = max_concurrent_resolves;
     resolver_.reset(new TestHostResolverImpl(options, NULL));
     resolver_->set_proc_params_for_test(params);
     dns_client_ = new MockDnsClient(DnsConfig(), dns_rules_);
     resolver_->SetDnsClient(std::unique_ptr<DnsClient>(dns_client_));
   }
 
   // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply.
   void AddDnsRule(const std::string& prefix,
                   uint16_t qtype,
+                  MockDnsClientRule::ResultType result_type,
+                  bool delay) {
+    return AddDnsRule(prefix, qtype, MockDnsClientRule::Result(result_type),
+                      delay);
+  }
+
+  void AddDnsRule(const std::string& prefix,
+                  uint16_t qtype,
+                  const IPAddress& result_ip,
+                  bool delay) {
+    return AddDnsRule(prefix, qtype, MockDnsClientRule::Result(result_ip),
+                      delay);
+  }
+
+  void AddDnsRule(const std::string& prefix,
+                  uint16_t qtype,
                   MockDnsClientRule::Result result,
                   bool delay) {
     dns_rules_.push_back(MockDnsClientRule(prefix, qtype, result, delay));
   }
 
   void ChangeDnsConfig(const DnsConfig& config) {
     NetworkChangeNotifier::SetDnsConfig(config);
     // Notification is delivered asynchronously.
     base::RunLoop().RunUntilIdle();
   }
@@ skipping 139 matching lines @@
   EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
   EXPECT_EQ(1u, requests_[1]->NumberOfAddresses());
   EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
   EXPECT_EQ(1u, requests_[2]->NumberOfAddresses());
   EXPECT_TRUE(requests_[2]->HasAddress("::1", 80));
   EXPECT_EQ(1u, requests_[3]->NumberOfAddresses());
   EXPECT_TRUE(requests_[3]->HasAddress("192.168.1.101", 80));
 }
 
+TEST_F(HostResolverImplDnsTest, NameCollisionIcann) {
+  ChangeDnsConfig(CreateValidDnsConfig());
+
+  // When the resolver returns an A record with 127.0.53.53 it should be mapped
+  // to a special error.
+  EXPECT_THAT(CreateRequest("4collision", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION));
+
+  // When the resolver returns an AAAA record with ::127.0.53.53 it should
+  // work just like any other IP. (Despite having the same suffix, it is not
+  // considered special)
+  EXPECT_THAT(CreateRequest("6collision", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+
+  EXPECT_THAT(requests_[1]->WaitForResult(), IsError(OK));
+  EXPECT_TRUE(requests_[1]->HasAddress("::127.0.53.53", 80));
+}
+
 TEST_F(HostResolverImplDnsTest, ServeFromHosts) {
   // Initially, use empty HOSTS file.
   DnsConfig config = CreateValidDnsConfig();
   ChangeDnsConfig(config);
 
   proc_->AddRuleForAllFamilies(std::string(),
                                std::string());  // Default to failures.
   proc_->SignalMultiple(1u);  // For the first request which misses.
 
   Request* req0 = CreateRequest("nx_ipv4", 80);
@@ skipping 651 matching lines @@
   EXPECT_EQ(1, count2);
 
   // Make another request to make sure both callbacks were cleared.
   req = CreateRequest("just.testing", 80);
   EXPECT_THAT(req->Resolve(), IsOk());
   EXPECT_EQ(2, count1);
   EXPECT_EQ(1, count2);
 }
 
 }  // namespace net