base::Bind: Convert NewRunnableMethod in chrome/browser.

chrome/browser/cancelable_request.h

 // 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.
 
 // CancelableRequestProviders and Consumers work together to make requests that
 // execute on a background thread in the provider and return data to the
 // consumer. These classes collaborate to keep a list of open requests and to
 // make sure that requests do not outlive either of the objects involved in the
 // transaction.
 //
@@ skipping 30 matching lines @@
 //     typedef Callback1<int>::Type RequestCallbackType;
 //
 //     Handle StartRequest(int some_input1, int some_input2,
 //                         CancelableRequestConsumerBase* consumer,
 //                         RequestCallbackType* callback) {
 //       scoped_refptr<CancelableRequest<RequestCallbackType> > request(
 //           new CancelableRequest<RequestCallbackType>(callback));
 //       AddRequest(request, consumer);
 //
 //       // Send the parameters and the request to the backend thread.
-//       backend_thread_->PostTask(FROM_HERE,
-//           NewRunnableMethod(backend_, &Backend::DoRequest, request,
+//       backend_thread_->PostTask(
+//           FROM_HERE,
+//           base::Bind(&Backend::DoRequest, backend_, request,
 //                             some_input1, some_input2));
 //
 //       // The handle will have been set by AddRequest.
 //       return request->handle();
 //     }
 //   };
 //
 //
 // Example backend provider that does work and dispatches the callback back
 // to the original thread. Note that we need to pass it as a scoped_refptr so
@@ skipping 603 matching lines @@
   // long as the request so that it can be forwarded to the other thread.
   // For complex objects, this would typically be done by having a derived
   // request own the data itself.
   void ForwardResult(const TupleType& param) {
     DCHECK(callback_.get());
     if (!canceled()) {
       if (callback_thread_ == MessageLoop::current()) {
         // We can do synchronous callbacks when we're on the same thread.
         ExecuteCallback(param);
       } else {
-        callback_thread_->PostTask(FROM_HERE, NewRunnableMethod(this,
-            &CancelableRequest<CB>::ExecuteCallback, param));
+        callback_thread_->PostTask(
+            FROM_HERE,
+            base::Bind(&CancelableRequest<CB>::ExecuteCallback, this, param));
       }
     }
   }
 
   // Like |ForwardResult| but this never does a synchronous callback.
   void ForwardResultAsync(const TupleType& param) {
     DCHECK(callback_.get());
     if (!canceled()) {
-      callback_thread_->PostTask(FROM_HERE, NewRunnableMethod(this,
-          &CancelableRequest<CB>::ExecuteCallback, param));
+      callback_thread_->PostTask(
+          FROM_HERE,
+          base::Bind(&CancelableRequest<CB>::ExecuteCallback, this, param));
     }
   }
 
  protected:
   virtual ~CancelableRequest() {}
 
  private:
   // Executes the callback and notifies the provider and the consumer that this
   // request has been completed. This must be called on the callback_thread_.
   void ExecuteCallback(const TupleType& param) {
@@ skipping 311 matching lines @@
   }
 
   // The value.
   Type value;
 
  protected:
   virtual ~CancelableRequest1() {}
 };
 
 #endif  // CHROME_BROWSER_CANCELABLE_REQUEST_H_