base:Bind: Convert ipc/.

ipc/ipc_sync_channel_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.
 //
 // Unit test for SyncChannel.
 
 #include "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "ipc/ipc_message.h"
@@ skipping 40 matching lines @@
     // to suppress using standard Valgrind mechanism (suppressions).
     // We have to use ANNOTATE_BENIGN_RACE to hide the reports and
     // make ThreadSanitizer bots green.
     ANNOTATE_BENIGN_RACE(this, "Race on vfptr, http://crbug.com/25841");
   }
 
   // The IPC thread needs to outlive SyncChannel, so force the correct order of
   // destruction.
   virtual ~Worker() {
     WaitableEvent listener_done(false, false), ipc_done(false, false);
-    ListenerThread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &Worker::OnListenerThreadShutdown1, &listener_done,
-        &ipc_done));
+    ListenerThread()->message_loop()->PostTask(
+        FROM_HERE, base::Bind(&Worker::OnListenerThreadShutdown1, this,
+                              &listener_done, &ipc_done));
     listener_done.Wait();
     ipc_done.Wait();
     ipc_thread_.Stop();
     listener_thread_.Stop();
   }
   void AddRef() { }
   void Release() { }
   static bool ImplementsThreadSafeReferenceCounting() { return true; }
   bool Send(Message* msg) { return channel_->Send(msg); }
   bool SendWithTimeout(Message* msg, int timeout_ms) {
     return channel_->SendWithTimeout(msg, timeout_ms);
   }
   void WaitForChannelCreation() { channel_created_->Wait(); }
   void CloseChannel() {
     DCHECK(MessageLoop::current() == ListenerThread()->message_loop());
     channel_->Close();
   }
   void Start() {
     StartThread(&listener_thread_, MessageLoop::TYPE_DEFAULT);
-    ListenerThread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &Worker::OnStart));
+    ListenerThread()->message_loop()->PostTask(
+        FROM_HERE, base::Bind(&Worker::OnStart, this));
   }
   void OverrideThread(base::Thread* overrided_thread) {
     DCHECK(overrided_thread_ == NULL);
     overrided_thread_ = overrided_thread;
   }
   bool SendAnswerToLife(bool pump, int timeout, bool succeed) {
     int answer = 0;
     SyncMessage* msg = new SyncChannelTestMsg_AnswerToLife(&answer);
     if (pump)
       msg->EnableMessagePumping();
@@ skipping 66 matching lines @@
     Run();
   }
 
   void OnListenerThreadShutdown1(WaitableEvent* listener_event,
                                  WaitableEvent* ipc_event) {
     // SyncChannel needs to be destructed on the thread that it was created on.
     channel_.reset();
 
     MessageLoop::current()->RunAllPending();
 
-    ipc_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &Worker::OnIPCThreadShutdown, listener_event, ipc_event));
+    ipc_thread_.message_loop()->PostTask(
+        FROM_HERE, base::Bind(&Worker::OnIPCThreadShutdown, this,
+                              listener_event, ipc_event));
   }
 
   void OnIPCThreadShutdown(WaitableEvent* listener_event,
                            WaitableEvent* ipc_event) {
     MessageLoop::current()->RunAllPending();
     ipc_event->Signal();
 
-    listener_thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &Worker::OnListenerThreadShutdown2, listener_event));
+    listener_thread_.message_loop()->PostTask(
+        FROM_HERE, base::Bind(&Worker::OnListenerThreadShutdown2, this,
+                              listener_event));
   }
 
   void OnListenerThreadShutdown2(WaitableEvent* listener_event) {
     MessageLoop::current()->RunAllPending();
     listener_event->Signal();
   }
 
   bool OnMessageReceived(const Message& message) {
     IPC_BEGIN_MESSAGE_MAP(Worker, message)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelTestMsg_Double, OnDoubleDelay)
@@ skipping 813 matching lines @@
       : SyncMessageFilter(shutdown_event),
         worker_(worker),
         thread_("helper_thread") {
     base::Thread::Options options;
     options.message_loop_type = MessageLoop::TYPE_DEFAULT;
     thread_.StartWithOptions(options);
   }
 
   virtual void OnFilterAdded(Channel* channel) {
     SyncMessageFilter::OnFilterAdded(channel);
-    thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &TestSyncMessageFilter::SendMessageOnHelperThread));
+    thread_.message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&TestSyncMessageFilter::SendMessageOnHelperThread, this));
   }
 
   void SendMessageOnHelperThread() {
     int answer = 0;
     bool result = Send(new SyncChannelTestMsg_AnswerToLife(&answer));
     DCHECK(result);
     DCHECK_EQ(answer, 42);
 
     worker_->Done();
   }
@@ skipping 19 matching lines @@
 // This class provides functionality to test the case that a Send on the sync
 // channel does not crash after the channel has been closed.
 class ServerSendAfterClose : public Worker {
  public:
   ServerSendAfterClose()
      : Worker(Channel::MODE_SERVER, "simpler_server"),
        send_result_(true) {
   }
 
   bool SendDummy() {
-    ListenerThread()->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        this, &ServerSendAfterClose::Send, new SyncChannelTestMsg_NoArgs));
+    ListenerThread()->message_loop()->PostTask(
+        FROM_HERE, base::IgnoreReturn<bool>(
+            base::Bind(&ServerSendAfterClose::Send, this,
+                       new SyncChannelTestMsg_NoArgs)));
     return true;
   }
 
   bool send_result() const {
     return send_result_;
   }
 
  private:
   virtual void Run() {
     CloseChannel();
@@ skipping 43 matching lines @@
       : Worker("restricted_channel", Channel::MODE_SERVER),
         sent_ping_event_(sent_ping_event) { }
 
   void OnDoPing(int ping) {
     // Send an asynchronous message that unblocks the caller.
     Message* msg = new SyncChannelTestMsg_Ping(ping);
     msg->set_unblock(true);
     Send(msg);
     // Signal the event after the message has been sent on the channel, on the
     // IPC thread.
-    ipc_thread().message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &RestrictedDispatchServer::OnPingSent));
+    ipc_thread().message_loop()->PostTask(
+        FROM_HERE, base::Bind(&RestrictedDispatchServer::OnPingSent, this));
   }
 
   base::Thread* ListenerThread() { return Worker::ListenerThread(); }
 
  private:
   bool OnMessageReceived(const Message& message) {
     IPC_BEGIN_MESSAGE_MAP(RestrictedDispatchServer, message)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_NoArgs, OnNoArgs)
      IPC_MESSAGE_HANDLER(SyncChannelTestMsg_Done, Done)
     IPC_END_MESSAGE_MAP()
@@ skipping 34 matching lines @@
         ping_(0),
         server_(server),
         success_(success),
         sent_ping_event_(sent_ping_event) {}
 
   void Run() {
     // Incoming messages from our channel should only be dispatched when we
     // send a message on that same channel.
     channel()->SetRestrictDispatchToSameChannel(true);
 
-    server_->ListenerThread()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(server_, &RestrictedDispatchServer::OnDoPing, 1));
+    server_->ListenerThread()->message_loop()->PostTask(
+        FROM_HERE, base::Bind(&RestrictedDispatchServer::OnDoPing, server_, 1));
     sent_ping_event_->Wait();
     Send(new SyncChannelTestMsg_NoArgs);
     if (ping_ == 1)
       ++*success_;
     else
       LOG(ERROR) << "Send failed to dispatch incoming message on same channel";
 
     scoped_ptr<SyncChannel> non_restricted_channel(new SyncChannel(
         "non_restricted_channel", Channel::MODE_CLIENT, this,
         ipc_thread().message_loop_proxy(), true, shutdown_event()));
 
-    server_->ListenerThread()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(server_, &RestrictedDispatchServer::OnDoPing, 2));
+    server_->ListenerThread()->message_loop()->PostTask(
+        FROM_HERE, base::Bind(&RestrictedDispatchServer::OnDoPing, server_, 2));
     sent_ping_event_->Wait();
     // Check that the incoming message is *not* dispatched when sending on the
     // non restricted channel.
     // TODO(piman): there is a possibility of a false positive race condition
     // here, if the message that was posted on the server-side end of the pipe
     // is not visible yet on the client side, but I don't know how to solve this
     // without hooking into the internals of SyncChannel. I haven't seen it in
     // practice (i.e. not setting SetRestrictDispatchToSameChannel does cause
     // the following to fail).
     non_restricted_channel->Send(new SyncChannelTestMsg_NoArgs);
@@ skipping 43 matching lines @@
   std::vector<Worker*> workers;
   workers.push_back(new NonRestrictedDispatchServer);
   workers.push_back(server);
   workers.push_back(
       new RestrictedDispatchClient(&sent_ping_event, server, &success));
   RunTest(workers);
   EXPECT_EQ(3, success);
 }
 
 }  // namespace IPC