base::Bind: Convert HostResolver::Resolve.

net/dns/async_host_resolver_unittest.cc

 // Copyright (c) 2011 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/async_host_resolver.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/host_cache.h"
 #include "net/base/net_log.h"
@@ skipping 130 matching lines @@
   HostResolver::RequestInfo info0_, info1_, info2_, info3_;
   std::vector<MockWrite> writes0_, writes1_, writes2_, writes3_;
   std::vector<MockRead> reads0_, reads1_, reads2_, reads3_;
   scoped_ptr<StaticSocketDataProvider> data0_, data1_, data2_, data3_;
   std::vector<const char*> ip_addresses0_, ip_addresses1_,
     ip_addresses2_, ip_addresses3_;
   MockClientSocketFactory factory_;
   TestPrng test_prng_;
   RandIntCallback rand_int_cb_;
   scoped_ptr<HostResolver> resolver_;
-  TestOldCompletionCallback callback0_, callback1_, callback2_, callback3_;
+  TestCompletionCallback callback0_, callback1_, callback2_, callback3_;
 };
 
 TEST_F(AsyncHostResolverTest, EmptyHostLookup) {
   info0_.set_host_port_pair(HostPortPair("", kPortNum));
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
 TEST_F(AsyncHostResolverTest, IPv4LiteralLookup) {
   const char* kIPLiteral = "192.168.1.2";
   info0_.set_host_port_pair(HostPortPair(kIPLiteral, kPortNum));
   info0_.set_host_resolver_flags(HOST_RESOLVER_CANONNAME);
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(OK, rv);
   std::vector<const char*> ip_addresses(1, kIPLiteral);
   VerifyAddressList(ip_addresses, kPortNum, addrlist0_);
   EXPECT_STREQ(kIPLiteral, addrlist0_.head()->ai_canonname);
 }
 
 TEST_F(AsyncHostResolverTest, IPv6LiteralLookup) {
   info0_.set_host_port_pair(HostPortPair("2001:db8:0::42", kPortNum));
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   // When support for IPv6 is added, this should succeed.
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
 TEST_F(AsyncHostResolverTest, CachedLookup) {
   int rv = resolver_->ResolveFromCache(info0_, &addrlist0_, BoundNetLog());
   EXPECT_EQ(ERR_DNS_CACHE_MISS, rv);
 
   // Cache the result of |info0_| lookup.
-  rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                           BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback0_.WaitForResult();
   EXPECT_EQ(OK, rv);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
 
   // Now lookup |info0_| from cache only, store results in |addrlist1_|,
   // should succeed synchronously.
   rv = resolver_->ResolveFromCache(info0_, &addrlist1_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_);
 }
 
 TEST_F(AsyncHostResolverTest, InvalidHostNameLookup) {
   const std::string kHostName1(64, 'a');
   info0_.set_host_port_pair(HostPortPair(kHostName1, kPortNum));
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 
   const std::string kHostName2(4097, 'b');
   info0_.set_host_port_pair(HostPortPair(kHostName2, kPortNum));
-  rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                           BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
 TEST_F(AsyncHostResolverTest, Lookup) {
-  int rv = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback0_.WaitForResult();
   EXPECT_EQ(OK, rv);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
 }
 
 TEST_F(AsyncHostResolverTest, ConcurrentLookup) {
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
   EXPECT_EQ(ERR_IO_PENDING, rv2);
 
   rv0 = callback0_.WaitForResult();
   EXPECT_EQ(OK, rv0);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses1_, kPortNum, addrlist1_);
 
   rv2 = callback2_.WaitForResult();
   EXPECT_EQ(OK, rv2);
   VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_);
 
   EXPECT_EQ(3u, factory_.udp_client_sockets().size());
 }
 
 TEST_F(AsyncHostResolverTest, SameHostLookupsConsumeSingleTransaction) {
   // We pass the info0_ to all requests.
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info0_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info0_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
-  int rv2 = resolver_->Resolve(info0_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info0_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
   EXPECT_EQ(ERR_IO_PENDING, rv2);
 
   rv0 = callback0_.WaitForResult();
   EXPECT_EQ(OK, rv0);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_);
 
   rv2 = callback2_.WaitForResult();
   EXPECT_EQ(OK, rv2);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist2_);
 
   // Although we have three lookups, a single UDP socket was used.
   EXPECT_EQ(1u, factory_.udp_client_sockets().size());
 }
 
 TEST_F(AsyncHostResolverTest, CancelLookup) {
   HostResolver::RequestHandle req0 = NULL, req2 = NULL;
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, &req0,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(),
+                               &req0, BoundNetLog());
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
-                               BoundNetLog());
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, &req2,
-                               BoundNetLog());
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(),
+                               &req2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
   EXPECT_EQ(ERR_IO_PENDING, rv2);
 
   resolver_->CancelRequest(req0);
   resolver_->CancelRequest(req2);
 
   MessageLoop::current()->RunAllPending();
 
   EXPECT_FALSE(callback0_.have_result());
   EXPECT_FALSE(callback2_.have_result());
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses1_, kPortNum, addrlist1_);
 }
 
 // Tests the following scenario: start two resolutions for the same host,
 // cancel one of them, make sure that the other one completes.
 TEST_F(AsyncHostResolverTest, CancelSameHostLookup) {
   HostResolver::RequestHandle req0 = NULL;
 
   // Pass the info0_ to both requests.
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, &req0,
-                               BoundNetLog());
-  int rv1 = resolver_->Resolve(info0_, &addrlist1_, &callback1_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(),
+                               &req0, BoundNetLog());
+  int rv1 = resolver_->Resolve(info0_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
 
   resolver_->CancelRequest(req0);
   MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(callback0_.have_result());
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_);
 
   EXPECT_EQ(1u, factory_.udp_client_sockets().size());
 }
 
 // Test that a queued lookup completes.
 TEST_F(AsyncHostResolverTest, QueuedLookup) {
   // kMaxTransactions is 2, thus the following requests consume all
   // available transactions.
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
 
   // The following request will end up in queue.
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv2);
   EXPECT_EQ(1u,
       static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending());
 
   // Make sure all requests complete.
   rv0 = callback0_.WaitForResult();
   EXPECT_EQ(OK, rv0);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses1_, kPortNum, addrlist1_);
 
   rv2 = callback2_.WaitForResult();
   EXPECT_EQ(OK, rv2);
   VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_);
 }
 
 // Test that cancelling a queued lookup works.
 TEST_F(AsyncHostResolverTest, CancelPendingLookup) {
   // kMaxTransactions is 2, thus the following requests consume all
   // available transactions.
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
 
   // The following request will end up in queue.
   HostResolver::RequestHandle req2 = NULL;
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, &req2,
-                               BoundNetLog());
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(),
+                               &req2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv2);
   EXPECT_EQ(1u,
       static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending());
 
   resolver_->CancelRequest(req2);
 
   // Make sure first two requests complete while the cancelled one doesn't.
   MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(callback2_.have_result());
 
   rv0 = callback0_.WaitForResult();
   EXPECT_EQ(OK, rv0);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses1_, kPortNum, addrlist1_);
 }
 
 TEST_F(AsyncHostResolverTest, ResolverDestructionCancelsLookups) {
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   // This one is queued.
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(1u,
       static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending());
 
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
   EXPECT_EQ(ERR_IO_PENDING, rv2);
 
   resolver_.reset();
 
   MessageLoop::current()->RunAllPending();
 
   EXPECT_FALSE(callback0_.have_result());
   EXPECT_FALSE(callback1_.have_result());
   EXPECT_FALSE(callback2_.have_result());
 }
 
 // Test that when the number of pending lookups is at max, a new lookup
 // with a priority lower than all of those in the queue fails.
 TEST_F(AsyncHostResolverTest, OverflowQueueWithLowPriorityLookup) {
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   // This one is queued and fills up the queue since its size is 1.
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(1u,
       static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending());
 
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
   EXPECT_EQ(ERR_IO_PENDING, rv2);
 
   // This one fails.
   info3_.set_priority(LOWEST);
-  int rv3 = resolver_->Resolve(info3_, &addrlist3_, &callback3_, NULL,
+  int rv3 = resolver_->Resolve(info3_, &addrlist3_, callback3_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv3);
 
   MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(callback3_.have_result());
 }
 
 // Test that when the number of pending lookups is at max, a new lookup
 // with a priority higher than any of those in the queue succeeds and
 // causes the lowest priority lookup in the queue to fail.
 TEST_F(AsyncHostResolverTest, OverflowQueueWithHighPriorityLookup) {
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
 
   // Next lookup is queued.  Since this will be ejected from the queue and
   // will not consume a socket from our factory, we are not passing it
   // predefined members.
   HostResolver::RequestInfo info(HostPortPair("cnn.com", 80));
   info.set_address_family(ADDRESS_FAMILY_IPV4);
   AddressList addrlist_fail;
-  TestOldCompletionCallback callback_fail;
-  int rv_fail = resolver_->Resolve(info, &addrlist_fail, &callback_fail, NULL,
+  TestCompletionCallback callback_fail;
+  int rv_fail = resolver_->Resolve(info, &addrlist_fail,
+                                   callback_fail.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(1u,
       static_cast<AsyncHostResolver*>(resolver_.get())->GetNumPending());
 
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
   EXPECT_EQ(ERR_IO_PENDING, rv_fail);
 
   // Lookup 2 causes the above to fail, but itself should succeed.
   info2_.set_priority(HIGHEST);
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
 
   rv0 = callback0_.WaitForResult();
   EXPECT_EQ(OK, rv0);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses1_, kPortNum, addrlist1_);
 
   rv_fail = callback_fail.WaitForResult();
   EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv_fail);
   EXPECT_EQ(static_cast<addrinfo*>(NULL), addrlist_fail.head());
 
   rv2 = callback2_.WaitForResult();
   EXPECT_EQ(OK, rv2);
   VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_);
 }
 
 // Test that registering, unregistering, and notifying of observers of
 // resolution start, completion and cancellation (both due to CancelRequest
 // and resolver destruction) work.
 TEST_F(AsyncHostResolverTest, Observers) {
   TestHostResolverObserver observer;
   resolver_->AddObserver(&observer);
 
-  int rv0 = resolver_->Resolve(info0_, &addrlist0_, &callback0_, NULL,
+  int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
-  int rv1 = resolver_->Resolve(info1_, &addrlist1_, &callback1_, NULL,
+  int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   // We will cancel this one.
   HostResolver::RequestHandle req2 = NULL;
-  int rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, &req2,
-                               BoundNetLog());
+  int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(),
+                               &req2, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
   EXPECT_EQ(ERR_IO_PENDING, rv2);
 
   // Cancel lookup 2.
   resolver_->CancelRequest(req2);
 
   // Lookup 0 and 1 should succeed.
   rv0 = callback0_.WaitForResult();
   EXPECT_EQ(OK, rv0);
@@ skipping 27 matching lines @@
   // Lookup 2 was cancelled, hence, failed to finish.
   EXPECT_TRUE(observer.start_log[2] ==
               TestHostResolverObserver::StartOrCancelEntry(2, info2_));
   EXPECT_TRUE(observer.cancel_log[0] ==
               TestHostResolverObserver::StartOrCancelEntry(2, info2_));
 
   // Unregister observer.
   resolver_->RemoveObserver(&observer);
 
   // We will do lookup 2 again but will not cancel it this time.
-  rv2 = resolver_->Resolve(info2_, &addrlist2_, &callback2_, NULL,
+  rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(), NULL,
                            BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv2);
 
   // Run lookup 2 to completion.
   rv2 = callback2_.WaitForResult();
   EXPECT_EQ(OK, rv2);
   VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_);
 
   // Observer log should stay the same.
   EXPECT_EQ(3u, observer.start_log.size());
   EXPECT_EQ(2u, observer.finish_log.size());
   EXPECT_EQ(1u, observer.cancel_log.size());
 
   // Re-register observer.
   resolver_->AddObserver(&observer);
 
   // Start lookup 3.
-  int rv3 = resolver_->Resolve(info3_, &addrlist3_, &callback3_, NULL,
+  int rv3 = resolver_->Resolve(info3_, &addrlist3_, callback3_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv3);
 
   // Destroy the resolver and make sure that observer was notified of just
   // the resolution start.
   resolver_.reset();
 
   EXPECT_EQ(4u, observer.start_log.size()); // Was incremented by 1.
   EXPECT_EQ(2u, observer.finish_log.size());
   EXPECT_EQ(2u, observer.cancel_log.size());
 
   EXPECT_TRUE(observer.start_log[3] ==
               TestHostResolverObserver::StartOrCancelEntry(4, info3_));
 }
 
 }  // namespace net