Convert NewRunnableFunction/NewRunnableMethod calls to use base::Bind().

content/common/webmessageportchannel_impl.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 "content/common/webmessageportchannel_impl.h"
 
+#include "base/bind.h"
 #include "content/common/child_process.h"
 #include "content/common/child_thread.h"
 #include "content/common/worker_messages.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMessagePortChannelClient.h"
 
 using WebKit::WebMessagePortChannel;
 using WebKit::WebMessagePortChannelArray;
 using WebKit::WebMessagePortChannelClient;
 using WebKit::WebString;
@@ skipping 54 matching lines @@
   // before getting the other message port id.
   scoped_refptr<WebMessagePortChannelImpl> webchannel(
       static_cast<WebMessagePortChannelImpl*>(channel));
   Entangle(webchannel);
 }
 
 void WebMessagePortChannelImpl::postMessage(
     const WebString& message,
     WebMessagePortChannelArray* channels) {
   if (MessageLoop::current() != ChildThread::current()->message_loop()) {
-    ChildThread::current()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &WebMessagePortChannelImpl::postMessage,
-            message, channels));
+    ChildThread::current()->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&WebMessagePortChannelImpl::postMessage, this,
+                   message, channels));
     return;
   }
 
   std::vector<int> message_port_ids(channels ? channels->size() : 0);
   if (channels) {
     // Extract the port IDs from the source array, then free it.
     for (size_t i = 0; i < channels->size(); ++i) {
       WebMessagePortChannelImpl* webchannel =
           static_cast<WebMessagePortChannelImpl*>((*channels)[i]);
       message_port_ids[i] = webchannel->message_port_id();
@@ skipping 23 matching lines @@
     result_ports[i] = channel_array[i];
   }
 
   channels.swap(result_ports);
   message_queue_.pop();
   return true;
 }
 
 void WebMessagePortChannelImpl::Init() {
   if (MessageLoop::current() != ChildThread::current()->message_loop()) {
-    ChildThread::current()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &WebMessagePortChannelImpl::Init));
+    ChildThread::current()->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&WebMessagePortChannelImpl::Init, this));
     return;
   }
 
   if (route_id_ == MSG_ROUTING_NONE) {
     DCHECK(message_port_id_ == MSG_ROUTING_NONE);
     Send(new WorkerProcessHostMsg_CreateMessagePort(
         &route_id_, &message_port_id_));
   }
 
   ChildThread::current()->AddRoute(route_id_, this);
 }
 
 void WebMessagePortChannelImpl::Entangle(
     scoped_refptr<WebMessagePortChannelImpl> channel) {
   if (MessageLoop::current() != ChildThread::current()->message_loop()) {
-    ChildThread::current()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &WebMessagePortChannelImpl::Entangle, channel));
+    ChildThread::current()->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&WebMessagePortChannelImpl::Entangle, this, channel));
     return;
   }
 
   Send(new WorkerProcessHostMsg_Entangle(
       message_port_id_, channel->message_port_id()));
 }
 
 void WebMessagePortChannelImpl::QueueMessages() {
   if (MessageLoop::current() != ChildThread::current()->message_loop()) {
-    ChildThread::current()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &WebMessagePortChannelImpl::QueueMessages));
+    ChildThread::current()->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&WebMessagePortChannelImpl::QueueMessages, this));
     return;
   }
   // This message port is being sent elsewhere (perhaps to another process).
   // The new endpoint needs to receive the queued messages, including ones that
   // could still be in-flight.  So we tell the browser to queue messages, and it
   // sends us an ack, whose receipt we know means that no more messages are
   // in-flight.  We then send the queued messages to the browser, which prepends
   // them to the ones it queued and it sends them to the new endpoint.
   Send(new WorkerProcessHostMsg_QueueMessages(message_port_id_));
 
   // The process could potentially go away while we're still waiting for
   // in-flight messages.  Ensure it stays alive.
   ChildProcess::current()->AddRefProcess();
 }
 
 void WebMessagePortChannelImpl::Send(IPC::Message* message) {
   if (MessageLoop::current() != ChildThread::current()->message_loop()) {
     DCHECK(!message->is_sync());
-    ChildThread::current()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &WebMessagePortChannelImpl::Send, message));
+    ChildThread::current()->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&WebMessagePortChannelImpl::Send, this, message));
     return;
   }
 
   ChildThread::current()->Send(message);
 }
 
 bool WebMessagePortChannelImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebMessagePortChannelImpl, message)
     IPC_MESSAGE_HANDLER(WorkerProcessMsg_Message, OnMessage)
@@ skipping 48 matching lines @@
 
   message_port_id_ = MSG_ROUTING_NONE;
 
   Release();
   ChildProcess::current()->ReleaseProcess();
 }
 
 WebMessagePortChannelImpl::Message::Message() {}
 
 WebMessagePortChannelImpl::Message::~Message() {}