Create "Prebind" a wrapper to tr1::bind.

net/base/host_resolver_impl.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"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
 #endif
 
 #include <cmath>
 #include <deque>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/prebind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 347 matching lines @@
 
     if (!req->info().is_speculative())
       had_non_speculative_request_ = true;
   }
 
   // Called from origin loop.
   void Start() {
     start_time_ = base::TimeTicks::Now();
 
     // Dispatch the job to a worker thread.
-    if (!WorkerPool::PostTask(FROM_HERE,
-            NewRunnableMethod(this, &Job::DoLookup), true)) {
+    if (!WorkerPool::PostClosure(FROM_HERE,
+            base::Prebind(&Job::DoLookup, this), true)) {
       NOTREACHED();
 
       // Since we could be running within Resolve() right now, we can't just
       // call OnLookupComplete().  Instead we must wait until Resolve() has
       // returned (IO_PENDING).
       error_ = ERR_UNEXPECTED;
-      MessageLoop::current()->PostTask(
-          FROM_HERE, NewRunnableMethod(this, &Job::OnLookupComplete));
+      MessageLoop::current()->PostClosure(
+          FROM_HERE, base::Closure(&Job::OnLookupComplete, this));
     }
   }
 
   // Cancels the current job. Callable from origin thread.
   void Cancel() {
     net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
 
     HostResolver* resolver = resolver_;
     resolver_ = NULL;
 
@@ skipping 72 matching lines @@
                              key_.address_family,
                              key_.host_resolver_flags,
                              &results_,
                              &os_error_);
 
     // The origin loop could go away while we are trying to post to it, so we
     // need to call its PostTask method inside a lock.  See ~HostResolver.
     {
       AutoLock locked(origin_loop_lock_);
       if (origin_loop_) {
-        origin_loop_->PostTask(FROM_HERE,
-                               NewRunnableMethod(this, &Job::OnLookupComplete));
+        origin_loop_->PostClosure(FROM_HERE,
+                                  base::Closure(&Job::OnLookupComplete, this));
       }
     }
   }
 
   // Callback for when DoLookup() completes (runs on origin thread).
   void OnLookupComplete() {
     // Should be running on origin loop.
     // TODO(eroman): this is being hit by URLRequestTest.CancelTest*,
     // because MessageLoop::current() == NULL.
     //DCHECK_EQ(origin_loop_, MessageLoop::current());
@@ skipping 144 matching lines @@
       : resolver_(resolver),
         origin_loop_(MessageLoop::current()) {
     DCHECK(!was_cancelled());
   }
 
   void Start() {
     if (was_cancelled())
       return;
     DCHECK(IsOnOriginThread());
     const bool kIsSlow = true;
-    WorkerPool::PostTask(
-        FROM_HERE, NewRunnableMethod(this, &IPv6ProbeJob::DoProbe), kIsSlow);
+    WorkerPool::PostClosure(
+        FROM_HERE, base::Closure(&IPv6ProbeJob::DoProbe, this), kIsSlow);
   }
 
   // Cancels the current job.
   void Cancel() {
     if (was_cancelled())
       return;
     DCHECK(IsOnOriginThread());
     resolver_ = NULL;  // Read/write ONLY on origin thread.
     {
       AutoLock locked(origin_loop_lock_);
@@ skipping 17 matching lines @@
     }
     return false;
   }
 
   // Run on worker thread.
   void DoProbe() {
     // Do actual testing on this thread, as it takes 40-100ms.
     AddressFamily family = IPv6Supported() ? ADDRESS_FAMILY_UNSPECIFIED
                                            : ADDRESS_FAMILY_IPV4;
 
-    Task* reply = NewRunnableMethod(this, &IPv6ProbeJob::OnProbeComplete,
-                                    family);
+    base::Closure reply = base::Closure(&IPv6ProbeJob::OnProbeComplete, this,
+                                        family);
 
     // The origin loop could go away while we are trying to post to it, so we
     // need to call its PostTask method inside a lock.  See ~HostResolver.
     {
       AutoLock locked(origin_loop_lock_);
       if (origin_loop_) {
-        origin_loop_->PostTask(FROM_HERE, reply);
+        origin_loop_->PostClosure(FROM_HERE, reply);
         return;
       }
     }
 
-    // We didn't post, so delete the reply.
-    delete reply;
   }
 
   // Callback for when DoProbe() completes (runs on origin thread).
   void OnProbeComplete(AddressFamily address_family) {
     if (was_cancelled())
       return;
     DCHECK(IsOnOriginThread());
     resolver_->IPv6ProbeSetDefaultAddressFamily(address_family);
   }
 
@@ skipping 735 matching lines @@
     job_pools_[i]->ResetNumOutstandingJobs();
   JobMap jobs;
   jobs.swap(jobs_);
   for (JobMap::iterator it = jobs.begin(); it != jobs.end(); ++it) {
     AbortJob(it->second);
     it->second->Cancel();
   }
 }
 
 }  // namespace net