Remove "Default Address Family" behavior from the HostResolver.

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 <string>
 
 #include "base/bind.h"
@@ skipping 398 matching lines @@
   int current_attempt_number_;  // Incremented whenever Resolve is called.
   int total_attempts_;
   int total_attempts_resolved_;
   int resolved_attempt_number_;
 
   // All attempts wait for right attempt to be resolve.
   base::Lock lock_;
   base::ConditionVariable all_done_;
 };
 
+// TestHostResolverImpl's sole purpose is to mock the IPv6 reachability test.
+// By default, this pretends that IPv6 is globally reachable.
+// This class is necessary so unit tests run the same on dual-stack machines as
+// well as IPv4 only machines.
+class TestHostResolverImpl : public HostResolverImpl {
+ public:
+  TestHostResolverImpl(const Options& options, NetLog* net_log)
+      : HostResolverImpl(options, net_log), ipv6_reachable_(true) {}

[pauljensen, 2015/06/05 14:58:47]

nit: use C++11 delegated constructor so we don't forget to initialize member
variables added in the future in all constructors.

[cbentzel, 2015/06/05 15:25:43]

Cool! As you can tell, I haven't been doing enough C++ development since
Chromium adopted C++11.

+
+  TestHostResolverImpl(const Options& options,
+                       NetLog* net_log,
+                       bool ipv6_reachable)
+      : HostResolverImpl(options, net_log), ipv6_reachable_(ipv6_reachable) {}
+
+  ~TestHostResolverImpl() override {}
+
+ private:
+  bool ipv6_reachable_;

[pauljensen, 2015/06/05 14:58:47]

nit: const

[cbentzel, 2015/06/05 15:25:43]

Done.

+
+  bool IsIPv6Reachable(const BoundNetLog& net_log) override {
+    return ipv6_reachable_;
+  }
+};
+
 }  // namespace
 
 class HostResolverImplTest : public testing::Test {
  public:
   static const int kDefaultPort = 80;
 
   HostResolverImplTest() : proc_(new MockHostResolverProc()) {}
 
   void CreateResolver() {
     CreateResolverWithLimitsAndParams(kMaxJobs,
@@ skipping 38 matching lines @@
     if (resolver_.get())
       EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
     EXPECT_FALSE(proc_->HasBlockedRequests());
   }
 
   virtual void CreateResolverWithLimitsAndParams(
       size_t max_concurrent_resolves,
       const HostResolverImpl::ProcTaskParams& params) {
     HostResolverImpl::Options options = DefaultOptions();
     options.max_concurrent_resolves = max_concurrent_resolves;
-    resolver_.reset(new HostResolverImpl(options, NULL));
+    resolver_.reset(new TestHostResolverImpl(options, NULL));
     resolver_->set_proc_params_for_test(params);
   }
 
   // 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,
                          RequestPriority priority) {
     Request* req = new Request(
         info, priority, requests_.size(), resolver_.get(), handler_.get());
     requests_.push_back(req);
@@ skipping 359 matching lines @@
         // Since caching is disabled, this will result in another async request.
         EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 70)->Resolve());
       }
     }
   };
   set_handler(new MyHandler());
 
   // Turn off caching for this host resolver.
   HostResolver::Options options = DefaultOptions();
   options.enable_caching = false;
-  resolver_.reset(new HostResolverImpl(options, NULL));
+  resolver_.reset(new TestHostResolverImpl(options, NULL));
   resolver_->set_proc_params_for_test(DefaultParams(proc_.get()));
 
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i;
   }
 
   proc_->SignalMultiple(2u);  // One for "a". One for the second "a".
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   ASSERT_EQ(5u, requests_.size());
@@ skipping 301 matching lines @@
   EXPECT_EQ("req7", capture_list[3].hostname);
 
   // Verify that the evicted (incomplete) requests were not cached.
   EXPECT_EQ(4u, resolver_->GetHostCache()->size());
 
   for (size_t i = 0; i < requests_.size(); ++i) {
     EXPECT_TRUE(requests_[i]->completed()) << i;
   }
 }
 
-// Tests that after changing the default AddressFamily to IPV4, requests
-// with UNSPECIFIED address family map to IPV4.
-TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) {
-  CreateSerialResolver();  // To guarantee order of resolutions.
-
-  proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1");
-  proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2");
-
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
-
-  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
-  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
-  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
-
-  // Start all of the requests.
-  for (size_t i = 0; i < requests_.size(); ++i) {
-    EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
-  }
-
-  proc_->SignalMultiple(requests_.size());
-
-  // Wait for all the requests to complete.
-  for (size_t i = 0u; i < requests_.size(); ++i) {
-    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
-  }
-
-  // Since the requests all had the same priority and we limited the thread
-  // count to 1, they should have completed in the same order as they were
-  // requested. Moreover, request0 and request1 will have been serviced by
-  // the same job.
-
-  MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
-  ASSERT_EQ(2u, capture_list.size());
-
-  EXPECT_EQ("h1", capture_list[0].hostname);
-  EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[0].address_family);
-
-  EXPECT_EQ("h1", capture_list[1].hostname);
-  EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[1].address_family);
-
-  // Now check that the correct resolved IP addresses were returned.
-  EXPECT_TRUE(requests_[0]->HasOneAddress("1.0.0.1", 80));
-  EXPECT_TRUE(requests_[1]->HasOneAddress("1.0.0.1", 80));
-  EXPECT_TRUE(requests_[2]->HasOneAddress("::2", 80));
-}
-
-// This is the exact same test as SetDefaultAddressFamily_IPv4, except the
-// default family is set to IPv6 and the family of requests is flipped where
-// specified.
-TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
-  CreateSerialResolver();  // To guarantee order of resolutions.
-
-  // Don't use IPv6 replacements here since some systems don't support it.
-  proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1");
-  proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2");
-
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV6);
-
-  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED);
-  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV6);
-  CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV4);
-
-  // Start all of the requests.
-  for (size_t i = 0; i < requests_.size(); ++i) {
-    EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i;
-  }
-
-  proc_->SignalMultiple(requests_.size());
-
-  // Wait for all the requests to complete.
-  for (size_t i = 0u; i < requests_.size(); ++i) {
-    EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i;
-  }
-
-  // Since the requests all had the same priority and we limited the thread
-  // count to 1, they should have completed in the same order as they were
-  // requested. Moreover, request0 and request1 will have been serviced by
-  // the same job.
-
-  MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
-  ASSERT_EQ(2u, capture_list.size());
-
-  EXPECT_EQ("h1", capture_list[0].hostname);
-  EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[0].address_family);
-
-  EXPECT_EQ("h1", capture_list[1].hostname);
-  EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[1].address_family);
-
-  // Now check that the correct resolved IP addresses were returned.
-  EXPECT_TRUE(requests_[0]->HasOneAddress("::2", 80));
-  EXPECT_TRUE(requests_[1]->HasOneAddress("::2", 80));
-  EXPECT_TRUE(requests_[2]->HasOneAddress("1.0.0.1", 80));
-}
-
 // Make sure that the address family parameter is respected when raw IPs are
 // passed in.
 TEST_F(HostResolverImplTest, AddressFamilyWithRawIPs) {
   Request* request =
       CreateRequest("127.0.0.1", 80,  MEDIUM, ADDRESS_FAMILY_IPV4);
   EXPECT_EQ(OK, request->Resolve());
   EXPECT_TRUE(request->HasOneAddress("127.0.0.1", 80));
 
   request = CreateRequest("127.0.0.1", 80,  MEDIUM, ADDRESS_FAMILY_IPV6);
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, request->Resolve());
@@ skipping 46 matching lines @@
       new LookupAttemptHostResolverProc(
           NULL, kAttemptNumberToResolve, kTotalAttempts));
 
   HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc.get());
 
   // Specify smaller interval for unresponsive_delay_ for HostResolverImpl so
   // that unit test runs faster. For example, this test finishes in 1.5 secs
   // (500ms * 3).
   params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500);
 
-  resolver_.reset(new HostResolverImpl(DefaultOptions(), NULL));
+  resolver_.reset(new TestHostResolverImpl(DefaultOptions(), NULL));
   resolver_->set_proc_params_for_test(params);
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   Request* req = CreateRequest(info, DEFAULT_PRIORITY);
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
 
   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
   EXPECT_EQ(-4, req->WaitForResult());
 
@@ skipping 46 matching lines @@
   request = CreateRequest("not_reserved2");
   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
   EXPECT_EQ(OK, request->WaitForResult());
 
   request = CreateRequest("not_reserved3");
   EXPECT_EQ(ERR_IO_PENDING, request->Resolve());
   EXPECT_EQ(OK, request->WaitForResult());
 }
 
 TEST_F(HostResolverImplTest, IsIPv6Reachable) {
+  // The real HostResolverImpl is needed since TestHostResolverImpl will
+  // bypass the IPv6 reachability tests.
+  resolver_.reset(new HostResolverImpl(DefaultOptions(), nullptr));
+
   // Verify that two consecutive calls return the same value.
   TestNetLog net_log;
   BoundNetLog bound_net_log = BoundNetLog::Make(&net_log, NetLog::SOURCE_NONE);
   bool result1 = IsIPv6Reachable(bound_net_log);
   bool result2 = IsIPv6Reachable(bound_net_log);
   EXPECT_EQ(result1, result2);
 
   // Filter reachability check events and verify that there are two of them.
   TestNetLogEntry::List event_list;
   net_log.GetEntries(&event_list);
@@ skipping 69 matching lines @@
                MockDnsClientRule::TIMEOUT, 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 HostResolverImpl(options, NULL));
+    resolver_.reset(new TestHostResolverImpl(options, NULL));
     resolver_->set_proc_params_for_test(params);
-    // Disable IPv6 support probing.
-    resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
     dns_client_ = new MockDnsClient(DnsConfig(), dns_rules_);
     resolver_->SetDnsClient(scoped_ptr<DnsClient>(dns_client_));
   }
 
   // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply.
   void AddDnsRule(const std::string& prefix,
                   uint16 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::MessageLoop::current()->RunUntilIdle();
   }
 
   MockDnsClientRuleList dns_rules_;
   // Owned by |resolver_|.
   MockDnsClient* dns_client_;
 };
 
 // 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(HostResolverImplDnsTest, DnsTask) {
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
-
   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());
 
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80, MEDIUM,
+                                          ADDRESS_FAMILY_IPV4)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80, MEDIUM,
+                                          ADDRESS_FAMILY_IPV4)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80, MEDIUM,
+                                          ADDRESS_FAMILY_IPV4)->Resolve());
 
   proc_->SignalMultiple(requests_.size());
 
   for (size_t i = 1; i < requests_.size(); ++i)
     EXPECT_NE(ERR_UNEXPECTED, requests_[i]->WaitForResult()) << i;
 
   EXPECT_EQ(OK, requests_[1]->result());
   // Resolved by MockDnsClient.
   EXPECT_TRUE(requests_[1]->HasOneAddress("127.0.0.1", 80));
   // Fallback to ProcTask.
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[2]->result());
   EXPECT_EQ(OK, requests_[3]->result());
   EXPECT_TRUE(requests_[3]->HasOneAddress("192.168.1.102", 80));
 }
 
 // Test successful and failing resolutions in HostResolverImpl::DnsTask when
 // fallback to ProcTask is disabled.
 TEST_F(HostResolverImplDnsTest, NoFallbackToProcTask) {
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   set_fallback_to_proctask(false);
 
   proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
   // All other hostnames will fail in proc_.
 
   // Set empty DnsConfig.
   ChangeDnsConfig(DnsConfig());
   // Initially there is no config, so client should not be invoked.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
   // There is no config, so fallback to ProcTask must work.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve());
   proc_->SignalMultiple(requests_.size());
 
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult());
   EXPECT_EQ(OK, requests_[1]->WaitForResult());
   EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.1.102", 80));
 
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_abort", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_abort", 80, MEDIUM,
+                                          ADDRESS_FAMILY_IPV4)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80, MEDIUM,
+                                          ADDRESS_FAMILY_IPV4)->Resolve());
 
   // Simulate the case when the preference or policy has disabled the DNS client
   // causing AbortDnsTasks.
   resolver_->SetDnsClient(
       scoped_ptr<DnsClient>(new MockDnsClient(DnsConfig(), dns_rules_)));
   ChangeDnsConfig(CreateValidDnsConfig());
 
   // First request is resolved by MockDnsClient, others should fail due to
   // disabled fallback to ProcTask.
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve());
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80, MEDIUM,
+                                          ADDRESS_FAMILY_IPV4)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80, MEDIUM,
+                                          ADDRESS_FAMILY_IPV4)->Resolve());
   proc_->SignalMultiple(requests_.size());
 
   // Aborted due to Network Change.
   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->WaitForResult());
   EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[3]->WaitForResult());
   // Resolved by MockDnsClient.
   EXPECT_EQ(OK, requests_[4]->WaitForResult());
   EXPECT_TRUE(requests_[4]->HasOneAddress("127.0.0.1", 80));
   // Fallback to ProcTask is disabled.
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[5]->WaitForResult());
 }
 
 // Test behavior of OnDnsTaskFailure when Job is aborted.
 TEST_F(HostResolverImplDnsTest, OnDnsTaskFailureAbortedJob) {
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   ChangeDnsConfig(CreateValidDnsConfig());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
   // Abort all jobs here.
   CreateResolver();
   proc_->SignalMultiple(requests_.size());
   // Run to completion.
   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
   // It shouldn't crash during OnDnsTaskFailure callbacks.
   EXPECT_EQ(ERR_IO_PENDING, requests_[0]->result());
 
   // Repeat test with Fallback to ProcTask disabled
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   set_fallback_to_proctask(false);
   ChangeDnsConfig(CreateValidDnsConfig());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve());
   // Abort all jobs here.
   CreateResolver();
   // Run to completion.
   base::MessageLoop::current()->RunUntilIdle();  // Notification happens async.
   // It shouldn't crash during OnDnsTaskFailure callbacks.
   EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result());
 }
@@ skipping 184 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   EXPECT_EQ(OK, req->WaitForResult());
 }
 
 // Confirm that resolving "localhost" is unrestricted even if there are no
 // global IPv6 address. See SystemHostResolverCall for rationale.
 // Test both the DnsClient and system host resolver paths.
 TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) {
   // Use regular SystemHostResolverCall!
   scoped_refptr<HostResolverProc> proc(new SystemHostResolverProc());
-  resolver_.reset(new HostResolverImpl(DefaultOptions(), NULL));
+  resolver_.reset(new TestHostResolverImpl(DefaultOptions(), NULL, false));
   resolver_->set_proc_params_for_test(DefaultParams(proc.get()));
 
   resolver_->SetDnsClient(
       scoped_ptr<DnsClient>(new MockDnsClient(DnsConfig(), dns_rules_)));
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
   // Get the expected output.
   AddressList addrlist;
   int rv = proc->Resolve("localhost", ADDRESS_FAMILY_UNSPECIFIED, 0, &addrlist,
                          NULL);
   if (rv != OK)
     return;
 
   for (unsigned i = 0; i < addrlist.size(); ++i)
     LOG(WARNING) << addrlist[i].ToString();
 
   bool saw_ipv4 = AddressListContains(addrlist, "127.0.0.1", 0);
   bool saw_ipv6 = AddressListContains(addrlist, "::1", 0);
   if (!saw_ipv4 && !saw_ipv6)
     return;
 
-  HostResolver::RequestInfo info(HostPortPair("localhost", 80));
-  info.set_address_family(ADDRESS_FAMILY_UNSPECIFIED);
-  info.set_host_resolver_flags(HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
+  // Try without DnsClient.
+  DnsConfig config = CreateValidDnsConfig();
+  config.use_local_ipv6 = false;
+  ChangeDnsConfig(config);

[pauljensen, 2015/06/05 14:58:47]

Any particular reason you changed from this:
    ChangeDnsConfig(DnsConfig())
to this?
    DnsConfig config = CreateValidDnsConfig();
    config.use_local_ipv6 = false;
    ChangeDnsConfig(config);
    info_proc.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY);
which also required adding:
    HostResolver::RequestInfo info_hosts(HostPortPair("localhost", 80));
    info_hosts.set_address_family(ADDRESS_FAMILY_UNSPECIFIED);
and also required renaming config->config_hosts?

[cbentzel, 2015/06/05 15:25:43]

Yes, there was a reason.

The first part of this test validates that if the "proc" approach to resolution
is used, we'll still try to get both A and AAAA results for names on localhost
even if there is no globally reachable IPv6 DNS address.

If there is not a valid DNS config, then HostResolverImpl::use_local_ipv6_ is
conservatively set to true. This means that we will bypass the IPv6 reachability
test in HostResolverImpl::GetEffectiveKeyForRequest - which also means that the
initial request is ADDRESS_FAMILY_UNSPEC, rather than ADDRESS_FAMILY_IPV4 with
HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6. That would mean that the test
doesn't exercise what it means to exercise.

So, I have to specify a valid DNS config so the IPv6 reachability test is done
(and fails). But I also need to make sure that proc is used rather than the
DnsTask approach, so it's why I need to also specify HOST_RESOLVER_SYSTEM_ONLY.

----

I then need to modify the config again later on so it includes the pretend HOSTS
file - since the second part of the test is there to make sure that the host
resolution gets retried for localhost addresses when there is no globally
reachable IPv6 address.

[pauljensen, 2015/06/05 15:45:54]

Ah, I didn't notice that DnsConfig's use_local_ipv6 is modified before setting
into HostResolveImpl's use_local_ipv6.
Why not just modify the original line 1849 UNSPECIFIED->IPv4?

+  HostResolver::RequestInfo info_proc(HostPortPair("localhost", 80));
+  info_proc.set_address_family(ADDRESS_FAMILY_UNSPECIFIED);
+  info_proc.set_host_resolver_flags(HOST_RESOLVER_SYSTEM_ONLY);
+  Request* req = CreateRequest(info_proc, DEFAULT_PRIORITY);
 
-  // Try without DnsClient.
-  ChangeDnsConfig(DnsConfig());
-  Request* req = CreateRequest(info, DEFAULT_PRIORITY);
   // It is resolved via getaddrinfo, so expect asynchronous result.
   EXPECT_EQ(ERR_IO_PENDING, req->Resolve());
   EXPECT_EQ(OK, req->WaitForResult());
 
   EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80));
   EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80));
 
   // Configure DnsClient with dual-host HOSTS file.
-  DnsConfig config = CreateValidDnsConfig();
+  DnsConfig config_hosts = CreateValidDnsConfig();
   DnsHosts hosts;
   IPAddressNumber local_ipv4, local_ipv6;
   ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4));
   ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6));
   if (saw_ipv4)
     hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV4)] = local_ipv4;
   if (saw_ipv6)
     hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV6)] = local_ipv6;
-  config.hosts = hosts;
+  config_hosts.hosts = hosts;
 
-  ChangeDnsConfig(config);
-  req = CreateRequest(info, DEFAULT_PRIORITY);
+  ChangeDnsConfig(config_hosts);
+  HostResolver::RequestInfo info_hosts(HostPortPair("localhost", 80));
+  info_hosts.set_address_family(ADDRESS_FAMILY_UNSPECIFIED);
+  req = CreateRequest(info_hosts, DEFAULT_PRIORITY);
   // Expect synchronous resolution from DnsHosts.
   EXPECT_EQ(OK, req->Resolve());
 
   EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80));
   EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80));
 }
 
 // Cancel a request with a single DNS transaction active.
 TEST_F(HostResolverImplDnsTest, CancelWithOneTransactionActive) {
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
   ChangeDnsConfig(CreateValidDnsConfig());
 
-  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING,
+            CreateRequest("ok", 80, MEDIUM, ADDRESS_FAMILY_IPV4)->Resolve());
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
   requests_[0]->Cancel();
 
   // Dispatcher state checked in TearDown.
 }
 
 // Cancel a request with a single DNS transaction active and another pending.
 TEST_F(HostResolverImplDnsTest, CancelWithOneTransactionActiveOnePending) {
   CreateSerialResolver();
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
   requests_[0]->Cancel();
 
   // Dispatcher state checked in TearDown.
 }
 
 // Cancel a request with two DNS transactions active.
 TEST_F(HostResolverImplDnsTest, CancelWithTwoTransactionsActive) {
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
   EXPECT_EQ(2u, num_running_dispatcher_jobs());
   requests_[0]->Cancel();
 
   // Dispatcher state checked in TearDown.
 }
 
 // Delete a resolver with some active requests and some queued requests.
 TEST_F(HostResolverImplDnsTest, DeleteWithActiveTransactions) {
   // At most 10 Jobs active at once.
   CreateResolverWithLimitsAndParams(10u, DefaultParams(proc_.get()));
 
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   // First active job is an IPv4 request.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
 
   // Add 10 more DNS lookups for different hostnames.  First 4 should have two
   // active jobs, next one has a single active job, and one pending.  Others
   // should all be queued.
   for (int i = 0; i < 10; ++i) {
     EXPECT_EQ(ERR_IO_PENDING, CreateRequest(
         base::StringPrintf("ok%i", i))->Resolve());
   }
   EXPECT_EQ(10u, num_running_dispatcher_jobs());
 
   resolver_.reset();
 }
 
 // Cancel a request with only the IPv6 transaction active.
 TEST_F(HostResolverImplDnsTest, CancelWithIPv6TransactionActive) {
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("6slow_ok", 80)->Resolve());
   EXPECT_EQ(2u, num_running_dispatcher_jobs());
 
   // The IPv4 request should complete, the IPv6 request is still pending.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
   requests_[0]->Cancel();
 
   // Dispatcher state checked in TearDown.
 }
 
 // Cancel a request with only the IPv4 transaction pending.
 TEST_F(HostResolverImplDnsTest, CancelWithIPv4TransactionPending) {
   set_fallback_to_proctask(false);
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_ok", 80)->Resolve());
   EXPECT_EQ(2u, num_running_dispatcher_jobs());
 
   // The IPv6 request should complete, the IPv4 request is still pending.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
 
   requests_[0]->Cancel();
 }
 
 // Test cases where AAAA completes first.
 TEST_F(HostResolverImplDnsTest, AAAACompletesFirst) {
   set_fallback_to_proctask(false);
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_ok", 80)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_4ok", 80)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_4timeout", 80)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4slow_6timeout", 80)->Resolve());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(requests_[0]->completed());
   EXPECT_FALSE(requests_[1]->completed());
@@ skipping 17 matching lines @@
   EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80));
 
   EXPECT_TRUE(requests_[2]->completed());
   EXPECT_EQ(ERR_DNS_TIMED_OUT, requests_[2]->result());
 }
 
 // Test the case where only a single transaction slot is available.
 TEST_F(HostResolverImplDnsTest, SerialResolver) {
   CreateSerialResolver();
   set_fallback_to_proctask(false);
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve());
   EXPECT_EQ(1u, num_running_dispatcher_jobs());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(requests_[0]->completed());
   EXPECT_EQ(OK, requests_[0]->result());
   EXPECT_EQ(2u, requests_[0]->NumberOfAddresses());
   EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80));
   EXPECT_TRUE(requests_[0]->HasAddress("::1", 80));
 }
 
 // Test the case where the AAAA query is started when another transaction
 // completes.
 TEST_F(HostResolverImplDnsTest, AAAAStartsAfterOtherJobFinishes) {
   CreateResolverWithLimitsAndParams(2u, DefaultParams(proc_.get()));
   set_fallback_to_proctask(false);
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80, MEDIUM,
                                           ADDRESS_FAMILY_IPV4)->Resolve());
   EXPECT_EQ(ERR_IO_PENDING,
             CreateRequest("4slow_ok", 80, MEDIUM)->Resolve());
   // An IPv4 request should have been started pending for each job.
   EXPECT_EQ(2u, num_running_dispatcher_jobs());
 
   // Request 0's IPv4 request should complete, starting Request 1's IPv6
@@ skipping 38 matching lines @@
 }
 
 // Tests getting a new invalid DnsConfig while there are active DnsTasks.
 TEST_F(HostResolverImplDnsTest, InvalidDnsConfigWithPendingRequests) {
   // At most 3 jobs active at once.  This number is important, since we want to
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
   CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
 
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   proc_->AddRuleForAllFamilies("slow_nx1", "192.168.0.1");
   proc_->AddRuleForAllFamilies("slow_nx2", "192.168.0.2");
   proc_->AddRuleForAllFamilies("ok", "192.168.0.3");
 
   // First active job gets two slots.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_nx1")->Resolve());
   // Next job gets one slot, and waits on another.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_nx2")->Resolve());
@@ skipping 20 matching lines @@
 TEST_F(HostResolverImplDnsTest,
        AutomaticallyDisableDnsClientWithPendingRequests) {
   // Trying different limits is important for this test:  Different limits
   // result in different behavior when aborting in-progress DnsTasks.  Having
   // a DnsTask that has one job active and one in the queue when another job
   // occupying two slots has its DnsTask aborted is the case most likely to run
   // into problems.
   for (size_t limit = 1u; limit < 6u; ++limit) {
     CreateResolverWithLimitsAndParams(limit, DefaultParams(proc_.get()));
 
-    resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
     ChangeDnsConfig(CreateValidDnsConfig());
 
     // Queue up enough failures to disable DnsTasks.  These will all fall back
     // to ProcTasks, and succeed there.
     for (unsigned i = 0u; i < maximum_dns_failures(); ++i) {
       std::string host = base::StringPrintf("nx%u", i);
       proc_->AddRuleForAllFamilies(host, "192.168.0.1");
       EXPECT_EQ(ERR_IO_PENDING, CreateRequest(host)->Resolve());
     }
 
@@ skipping 26 matching lines @@
 }
 
 // Tests a call to SetDnsClient while there are active DnsTasks.
 TEST_F(HostResolverImplDnsTest, ManuallyDisableDnsClientWithPendingRequests) {
   // At most 3 jobs active at once.  This number is important, since we want to
   // make sure that aborting the first HostResolverImpl::Job does not trigger
   // another DnsTransaction on the second Job when it releases its second
   // prioritized dispatcher slot.
   CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()));
 
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED);
   ChangeDnsConfig(CreateValidDnsConfig());
 
   proc_->AddRuleForAllFamilies("slow_ok1", "192.168.0.1");
   proc_->AddRuleForAllFamilies("slow_ok2", "192.168.0.2");
   proc_->AddRuleForAllFamilies("ok", "192.168.0.3");
 
   // First active job gets two slots.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok1")->Resolve());
   // Next job gets one slot, and waits on another.
   EXPECT_EQ(ERR_IO_PENDING, CreateRequest("slow_ok2")->Resolve());
@@ skipping 12 matching lines @@
 
   EXPECT_EQ(OK, requests_[0]->WaitForResult());
   EXPECT_TRUE(requests_[0]->HasOneAddress("192.168.0.1", 80));
   EXPECT_EQ(OK, requests_[1]->WaitForResult());
   EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.0.2", 80));
   EXPECT_EQ(OK, requests_[2]->WaitForResult());
   EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.0.3", 80));
 }
 
 }  // namespace net