Misc HostResolverImpl refactors.

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 1485 matching lines @@
   proc_->AddRuleForAllFamilies("not_reserved2", "127.0.53.54");
   proc_->AddRuleForAllFamilies("not_reserved3", "10.0.53.53");
   proc_->SignalMultiple(6u);
 
   Request* request;
 
   request = CreateRequest("single");
   EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_THAT(request->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION));
 
+  // ERR_ICANN_NAME_COLLISION is cached like any other error, using a
+  // fixed TTL for failed entries from proc-based resolver. That said, the
+  // fixed TTL is 0, so it will never be cached.
+  request = CreateRequest("single");
+  EXPECT_THAT(request->ResolveFromCache(), IsError(ERR_DNS_CACHE_MISS));
+
   request = CreateRequest("multiple");
   EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_THAT(request->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION));
 
   // Resolving an IP literal of 127.0.53.53 however is allowed.
   EXPECT_THAT(CreateRequest("127.0.53.53")->Resolve(), IsOk());
 
   // Moreover the address should not be recognized when embedded in an IPv6
   // address.
   request = CreateRequest("ipv6");
@@ skipping 313 matching lines @@
   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));
+
+  // The mock responses for 4collision (and 6collision) have a TTL of 1 day.
+  // Test whether the ERR_ICANN_NAME_COLLISION failure was cached.
+  // On the one hand caching the failure makes sense, as the error is derived
+  // from the IP in the response. However for consistency with the the proc-
+  // based implementation the TTL is unused.
+  EXPECT_THAT(CreateRequest("4collision", 80)->ResolveFromCache(),
+              IsError(ERR_DNS_CACHE_MISS));
 }
 
 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.
@@ skipping 653 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