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_;
 };
 
+class TestHostResolverImpl : public HostResolverImpl {

[pauljensen, 2015/06/03 16:26:06]

How about adding a comment mentioning that use of this class prevents IPv6
probing?

[cbentzel, 2015/06/03 22:58:08]

Done.

+ public:
+  TestHostResolverImpl(const Options& options, NetLog* net_log)
+      : HostResolverImpl(options, net_log) {}
+
+  ~TestHostResolverImpl() override {}
+
+ private:
+  bool IsIPv6Reachable(const BoundNetLog& net_log) override { return true; }
+};
+
 }  // 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) {
+  // We need to use the real resolver here.
+  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, IDLE, ADDRESS_FAMILY_IPV4)->Resolve());

[pauljensen, 2015/06/03 16:26:06]

Any particular reason you changed the priority from MEDIUM to IDLE?

[cbentzel, 2015/06/03 22:58:08]

Fewer characters to type. I'll change to MEDIUM since it obviously raised a
question.

+  EXPECT_EQ(ERR_IO_PENDING,
+            CreateRequest("nx_fail", 80, IDLE, ADDRESS_FAMILY_IPV4)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80, IDLE,
+                                          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, IDLE,
+                                          ADDRESS_FAMILY_IPV4)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80, IDLE,
+                                          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, IDLE, ADDRESS_FAMILY_IPV4)->Resolve());
+  EXPECT_EQ(ERR_IO_PENDING,
+            CreateRequest("nx_fail", 80, IDLE, 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));
   resolver_->set_proc_params_for_test(DefaultParams(proc.get()));
 
   resolver_->SetDnsClient(
       scoped_ptr<DnsClient>(new MockDnsClient(DnsConfig(), dns_rules_)));
-  resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);

[pauljensen, 2015/06/03 16:26:06]

By removing this, have you stopped this test from testing the intended behavior?
 I think the behavior being tested relies on a restricted request, at least
according to this comment:
https://code.google.com/p/chromium/codesearch#chromium/src/net/dns/host_resol...

[cbentzel, 2015/06/03 22:58:08]

Great catch. 

I noticed on my machine that localhost only resolved to 127.0.0.1 and most of
the test is skipped. 

I actually want to understand why this test uses SystemHostResolverProc rather
than mocking it out so it will actually run on all platforms. I'll try to get in
touch with szym@ about it.

[cbentzel, 2015/06/04 13:06:42]

OK, I looked at this some more.

The old version of the test acted as if the requests were AF_UNSPECIFIED, but
the HostResolverImpl would choose an effective key of AF_IPV4 and set the host
resolver flag that IPv6 was disabled - and made sure that localhost resolutions
would still give AAAA in this case if the system host resolver did as well.

The first request would go to the system getaddrinfo call.
The second request would be handled out of HOSTS.

By treating IPv6 probes as failing with the TestHostResolverImpl, the second
request is actually handled identically with the new version of the code from
the old version.

But the first version does not go through this check because we treat
"use_local_ipv6_" as true since there is no DnsConfig. So in that case we'd
still keep the AF_UNSPECIFIED behavior on a dual host machine.

Trying to figure out a good workaround for that without introducing runtime
logic.
 

 
   // 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();
@@ skipping 33 matching lines @@
   req = CreateRequest(info, 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, IDLE, 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