base::Bind: Convert HostResolver::Resolve.

net/base/host_resolver_impl_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/base/host_resolver_impl.h"
 
 #include <string>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/time.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
@@ skipping 242 matching lines @@
     virtual ~Delegate() {}
     virtual void OnCompleted(ResolveRequest* resolve) = 0;
   };
 
   ResolveRequest(HostResolver* resolver,
                  const std::string& hostname,
                  int port,
                  Delegate* delegate)
       : info_(HostPortPair(hostname, port)),
         resolver_(resolver),
-        delegate_(delegate),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            callback_(this, &ResolveRequest::OnLookupFinished)) {
+        delegate_(delegate)  {
     // Start the request.
-    int err = resolver->Resolve(info_, &addrlist_, &callback_, &req_,
-                                BoundNetLog());
+    int err = resolver->Resolve(
+        info_, &addrlist_,
+        base::Bind(&ResolveRequest::OnLookupFinished, base::Unretained(this)),
+        &req_, BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, err);
   }
 
   ResolveRequest(HostResolver* resolver,
                  const HostResolver::RequestInfo& info,
                  Delegate* delegate)
-      : info_(info), resolver_(resolver), delegate_(delegate),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            callback_(this, &ResolveRequest::OnLookupFinished)) {
+      : info_(info), resolver_(resolver), delegate_(delegate) {
     // Start the request.
-    int err = resolver->Resolve(info, &addrlist_, &callback_, &req_,
-                                BoundNetLog());
+    int err = resolver->Resolve(
+        info, &addrlist_,
+        base::Bind(&ResolveRequest::OnLookupFinished,
+                   base::Unretained(this)),
+       &req_, BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, err);
   }
 
   void Cancel() {
     resolver_->CancelRequest(req_);
   }
 
   const std::string& hostname() const {
     return info_.hostname();
   }
@@ skipping 24 matching lines @@
   HostResolver::RequestInfo info_;
   HostResolver::RequestHandle req_;
 
   // The result of the resolve.
   int result_;
   AddressList addrlist_;
 
   HostResolver* resolver_;
 
   Delegate* delegate_;
-  OldCompletionCallbackImpl<ResolveRequest> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ResolveRequest);
 };
 
 class HostResolverImplTest : public testing::Test {
  public:
   HostResolverImplTest()
       : callback_called_(false),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            callback_(this, &HostResolverImplTest::OnLookupFinished)) {
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&HostResolverImplTest::OnLookupFinished,
+                       base::Unretained(this)))) {
   }
 
  protected:
-  bool callback_called_;
-  int callback_result_;
-  OldCompletionCallbackImpl<HostResolverImplTest> callback_;
-
- private:
   void OnLookupFinished(int result) {
     callback_called_ = true;
     callback_result_ = result;
     MessageLoop::current()->Quit();
   }
+
+  bool callback_called_;
+  int callback_result_;
+  CompletionCallback callback_;
 };
 
 TEST_F(HostResolverImplTest, AsynchronousLookup) {
   AddressList addrlist;
   const int kPortnum = 80;
 
   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,
+  int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                    log.bound());
   EXPECT_EQ(ERR_IO_PENDING, err);
 
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(1u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
 
@@ skipping 69 matching lines @@
     scoped_ptr<HostResolver> host_resolver(
         new HostResolverImpl(resolver_proc,
                              HostCache::CreateDefaultCache(),
                              kMaxJobs,
                              kMaxRetryAttempts,
                              &net_log));
     AddressList addrlist;
     const int kPortnum = 80;
 
     HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
-    int err = host_resolver->Resolve(info, &addrlist, &callback_, NULL,
+    int err = host_resolver->Resolve(info, &addrlist, callback_, NULL,
                                      log.bound());
     EXPECT_EQ(ERR_IO_PENDING, err);
 
     resolver_proc->Wait();
   }
 
   resolver_proc->Signal();
 
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
@@ skipping 36 matching lines @@
   // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in.
 
   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;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HostResolver::RequestInfo info(HostPortPair("127.1.2.3", kPortnum));
-  int err = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int err = host_resolver->Resolve(info, &addrlist, callback.callback(), 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));
   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;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HostResolver::RequestInfo info(HostPortPair("2001:db8::1", kPortnum));
-  int err = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int err = host_resolver->Resolve(info, &addrlist, callback.callback(), 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_in6), ainfo->ai_addrlen);
 
   const struct sockaddr* sa = ainfo->ai_addr;
   const struct sockaddr_in6* sa_in6 = (const struct sockaddr_in6*) sa;
   EXPECT_TRUE(htons(kPortnum) == sa_in6->sin6_port);
 
   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));
   resolver_proc->AllowDirectLookup("*");
 
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
   AddressList addrlist;
   const int kPortnum = 5555;
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HostResolver::RequestInfo info(HostPortPair("", kPortnum));
-  int err = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err);
 }
 
 TEST_F(HostResolverImplTest, LongHost) {
   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');
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   HostResolver::RequestInfo info(HostPortPair(hostname, kPortnum));
-  int err = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                    BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, err);
 }
 
 // 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)
@@ skipping 323 matching lines @@
 
   virtual void OnCompleted(ResolveRequest* resolve) {
     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. We can't specify NULL though since that would
-      // mean synchronous mode so we give it a value of 1.
-      OldCompletionCallback* junk_callback =
-          reinterpret_cast<OldCompletionCallback*> (1);
+      // complete synchronously.
+      TestCompletionCallback junk_callback;
       AddressList addrlist;
 
       HostResolver::RequestInfo info(HostPortPair("a", 70));
-      int error = resolver->Resolve(info, &addrlist, junk_callback, NULL,
-                                    BoundNetLog());
+      int error = resolver->Resolve(info, &addrlist, junk_callback.callback(),
+                                    NULL, BoundNetLog());
       EXPECT_EQ(OK, error);
 
       // Ok good. Now make sure that if we ask to bypass the cache, it can no
       // longer service the request synchronously.
       info = HostResolver::RequestInfo(HostPortPair("a", 71));
       info.set_allow_cached_response(false);
       final_request_.reset(new ResolveRequest(resolver, info, this));
     } else if (71 == resolve->port()) {
       // Test is done.
       MessageLoop::current()->Quit();
@@ skipping 31 matching lines @@
 
   TestHostResolverObserver observer;
 
   host_resolver->AddObserver(&observer);
 
   AddressList addrlist;
 
   // Resolve "host1".
   HostResolver::RequestInfo info1(HostPortPair("host1", 70));
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
-  TestOldCompletionCallback callback;
-  int rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL,
+  TestCompletionCallback callback;
+  int rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL,
                                   log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
 
   EXPECT_EQ(2u, entries.size());
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_HOST_RESOLVER_IMPL));
   EXPECT_TRUE(LogContainsEndEvent(
       entries, 1, NetLog::TYPE_HOST_RESOLVER_IMPL));
 
   EXPECT_EQ(1U, observer.start_log.size());
   EXPECT_EQ(1U, observer.finish_log.size());
   EXPECT_EQ(0U, observer.cancel_log.size());
   EXPECT_TRUE(observer.start_log[0] ==
               TestHostResolverObserver::StartOrCancelEntry(0, info1));
   EXPECT_TRUE(observer.finish_log[0] ==
               TestHostResolverObserver::FinishEntry(0, true, info1));
 
   // Resolve "host1" again -- this time it  will be served from cache, but it
   // should still notify of completion.
-  rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL, BoundNetLog());
+  rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL,
+                              BoundNetLog());
   ASSERT_EQ(OK, rv);  // Should complete synchronously.
 
   EXPECT_EQ(2U, observer.start_log.size());
   EXPECT_EQ(2U, observer.finish_log.size());
   EXPECT_EQ(0U, observer.cancel_log.size());
   EXPECT_TRUE(observer.start_log[1] ==
               TestHostResolverObserver::StartOrCancelEntry(1, info1));
   EXPECT_TRUE(observer.finish_log[1] ==
               TestHostResolverObserver::FinishEntry(1, true, info1));
 
   // Resolve "host2", setting referrer to "http://foobar.com"
   HostResolver::RequestInfo info2(HostPortPair("host2", 70));
   info2.set_referrer(GURL("http://foobar.com"));
-  rv = host_resolver->Resolve(info2, &addrlist, &callback, NULL, BoundNetLog());
+  rv = host_resolver->Resolve(info2, &addrlist, callback.callback(), NULL,
+                              BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_EQ(3U, observer.start_log.size());
   EXPECT_EQ(3U, observer.finish_log.size());
   EXPECT_EQ(0U, observer.cancel_log.size());
   EXPECT_TRUE(observer.start_log[2] ==
               TestHostResolverObserver::StartOrCancelEntry(2, info2));
   EXPECT_TRUE(observer.finish_log[2] ==
               TestHostResolverObserver::FinishEntry(2, true, info2));
 
   // Unregister the observer.
   host_resolver->RemoveObserver(&observer);
 
   // Resolve "host3"
   HostResolver::RequestInfo info3(HostPortPair("host3", 70));
-  host_resolver->Resolve(info3, &addrlist, &callback, NULL, BoundNetLog());
+  host_resolver->Resolve(info3, &addrlist, callback.callback(), NULL,
+                         BoundNetLog());
 
   // No effect this time, since observer was removed.
   EXPECT_EQ(3U, observer.start_log.size());
   EXPECT_EQ(3U, observer.finish_log.size());
   EXPECT_EQ(0U, observer.cancel_log.size());
 }
 
 // Tests that observers are sent OnCancelResolution() whenever a request is
 // cancelled. There are two ways to cancel a request:
 //  (1) Delete the HostResolver while job is outstanding.
 //  (2) Call HostResolver::CancelRequest() while a request is outstanding.
 TEST_F(HostResolverImplTest, CancellationObserver) {
   TestHostResolverObserver observer;
   {
     // Create a host resolver and attach an observer.
     scoped_ptr<HostResolver> host_resolver(
         CreateHostResolverImpl(NULL));
     host_resolver->AddObserver(&observer);
 
-    TestOldCompletionCallback callback;
+    TestCompletionCallback callback;
 
     EXPECT_EQ(0U, observer.start_log.size());
     EXPECT_EQ(0U, observer.finish_log.size());
     EXPECT_EQ(0U, observer.cancel_log.size());
 
     // Start an async resolve for (host1:70).
     HostResolver::RequestInfo info1(HostPortPair("host1", 70));
     HostResolver::RequestHandle req = NULL;
     AddressList addrlist;
-    int rv = host_resolver->Resolve(info1, &addrlist, &callback, &req,
+    int rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), &req,
                                     BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_TRUE(NULL != req);
 
     EXPECT_EQ(1U, observer.start_log.size());
     EXPECT_EQ(0U, observer.finish_log.size());
     EXPECT_EQ(0U, observer.cancel_log.size());
 
     EXPECT_TRUE(observer.start_log[0] ==
                 TestHostResolverObserver::StartOrCancelEntry(0, info1));
 
     // Cancel the request.
     host_resolver->CancelRequest(req);
 
     EXPECT_EQ(1U, observer.start_log.size());
     EXPECT_EQ(0U, observer.finish_log.size());
     EXPECT_EQ(1U, observer.cancel_log.size());
 
     EXPECT_TRUE(observer.cancel_log[0] ==
                 TestHostResolverObserver::StartOrCancelEntry(0, info1));
 
     // Start an async request for (host2:60)
     HostResolver::RequestInfo info2(HostPortPair("host2", 60));
-    rv = host_resolver->Resolve(info2, &addrlist, &callback, NULL,
+    rv = host_resolver->Resolve(info2, &addrlist, callback.callback(), NULL,
                                 BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
     EXPECT_TRUE(NULL != req);
 
     EXPECT_EQ(2U, observer.start_log.size());
     EXPECT_EQ(0U, observer.finish_log.size());
     EXPECT_EQ(1U, observer.cancel_log.size());
 
     EXPECT_TRUE(observer.start_log[1] ==
                 TestHostResolverObserver::StartOrCancelEntry(1, info2));
@@ skipping 17 matching lines @@
 // Test that IP address changes flush the cache.
 TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) {
   scoped_ptr<HostResolver> host_resolver(
       new HostResolverImpl(NULL, HostCache::CreateDefaultCache(), kMaxJobs,
                            kMaxRetryAttempts, NULL));
 
   AddressList addrlist;
 
   // Resolve "host1".
   HostResolver::RequestInfo info1(HostPortPair("host1", 70));
-  TestOldCompletionCallback callback;
-  int rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL,
+  TestCompletionCallback callback;
+  int rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Resolve "host1" again -- this time it will be served from cache, but it
   // should still notify of completion.
-  rv = host_resolver->Resolve(info1, &addrlist, &callback, NULL, BoundNetLog());
+  rv = host_resolver->Resolve(info1, &addrlist, callback.callback(), NULL,
+                              BoundNetLog());
   ASSERT_EQ(OK, rv);  // Should complete synchronously.
 
   // Flush cache by triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunAllPending();  // Notification happens async.
 
   // 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());
+  rv = host_resolver->Resolve(info1, &addrlist, callback.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_ptr<HostResolver> host_resolver(CreateHostResolverImpl(resolver_proc));
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   AddressList addrlist;
-  int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   resolver_proc->Wait();
   // 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, host_resolver->GetHostCache()->size());
 }
 
 // Obey pool constraints after IP address has changed.
 TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) {
   scoped_refptr<WaitingHostResolverProc> resolver_proc(
       new WaitingHostResolverProc(CreateCatchAllHostResolverProc()));
   scoped_ptr<HostResolverImpl> host_resolver(
       new HostResolverImpl(resolver_proc, HostCache::CreateDefaultCache(),
                            kMaxJobs, kMaxRetryAttempts, NULL));
 
   const size_t kMaxOutstandingJobs = 1u;
   const size_t kMaxPendingRequests = 1000000u;  // not relevant.
   host_resolver->SetPoolConstraints(HostResolverImpl::POOL_NORMAL,
                                     kMaxOutstandingJobs,
                                     kMaxPendingRequests);
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   AddressList addrlist;
-  int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  int rv = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Must wait before signal to ensure that the two signals don't get merged
   // together. (Worker threads might not start until the last WaitForResult.)
   resolver_proc->Wait();
   // Triggering an IP address change.
   NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   MessageLoop::current()->RunAllPending();  // Notification happens async.
   resolver_proc->Signal();
 
   EXPECT_EQ(ERR_ABORTED, callback.WaitForResult());
 
-  rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  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 : public CallbackRunner< Tuple1<int> > {
  public:
   explicit ResolveWithinCallback(const HostResolver::RequestInfo& info)
       : info_(info) {}
 
   virtual void RunWithParams(const Tuple1<int>& params) {
     // Ditch the WaitingHostResolverProc so that the subsequent request
     // succeeds.
-    callback_.RunWithParams(params);
+    //callback_.RunWithParams(params);

[willchan no longer on Chromium, 2011/11/14 16:45:12]

Change this to callback_.callback()->Run(params.a)?

[James Hawkins, 2011/11/15 23:34:33]

Unfortunately the issue is that Resolve takes a CompletionCallback which is now
a typedef for base::Calback<...> which cannot be inherited from, so we can't use
ResolveWithinCallback (as it is written) at all.

[willchan no longer on Chromium, 2011/11/16 00:08:01]

Oh, you probably want to do the same transformation I did for
OldTestCompletionCallback=>TestCompletionCallback. Check out
net/base/test_completion_callback.h.

[James Hawkins, 2011/11/16 00:49:54]

Cool, done.

     host_resolver_.reset(
         CreateHostResolverImpl(CreateCatchAllHostResolverProc()));
     EXPECT_EQ(ERR_IO_PENDING,
-              host_resolver_->Resolve(info_, &addrlist_, &nested_callback_,
-                                      NULL, BoundNetLog()));
+              host_resolver_->Resolve(info_, &addrlist_,
+                                      nested_callback_.callback(), NULL,
+                                      BoundNetLog()));
   }
 
   int WaitForResult() {
     return callback_.WaitForResult();
   }
 
   int WaitForNestedResult() {
     return nested_callback_.WaitForResult();
   }
 
  private:
   const HostResolver::RequestInfo info_;
   AddressList addrlist_;
-  TestOldCompletionCallback callback_;
-  TestOldCompletionCallback nested_callback_;
+  TestCompletionCallback callback_;
+  TestCompletionCallback nested_callback_;
   scoped_ptr<HostResolver> host_resolver_;
 };
 
 TEST_F(HostResolverImplTest, OnlyAbortExistingRequestsOnIPAddressChange) {
   scoped_refptr<WaitingHostResolverProc> resolver_proc(
       new WaitingHostResolverProc(CreateCatchAllHostResolverProc()));
   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, NULL,
+  int rv = host_resolver->Resolve(info, &addrlist, /*callback.callback()*/CompletionCallback(), NULL,
                                   BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   resolver_proc->Wait();
   // Triggering 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());
@@ skipping 22 matching lines @@
       CreateResolverRequest("req0", LOW),
       CreateResolverRequest("req1", MEDIUM),
       CreateResolverRequest("req2", MEDIUM),
       CreateResolverRequest("req3", LOW),
       CreateResolverRequest("req4", HIGHEST),
       CreateResolverRequest("req5", LOW),
       CreateResolverRequest("req6", LOW),
       CreateResolverRequest("req5", HIGHEST),
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], NULL, BoundNetLog());
+                                    callback[i].callback(), NULL,
+                                    BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   // Unblock the resolver thread so the requests can run.
   resolver_proc->Signal();
 
   // Wait for all the requests to complete succesfully.
   for (size_t i = 0; i < arraysize(req); ++i) {
     EXPECT_EQ(OK, callback[i].WaitForResult()) << "i=" << i;
   }
@@ skipping 55 matching lines @@
   HostResolver::RequestInfo req[] = {
       CreateResolverRequest("req0", LOWEST),
       CreateResolverRequest("req1", HIGHEST),  // Will cancel.
       CreateResolverRequest("req2", MEDIUM),
       CreateResolverRequest("req3", LOW),
       CreateResolverRequest("req4", HIGHEST),   // Will cancel.
       CreateResolverRequest("req5", LOWEST),    // Will cancel.
       CreateResolverRequest("req6", MEDIUM),
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
   HostResolver::RequestHandle handle[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], &handle[i], BoundNetLog());
+                                    callback[i].callback(), &handle[i],
+                                    BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv);
   }
 
   // Cancel some requests
   host_resolver->CancelRequest(handle[1]);
   host_resolver->CancelRequest(handle[4]);
   host_resolver->CancelRequest(handle[5]);
   handle[1] = handle[4] = handle[5] = NULL;
 
   // Unblock the resolver thread so the requests can run.
@@ skipping 48 matching lines @@
       // At this point, there are 3 enqueued requests.
       // Insertion of subsequent requests will cause evictions
       // based on priority.
 
       CreateResolverRequest("req4", LOW),      // Evicts itself!
       CreateResolverRequest("req5", MEDIUM),   // Evicts req3
       CreateResolverRequest("req6", HIGHEST),  // Evicts req5.
       CreateResolverRequest("req7", MEDIUM),   // Evicts req2.
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
   HostResolver::RequestHandle handle[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], &handle[i], BoundNetLog());
+                                    callback[i].callback(), &handle[i],
+                                    BoundNetLog());
     if (i == 4u)
       EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv);
     else
       EXPECT_EQ(ERR_IO_PENDING, rv) << i;
   }
 
   // Unblock the resolver thread so the requests can run.
   resolver_proc->Signal();
 
   // Requests 3, 5, 2 will have been evicted due to queue overflow.
@@ skipping 39 matching lines @@
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
 
   HostResolver::RequestInfo req[] = {
       CreateResolverRequestForAddressFamily("h1", MEDIUM,
                                             ADDRESS_FAMILY_UNSPECIFIED),
       CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV4),
       CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV6),
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
   HostResolver::RequestHandle handle[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], &handle[i], BoundNetLog());
+                                    callback[i].callback(), &handle[i],
+                                    BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv) << i;
   }
 
   // Unblock the resolver thread so the requests can run.
   resolver_proc->Signal();
 
   // Wait for all the requests to complete.
   for (size_t i = 0u; i < arraysize(req); ++i) {
     EXPECT_EQ(OK, callback[i].WaitForResult());
   }
@@ skipping 42 matching lines @@
   // Note that at this point the CapturingHostResolverProc is blocked, so any
   // requests we make will not complete.
 
   HostResolver::RequestInfo req[] = {
       CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV6),
       CreateResolverRequestForAddressFamily("h1", MEDIUM,
                                             ADDRESS_FAMILY_UNSPECIFIED),
       CreateResolverRequestForAddressFamily("h1", MEDIUM, ADDRESS_FAMILY_IPV4),
   };
 
-  TestOldCompletionCallback callback[arraysize(req)];
+  TestCompletionCallback callback[arraysize(req)];
   AddressList addrlist[arraysize(req)];
   HostResolver::RequestHandle handle[arraysize(req)];
 
   // Start all of the requests.
   for (size_t i = 0; i < arraysize(req); ++i) {
     int rv = host_resolver->Resolve(req[i], &addrlist[i],
-                                    &callback[i], &handle[i], BoundNetLog());
+                                    callback[i].callback(), &handle[i],
+                                    BoundNetLog());
     EXPECT_EQ(ERR_IO_PENDING, rv) << i;
   }
 
   // Unblock the resolver thread so the requests can run.
   resolver_proc->Signal();
 
   // Wait for all the requests to complete.
   for (size_t i = 0u; i < arraysize(req); ++i) {
     EXPECT_EQ(OK, callback[i].WaitForResult());
   }
@@ skipping 34 matching lines @@
   scoped_ptr<HostResolver> host_resolver(
       CreateHostResolverImpl(resolver_proc));
 
   // First hit will miss the cache.
   HostResolver::RequestInfo info(HostPortPair("just.testing", kPortnum));
   CapturingBoundNetLog log(CapturingNetLog::kUnbounded);
   int err = host_resolver->ResolveFromCache(info, &addrlist, log.bound());
   EXPECT_EQ(ERR_DNS_CACHE_MISS, err);
 
   // This time, we fetch normally.
-  TestOldCompletionCallback callback;
-  err = host_resolver->Resolve(info, &addrlist, &callback, NULL, log.bound());
+  TestCompletionCallback callback;
+  err = host_resolver->Resolve(info, &addrlist, callback.callback(), NULL,
+                               log.bound());
   EXPECT_EQ(ERR_IO_PENDING, err);
   err = callback.WaitForResult();
   EXPECT_EQ(OK, err);
 
   // Now we should be able to fetch from the cache.
   err = host_resolver->ResolveFromCache(info, &addrlist, log.bound());
   EXPECT_EQ(OK, err);
 
   const struct addrinfo* ainfo = addrlist.head();
   EXPECT_EQ(static_cast<addrinfo*>(NULL), ainfo->ai_next);
@@ skipping 23 matching lines @@
                            NULL));
 
   // 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).
   TimeDelta kUnresponsiveTime = TimeDelta::FromMilliseconds(500);
   host_resolver->set_unresponsive_delay(kUnresponsiveTime);
 
   // Resolve "host1".
   HostResolver::RequestInfo info(HostPortPair("host1", 70));
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   AddressList addrlist;
-  int rv = host_resolver->Resolve(info, &addrlist, &callback, NULL,
+  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