[net] HostResolverImpl + DnsTransaction + DnsConfigService = Asynchronous DNS ready for experiments.

net/base/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/base/host_resolver_impl.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 33 matching lines @@
     HostResolverProc* resolver_proc) {
   return HostResolverImpl::ProcTaskParams(resolver_proc,
                                           kMaxRetryAttempts);
 }
 
 HostResolverImpl* CreateHostResolverImpl(HostResolverProc* resolver_proc) {
   return new HostResolverImpl(
       HostCache::CreateDefaultCache(),
       DefaultLimits(),
       DefaultParams(resolver_proc),
+      scoped_ptr<DnsConfigService>(NULL),
       NULL);
 }
 
 // This HostResolverImpl will only allow 1 outstanding resolve at a time.
 HostResolverImpl* CreateSerialHostResolverImpl(
     HostResolverProc* resolver_proc) {
   HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc);
   params.max_retry_attempts = 0u;
 
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1);
 
   return new HostResolverImpl(HostCache::CreateDefaultCache(),
                               limits,
                               params,
+                              scoped_ptr<DnsConfigService>(NULL),
                               NULL);
 }
 
 // Helper to create a HostResolver::RequestInfo.
 HostResolver::RequestInfo CreateResolverRequest(
     const std::string& hostname,
     RequestPriority priority) {
   HostResolver::RequestInfo info(HostPortPair(hostname, 80));
   info.set_priority(priority);
   return info;
@@ skipping 29 matching lines @@
   }
 
   void Signal() {
     event_.Signal();
   }
 
   virtual int Resolve(const std::string& hostname,
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error) {
+                      int* os_error) OVERRIDE {
     event_.Wait();
     {
       base::AutoLock l(lock_);
       capture_list_.push_back(CaptureEntry(hostname, address_family));
     }
     return ResolveUsingPrevious(hostname, address_family,
                                 host_resolver_flags, addrlist, os_error);
   }
 
   CaptureList GetCaptureList() const {
@@ skipping 26 matching lines @@
 //   z = value of address_family
 //
 class EchoingHostResolverProc : public HostResolverProc {
  public:
   EchoingHostResolverProc() : HostResolverProc(NULL) {}
 
   virtual int Resolve(const std::string& hostname,
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error) {
+                      int* os_error) OVERRIDE {
     // Encode the request's hostname and address_family in the output address.
     std::string ip_literal = base::StringPrintf("192.%d.%d.%d",
         static_cast<int>(hostname.size()),
         static_cast<int>(hostname[0]),
         static_cast<int>(address_family));
 
     return SystemHostResolverProc(ip_literal,
                                   ADDRESS_FAMILY_UNSPECIFIED,
                                   host_resolver_flags,
                                   addrlist, os_error);
@@ skipping 45 matching lines @@
   int total_attempts_resolved() { return total_attempts_resolved_; }
 
   // Returns the first attempt that that has resolved the host.
   int resolved_attempt_number() { return resolved_attempt_number_; }
 
   // HostResolverProc methods.
   virtual int Resolve(const std::string& host,
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error) {
+                      int* os_error) OVERRIDE {
     bool wait_for_right_attempt_to_complete = true;
     {
       base::AutoLock auto_lock(lock_);
       ++current_attempt_number_;
       if (current_attempt_number_ == attempt_number_to_resolve_) {
         resolved_attempt_number_ = current_attempt_number_;
         wait_for_right_attempt_to_complete = false;
       }
     }
 
@@ skipping 186 matching lines @@
 }
 
 TEST_F(HostResolverImplTest, FailedAsynchronousLookup) {
   AddressList addrlist;
   const int kPortnum = 80;
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
       new RuleBasedHostResolverProc(NULL));
   resolver_proc->AddSimulatedFailure("just.testing");
 
-  scoped_ptr<HostResolver> host_resolver(
-      CreateHostResolverImpl(resolver_proc));
+  scoped_ptr<HostResolver> host_resolver(CreateHostResolverImpl(resolver_proc));
 
   HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                    log.bound());
   EXPECT_EQ(ERR_IO_PENDING, err);
 
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
@@ skipping 14 matching lines @@
 
   // Also test that the error is not cached!
   err = host_resolver->ResolveFromCache(info, &addrlist, log.bound());
   EXPECT_EQ(ERR_DNS_CACHE_MISS, err);
 }
 
 // Using WaitingHostResolverProc you can simulate very long lookups.
 class WaitingHostResolverProc : public HostResolverProc {
  public:
   explicit WaitingHostResolverProc(HostResolverProc* previous)
-    : HostResolverProc(previous),
-      is_waiting_(false, false),
-      is_signaled_(false, false) {}
+      : HostResolverProc(previous),
+        is_waiting_(false, false),
+        is_signaled_(false, false) {}
+
+  // If |manual_reset| is true, once Signalled, it will let all Resolve calls
+  // proceed.
+  WaitingHostResolverProc(HostResolverProc* previous, bool manual_reset)
+      : HostResolverProc(previous),
+        is_waiting_(false, false),
+        is_signaled_(manual_reset, false) {}
 
   // Waits until a call to |Resolve| is blocked. It is recommended to always
   // |Wait| before |Signal|, and required if issuing a series of two or more
   // calls to |Signal|, because |WaitableEvent| does not count the number of
   // signals.
   void Wait() {
     is_waiting_.Wait();
   }
 
   // Signals a waiting call to |Resolve|.
   void Signal() {
     is_signaled_.Signal();
   }
 
   // HostResolverProc methods:
   virtual int Resolve(const std::string& host,
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error) {
+                      int* os_error) OVERRIDE {
     is_waiting_.Signal();
     is_signaled_.Wait();
     return ResolveUsingPrevious(host, address_family, host_resolver_flags,
                                 addrlist, os_error);
   }
 
  private:
   virtual ~WaitingHostResolverProc() {}
-
   base::WaitableEvent is_waiting_;
   base::WaitableEvent is_signaled_;
 };
 
 TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) {
   scoped_refptr<WaitingHostResolverProc> resolver_proc(
       new WaitingHostResolverProc(NULL));
 
   CapturingNetLog net_log(CapturingNetLog::kUnbounded);
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   {
     // This resolver will be destroyed while a lookup is running on WorkerPool.
     scoped_ptr<HostResolver> host_resolver(
         new HostResolverImpl(HostCache::CreateDefaultCache(),
                              DefaultLimits(),
                              DefaultParams(resolver_proc),
+                             scoped_ptr<DnsConfigService>(NULL),
                              &net_log));
     AddressList addrlist;
     const int kPortnum = 80;
 
     HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
     int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                      log.bound());
     EXPECT_EQ(ERR_IO_PENDING, err);
 
     resolver_proc->Wait();
@@ skipping 15 matching lines @@
 
   int pos = ExpectLogContainsSomewhereAfter(net_log_entries, 0,
       NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,
       NetLog::PHASE_BEGIN);
   pos = ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
       NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
       NetLog::PHASE_BEGIN);
   pos = ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
         NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK,
         NetLog::PHASE_BEGIN);
-  // Both Request and ProcTask need to be cancelled. (The Job is "aborted".)
-  pos = ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
-      NetLog::TYPE_CANCELLED,
-      NetLog::PHASE_NONE);
-  // Don't care about order in which Request, Job and ProcTask end, or when the
-  // other one is cancelled.
+
+  // The Request needs to be cancelled. (The Job is "aborted".)
+  // Don't care about order in which Request, Job and ProcTask end.
   ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
       NetLog::TYPE_CANCELLED,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
+      NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK,
+      NetLog::PHASE_END);
+  ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
       NetLog::TYPE_HOST_RESOLVER_IMPL_REQUEST,
       NetLog::PHASE_END);
   ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
-      NetLog::TYPE_HOST_RESOLVER_IMPL_PROC_TASK,
-      NetLog::PHASE_END);
-  ExpectLogContainsSomewhereAfter(net_log_entries, pos + 1,
       NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
       NetLog::PHASE_END);
 
   EXPECT_FALSE(callback_called_);
 }
 
 TEST_F(HostResolverImplTest, NumericIPv4Address) {
   // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
 
   scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
@@ skipping 90 matching lines @@
 
 // Helper class used by HostResolverImplTest.DeDupeRequests. It receives request
 // completion notifications for all the resolves, so it can tally up and
 // determine when we are done.
 class DeDupeRequestsVerifier : public ResolveRequest::Delegate {
  public:
   explicit DeDupeRequestsVerifier(CapturingHostResolverProc* resolver_proc)
       : count_a_(0), count_b_(0), resolver_proc_(resolver_proc) {}
 
   // The test does 5 resolves (which can complete in any order).
-  virtual void OnCompleted(ResolveRequest* resolve) {
+  virtual void OnCompleted(ResolveRequest* resolve) OVERRIDE {
     // Tally up how many requests we have seen.
     if (resolve->hostname() == "a") {
       count_a_++;
     } else if (resolve->hostname() == "b") {
       count_b_++;
     } else {
       FAIL() << "Unexpected hostname: " << resolve->hostname();
     }
 
     // Check that the port was set correctly.
@@ skipping 52 matching lines @@
   // |verifier| will send quit message once all the requests have finished.
   MessageLoop::current()->Run();
 }
 
 // Helper class used by HostResolverImplTest.CancelMultipleRequests.
 class CancelMultipleRequestsVerifier : public ResolveRequest::Delegate {
  public:
   CancelMultipleRequestsVerifier() {}
 
   // The cancels kill all but one request.
-  virtual void OnCompleted(ResolveRequest* resolve) {
+  virtual void OnCompleted(ResolveRequest* resolve) OVERRIDE {
     EXPECT_EQ("a", resolve->hostname());
     EXPECT_EQ(82, resolve->port());
 
     // Check that the port was set correctly.
     EXPECT_EQ(resolve->port(), resolve->addrlist().GetPort());
 
     // End this test, we are done.
     MessageLoop::current()->Quit();
   }
 
@@ skipping 37 matching lines @@
   MessageLoop::current()->Run();
 }
 
 // Helper class used by HostResolverImplTest.CancelWithinCallback.
 class CancelWithinCallbackVerifier : public ResolveRequest::Delegate {
  public:
   CancelWithinCallbackVerifier()
       : req_to_cancel1_(NULL), req_to_cancel2_(NULL), num_completions_(0) {
   }
 
-  virtual void OnCompleted(ResolveRequest* resolve) {
+  virtual void OnCompleted(ResolveRequest* resolve) OVERRIDE {
     num_completions_++;
 
     // Port 80 is the first request that the callback will be invoked for.
     // While we are executing within that callback, cancel the other requests
     // in the job and start another request.
     if (80 == resolve->port()) {
       EXPECT_EQ("a", resolve->hostname());
 
       req_to_cancel1_->Cancel();
       req_to_cancel2_->Cancel();
@@ skipping 62 matching lines @@
 }
 
 // Helper class used by HostResolverImplTest.DeleteWithinCallback.
 class DeleteWithinCallbackVerifier : public ResolveRequest::Delegate {
  public:
   // |host_resolver| is the resolver that the the resolve requests were started
   // with.
   explicit DeleteWithinCallbackVerifier(HostResolver* host_resolver)
       : host_resolver_(host_resolver) {}
 
-  virtual void OnCompleted(ResolveRequest* resolve) {
+  virtual void OnCompleted(ResolveRequest* resolve) OVERRIDE {
     EXPECT_EQ("a", resolve->hostname());
     EXPECT_EQ(80, resolve->port());
 
     // Deletes the host resolver.
     host_resolver_.reset();
 
     // Quit after returning from OnCompleted (to give it a chance at
     // incorrectly running the cancelled tasks).
     MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
@@ skipping 29 matching lines @@
 
   // |verifier| will send quit message once all the requests have finished.
   MessageLoop::current()->Run();
 }
 
 // Helper class used by HostResolverImplTest.StartWithinCallback.
 class StartWithinCallbackVerifier : public ResolveRequest::Delegate {
  public:
   StartWithinCallbackVerifier() : num_requests_(0) {}
 
-  virtual void OnCompleted(ResolveRequest* resolve) {
+  virtual void OnCompleted(ResolveRequest* resolve) OVERRIDE {
     EXPECT_EQ("a", resolve->hostname());
 
     if (80 == resolve->port()) {
       // On completing the first request, start another request for "a".
       // Since caching is disabled, this will result in another async request.
       final_request_.reset(new ResolveRequest(
         resolve->resolver(), "a", 70, this));
     }
     if (++num_requests_ == 5) {
       // Test is done.
       MessageLoop::current()->Quit();
     }
   }
 
  private:
   int num_requests_;
   scoped_ptr<ResolveRequest> final_request_;
   DISALLOW_COPY_AND_ASSIGN(StartWithinCallbackVerifier);
 };
 
 TEST_F(HostResolverImplTest, StartWithinCallback) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolver().  Also, the capturing resolver_proc is initially
   // blocked.
   scoped_refptr<CapturingHostResolverProc> resolver_proc(
       new CapturingHostResolverProc(NULL));
 
   // Turn off caching for this host resolver.
   scoped_ptr<HostResolver> host_resolver(new HostResolverImpl(
-      NULL, DefaultLimits(), DefaultParams(resolver_proc), NULL));
+      NULL,
+      DefaultLimits(),
+      DefaultParams(resolver_proc),
+      scoped_ptr<DnsConfigService>(NULL),
+      NULL));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   StartWithinCallbackVerifier verifier;
 
   // Start 4 requests, duplicating hosts "a". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
 
   ResolveRequest req1(host_resolver.get(), "a", 80, &verifier);
   ResolveRequest req2(host_resolver.get(), "a", 81, &verifier);
   ResolveRequest req3(host_resolver.get(), "a", 82, &verifier);
   ResolveRequest req4(host_resolver.get(), "a", 83, &verifier);
 
   // Ready, Set, GO!!!
   resolver_proc->Signal();
 
   // |verifier| will send quit message once all the requests have finished.
   MessageLoop::current()->Run();
 }
 
 // Helper class used by HostResolverImplTest.BypassCache.
 class BypassCacheVerifier : public ResolveRequest::Delegate {
  public:
   BypassCacheVerifier() {}
 
-  virtual void OnCompleted(ResolveRequest* resolve) {
+  virtual void OnCompleted(ResolveRequest* resolve) OVERRIDE {
     EXPECT_EQ("a", resolve->hostname());
     HostResolver* resolver = resolve->resolver();
 
     if (80 == resolve->port()) {
       // On completing the first request, start another request for "a".
       // Since caching is enabled, this should complete synchronously.
 
       // Note that |junk_callback| shouldn't be used since we are going to
       // complete synchronously.
       TestCompletionCallback junk_callback;
@@ skipping 121 matching lines @@
   EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
 
   rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   resolver_proc->Wait();
   resolver_proc->Signal();
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
-class ResolveWithinCallback {
+// Helper class used by AbortOnlyExistingRequestsOnIPAddressChange.
+class StartWithinAbortedCallbackVerifier : public ResolveRequest::Delegate {
  public:
-  explicit ResolveWithinCallback(const HostResolver::RequestInfo& info)
-      : info_(info) {}
+  explicit StartWithinAbortedCallbackVerifier(const std::string& next_hostname)
+      : next_hostname_(next_hostname) {}
 
-  const CompletionCallback& callback() const { return callback_.callback(); }
-
-  int WaitForResult() {
-    int result = callback_.WaitForResult();
-    // Ditch the WaitingHostResolverProc so that the subsequent request
-    // succeeds.
-    host_resolver_.reset(
-        CreateHostResolverImpl(CreateCatchAllHostResolverProc()));
-    EXPECT_EQ(ERR_IO_PENDING,
-              host_resolver_->Resolve(info_, &addrlist_,
-                                      nested_callback_.callback(), NULL,
-                                      BoundNetLog()));
-    return result;
+  virtual void OnCompleted(ResolveRequest* resolve) OVERRIDE {
+    if (request_.get() == NULL) {
+      EXPECT_EQ(ERR_ABORTED, resolve->result());
+      // Start new request for a different hostname to ensure that the order
+      // of jobs in HostResolverImpl is not stable.
+      request_.reset(new ResolveRequest(resolve->resolver(),
+                                        next_hostname_,
+                                        resolve->port(),
+                                        this));
+    } else {
+      EXPECT_EQ(resolve, request_.get());
+      callback_.callback().Run(resolve->result());
+    }
   }
 
-  int WaitForNestedResult() {
-    return nested_callback_.WaitForResult();
+  int WaitUntilDone() {
+    return callback_.WaitForResult();
   }
 
  private:
-  const HostResolver::RequestInfo info_;
-  AddressList addrlist_;
+  std::string next_hostname_;
+  scoped_ptr<ResolveRequest> request_;
   TestCompletionCallback callback_;
-  TestCompletionCallback nested_callback_;
-  scoped_ptr<HostResolver> host_resolver_;
+  DISALLOW_COPY_AND_ASSIGN(StartWithinAbortedCallbackVerifier);
 };
 
-TEST_F(HostResolverImplTest, OnlyAbortExistingRequestsOnIPAddressChange) {
+// Tests that a new Request made from the callback of a previously aborted one
+// will not be aborted.
+TEST_F(HostResolverImplTest, AbortOnlyExistingRequestsOnIPAddressChange) {
+  // Setting |manual_reset| to true so that Signal unblocks all calls.
   scoped_refptr<WaitingHostResolverProc> resolver_proc(
-      new WaitingHostResolverProc(CreateCatchAllHostResolverProc()));
+      new WaitingHostResolverProc(CreateCatchAllHostResolverProc(), true));
   scoped_ptr<HostResolver> host_resolver(CreateHostResolverImpl(resolver_proc));
 
-  // Resolve "host1".
-  HostResolver::RequestInfo info(HostPortPair("host1", 70));
-  ResolveWithinCallback callback(info);
-  AddressList addrlist;
-  int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
-                                  BoundNetLog());
-  EXPECT_EQ(ERR_IO_PENDING, rv);
+  StartWithinAbortedCallbackVerifier verifier1("zzz");
+  StartWithinAbortedCallbackVerifier verifier2("aaa");
+  StartWithinAbortedCallbackVerifier verifier3("eee");
 
+  ResolveRequest req1(host_resolver.get(), "bbb", 40, &verifier1);
+  ResolveRequest req2(host_resolver.get(), "eee", 80, &verifier2);
+  ResolveRequest req3(host_resolver.get(), "ccc", 90, &verifier3);
+  // The jobs start immediately.
+  // Wait until at least one is blocked.
   resolver_proc->Wait();
-  // Triggering an IP address change.
+  // Trigger an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
-  MessageLoop::current()->RunAllPending();  // Notification happens async.
-  EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
-  resolver_proc->Signal();  // release the thread from WorkerPool for cleanup
-  EXPECT_EQ(OK, callback.WaitForNestedResult());
+  // This should abort all running jobs.
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(ERR_ABORTED, req1.result());
+  EXPECT_EQ(ERR_ABORTED, req2.result());
+  EXPECT_EQ(ERR_ABORTED, req3.result());
+  // Unblock all calls to proc.
+  resolver_proc->Signal();
+  // Run until the re-started requests finish.
+  EXPECT_EQ(OK, verifier1.WaitUntilDone());
+  EXPECT_EQ(OK, verifier2.WaitUntilDone());
+  EXPECT_EQ(OK, verifier3.WaitUntilDone());
+  MessageLoop::current()->AssertIdle();
 }
 
 // Tests that when the maximum threads is set to 1, requests are dequeued
 // in order of priority.
 TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) {
   scoped_refptr<CapturingHostResolverProc> resolver_proc(
       new CapturingHostResolverProc(NULL));
 
   scoped_ptr<HostResolverImpl> host_resolver(
       CreateSerialHostResolverImpl(resolver_proc));
@@ skipping 362 matching lines @@
   // the host. First and second attempt will be forced to sleep until they get
   // word that a resolution has completed. The 3rd resolution attempt will try
   // to get done ASAP, and won't sleep..
   int kAttemptNumberToResolve = 3;
   int kTotalAttempts = 3;
 
   scoped_refptr<LookupAttemptHostResolverProc> resolver_proc(
       new LookupAttemptHostResolverProc(
           NULL, kAttemptNumberToResolve, kTotalAttempts));
 
-  HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc);
+  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 = TimeDelta::FromMilliseconds(500);
 
   scoped_ptr<HostResolverImpl> host_resolver(
       new HostResolverImpl(HostCache::CreateDefaultCache(),
                            DefaultLimits(),
                            params,
+                           scoped_ptr<DnsConfigService>(NULL),
                            NULL));
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   TestCompletionCallback callback;
   AddressList addrlist;
   int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
   EXPECT_EQ(-4, callback.WaitForResult());
 
   resolver_proc->WaitForAllAttemptsToFinish(TimeDelta::FromMilliseconds(60000));
   MessageLoop::current()->RunAllPending();
 
   EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts);
   EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve);
 }
 
 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
 
 }  // namespace net