Convert implicit scoped_refptr constructor calls to explicit ones, part 1

net/base/host_resolver_impl_unittest.cc

 // Copyright (c) 2010 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/compiler_specific.h"
 #include "base/message_loop.h"
@@ skipping 241 matching lines @@
     callback_called_ = true;
     callback_result_ = result;
     MessageLoop::current()->Quit();
   }
 };
 
 TEST_F(HostResolverImplTest, SynchronousLookup) {
   AddressList addrlist;
   const int kPortnum = 80;
 
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   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, NULL, NULL, log.bound());
   EXPECT_EQ(OK, err);
 
@@ skipping 10 matching lines @@
   const struct sockaddr* sa = ainfo->ai_addr;
   const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa;
   EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port);
   EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr);
 }
 
 TEST_F(HostResolverImplTest, AsynchronousLookup) {
   AddressList addrlist;
   const int kPortnum = 80;
 
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AddRule("just.testing", "192.168.1.42");
 
   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);
@@ skipping 15 matching lines @@
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
   EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen);
 
   const struct sockaddr* sa = ainfo->ai_addr;
   const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa;
   EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port);
   EXPECT_TRUE(htonl(0xc0a8012a) == sa_in->sin_addr.s_addr);
 }
 
 TEST_F(HostResolverImplTest, CanceledAsynchronousLookup) {
-  scoped_refptr<WaitingHostResolverProc> resolver_proc =
-      new WaitingHostResolverProc(NULL);
+  scoped_refptr<WaitingHostResolverProc> resolver_proc(
+      new WaitingHostResolverProc(NULL));
 
   CapturingNetLog net_log(CapturingNetLog::kUnbounded);
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   {
     scoped_ptr<HostResolver> host_resolver(
         new HostResolverImpl(resolver_proc,
                              CreateDefaultCache(),
                              kMaxJobs,
                              &net_log));
     AddressList addrlist;
@@ skipping 40 matching lines @@
   net::ExpectLogContainsSomewhereAfter(net_log.entries(), pos + 1,
       net::NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
       net::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 =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
   const int kPortnum = 5555;
   HostResolver::RequestInfo info(HostPortPair("127.1.2.3", kPortnum));
   int err = host_resolver->Resolve(info, &addrlist, NULL, NULL, BoundNetLog());
   EXPECT_EQ(OK, err);
 
   const struct addrinfo* ainfo = addrlist.head();
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
   EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen);
 
   const struct sockaddr* sa = ainfo->ai_addr;
   const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa;
   EXPECT_TRUE(htons(kPortnum) == sa_in->sin_port);
   EXPECT_TRUE(htonl(0x7f010203) == sa_in->sin_addr.s_addr);
 }
 
 TEST_F(HostResolverImplTest, NumericIPv6Address) {
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   // Resolve a plain IPv6 address.  Don't worry about [brackets], because
   // the caller should have removed them.
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
   const int kPortnum = 5555;
   HostResolver::RequestInfo info(HostPortPair("2001:db8::1", kPortnum));
   int err = host_resolver->Resolve(info, &addrlist, NULL, NULL, BoundNetLog());
@@ skipping 10 matching lines @@
   const uint8 expect_addr[] = {
     0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
   };
   for (int i = 0; i < 16; i++) {
     EXPECT_EQ(expect_addr[i], sa_in6->sin6_addr.s6_addr[i]);
   }
 }
 
 TEST_F(HostResolverImplTest, EmptyHost) {
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
   const int kPortnum = 5555;
   HostResolver::RequestInfo info(HostPortPair("", kPortnum));
   int err = host_resolver->Resolve(info, &addrlist, NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err);
 }
 
 TEST_F(HostResolverImplTest, LongHost) {
-  scoped_refptr<RuleBasedHostResolverProc> resolver_proc =
-      new RuleBasedHostResolverProc(NULL);
+  scoped_refptr<RuleBasedHostResolverProc> resolver_proc(
+      new RuleBasedHostResolverProc(NULL));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
   const int kPortnum = 5555;
   std::string hostname(4097, 'a');
   HostResolver::RequestInfo info(HostPortPair(hostname, kPortnum));
   int err = host_resolver->Resolve(info, &addrlist, NULL, NULL, BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err);
@@ skipping 42 matching lines @@
   int count_a_;
   int count_b_;
   CapturingHostResolverProc* resolver_proc_;
 
   DISALLOW_COPY_AND_ASSIGN(DeDupeRequestsVerifier);
 };
 
 TEST_F(HostResolverImplTest, DeDupeRequests) {
   // Use a capturing resolver_proc, since the verifier needs to know what calls
   // reached Resolve().  Also, the capturing resolver_proc is initially blocked.
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   DeDupeRequestsVerifier verifier(resolver_proc.get());
 
   // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
@@ skipping 29 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CancelMultipleRequestsVerifier);
 };
 
 TEST_F(HostResolverImplTest, CancelMultipleRequests) {
   // 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);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   CancelMultipleRequestsVerifier verifier;
 
   // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
@@ skipping 65 matching lines @@
   ResolveRequest* req_to_cancel1_;
   ResolveRequest* req_to_cancel2_;
   int num_completions_;
   DISALLOW_COPY_AND_ASSIGN(CancelWithinCallbackVerifier);
 };
 
 TEST_F(HostResolverImplTest, CancelWithinCallback) {
   // 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);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened.
   CancelWithinCallbackVerifier verifier;
 
   // Start 4 requests, duplicating hosts "a". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
@@ skipping 35 matching lines @@
 
  private:
   scoped_ptr<HostResolver> host_resolver_;
   DISALLOW_COPY_AND_ASSIGN(DeleteWithinCallbackVerifier);
 };
 
 TEST_F(HostResolverImplTest, DeleteWithinCallback) {
   // 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);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // The class will receive callbacks for when each resolve completes. It
   // checks that the right things happened. Note that the verifier holds the
   // only reference to |host_resolver|, so it can delete it within callback.
   HostResolver* host_resolver =
       CreateHostResolverImpl(resolver_proc);
   DeleteWithinCallbackVerifier verifier(host_resolver);
 
   // Start 4 requests, duplicating hosts "a". Since the resolver_proc is
   // blocked, these should all pile up until we signal it.
@@ skipping 33 matching lines @@
  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);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // Turn off caching for this host resolver.
   scoped_ptr<HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, NULL, kMaxJobs, 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
@@ skipping 310 matching lines @@
 
   // Resolve "host1" again -- this time it won't be served from cache, so it
   // will complete asynchronously.
   rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL, BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);  // Should complete asynchronously.
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Test that IP address changes send ERR_ABORTED to pending requests.
 TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) {
-  scoped_refptr<WaitingHostResolverProc> resolver_proc =
-      new WaitingHostResolverProc(NULL);
+  scoped_refptr<WaitingHostResolverProc> resolver_proc(
+      new WaitingHostResolverProc(NULL));
   HostCache* cache = CreateDefaultCache();
   scoped_ptr<HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, cache, kMaxJobs, NULL));
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   TestCompletionCallback callback;
   AddressList addrlist;
   int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunAllPending();  // Notification happens async.
   resolver_proc->Signal();
 
   EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
   EXPECT_EQ(0u, cache->size());
 }
 
 // Obey pool constraints after IP address has changed.
 TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
-  scoped_refptr<WaitingHostResolverProc> resolver_proc =
-      new WaitingHostResolverProc(NULL);
+  scoped_refptr<WaitingHostResolverProc> resolver_proc(
+      new WaitingHostResolverProc(NULL));
   scoped_ptr<MockHostResolver> host_resolver(new MockHostResolver());
   host_resolver->Reset(resolver_proc);
 
   const size_t kMaxOutstandingJobs = 1u;
   const size_t kMaxPendingRequests = 1000000u;  // not relevant.
   host_resolver->SetPoolConstraints(HostResolverImpl::POOL_NORMAL,
                                     kMaxOutstandingJobs,
                                     kMaxPendingRequests);
 
   // Resolve "host1".
@@ skipping 50 matching lines @@
 
  private:
   MockHostResolver* const host_resolver_;
   const HostResolver::RequestInfo info_;
   AddressList addrlist_;
   TestCompletionCallback callback_;
   TestCompletionCallback nested_callback_;
 };
 
 TEST_F(HostResolverImplTest, OnlyAbortExistingRequestsOnIPAddressChange) {
-  scoped_refptr<WaitingHostResolverProc> resolver_proc =
-      new WaitingHostResolverProc(NULL);
+  scoped_refptr<WaitingHostResolverProc> resolver_proc(
+      new WaitingHostResolverProc(NULL));
   scoped_ptr<MockHostResolver> host_resolver(new MockHostResolver());
   host_resolver->Reset(resolver_proc);
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
   ResolveWithinCallback callback(host_resolver.get(), info);
   AddressList addrlist;
   int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunAllPending();  // Notification happens async.
 
   EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
   resolver_proc->Signal();
   EXPECT_EQ(OK, callback.WaitForNestedResult());
 }
 
 // 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_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   size_t kMaxJobs = 1u;
   scoped_ptr<HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs,
                            NULL));
 
   CapturingObserver observer;
   host_resolver->AddObserver(&observer);
 
@@ skipping 63 matching lines @@
   EXPECT_EQ(LOW, observer.finish_log[3].info.priority());
 
   EXPECT_EQ("req1", observer.finish_log[4].info.hostname());
   EXPECT_EQ("req2", observer.finish_log[5].info.hostname());
   EXPECT_EQ("req3", observer.finish_log[6].info.hostname());
   EXPECT_EQ("req6", observer.finish_log[7].info.hostname());
 }
 
 // Try cancelling a request which has not been attached to a job yet.
 TEST_F(HostResolverImplTest, CancelPendingRequest) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxJobs = 1u;
   scoped_ptr<HostResolver> host_resolver(
       new HostResolverImpl(resolver_proc, CreateDefaultCache(), kMaxJobs,
                            NULL));
 
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
 
@@ skipping 41 matching lines @@
   ASSERT_EQ(4u, capture_list.size());
 
   EXPECT_EQ("req0", capture_list[0].hostname);
   EXPECT_EQ("req2", capture_list[1].hostname);
   EXPECT_EQ("req6", capture_list[2].hostname);
   EXPECT_EQ("req3", capture_list[3].hostname);
 }
 
 // Test that when too many requests are enqueued, old ones start to be aborted.
 TEST_F(HostResolverImplTest, QueueOverflow) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(NULL);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(NULL));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
   scoped_ptr<HostResolverImpl> host_resolver(new HostResolverImpl(
       resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs, NULL));
 
   // Only allow up to 3 requests to be enqueued at a time.
   const size_t kMaxPendingRequests = 3u;
   host_resolver->SetPoolConstraints(HostResolverImpl::POOL_NORMAL,
                                     kMaxOutstandingJobs,
@@ skipping 56 matching lines @@
 
   EXPECT_EQ("req0", capture_list[0].hostname);
   EXPECT_EQ("req1", capture_list[1].hostname);
   EXPECT_EQ("req6", capture_list[2].hostname);
   EXPECT_EQ("req7", capture_list[3].hostname);
 }
 
 // Tests that after changing the default AddressFamily to IPV4, requests
 // with UNSPECIFIED address family map to IPV4.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(new EchoingHostResolverProc);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(new EchoingHostResolverProc));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
   scoped_ptr<HostResolverImpl> host_resolver(new HostResolverImpl(
       resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs, NULL));
 
   host_resolver->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
@@ skipping 46 matching lines @@
   //    z = value of address family
   EXPECT_EQ("192.2.104.1", NetAddressToString(addrlist[0].head()));
   EXPECT_EQ("192.2.104.1", NetAddressToString(addrlist[1].head()));
   EXPECT_EQ("192.2.104.2", NetAddressToString(addrlist[2].head()));
 }
 
 // This is the exact same test as SetDefaultAddressFamily_IPv4, except the order
 // of requests 0 and 1 is flipped, and the default is set to IPv6 in place of
 // IPv4.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(new EchoingHostResolverProc);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(new EchoingHostResolverProc));
 
   // This HostResolverImpl will only allow 1 outstanding resolve at a time.
   const size_t kMaxOutstandingJobs = 1u;
   scoped_ptr<HostResolverImpl> host_resolver(new HostResolverImpl(
       resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs, NULL));
 
   host_resolver->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV6);
 
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
@@ skipping 45 matching lines @@
   //    y = ASCII value of hostname[0]
   //    z = value of address family
   EXPECT_EQ("192.2.104.2", NetAddressToString(addrlist[0].head()));
   EXPECT_EQ("192.2.104.2", NetAddressToString(addrlist[1].head()));
   EXPECT_EQ("192.2.104.1", NetAddressToString(addrlist[2].head()));
 }
 
 // This tests that the default address family is respected for synchronous
 // resolutions.
 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_Synchronous) {
-  scoped_refptr<CapturingHostResolverProc> resolver_proc =
-      new CapturingHostResolverProc(new EchoingHostResolverProc);
+  scoped_refptr<CapturingHostResolverProc> resolver_proc(
+      new CapturingHostResolverProc(new EchoingHostResolverProc));
 
   const size_t kMaxOutstandingJobs = 10u;
   scoped_ptr<HostResolverImpl> host_resolver(new HostResolverImpl(
       resolver_proc, CreateDefaultCache(), kMaxOutstandingJobs, NULL));
 
   host_resolver->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4);
 
   // Unblock the resolver thread so the requests can run.
   resolver_proc->Signal();
 
@@ skipping 35 matching lines @@
   EXPECT_EQ("192.1.98.2", NetAddressToString(addrlist[1].head()));
   EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[2].head()));
   EXPECT_EQ("192.1.98.1", NetAddressToString(addrlist[3].head()));
 }
 
 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags.
 
 }  // namespace
 
 }  // namespace net