ipc: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ipc/ipc_sync_channel_unittest.cc

 // Copyright (c) 2012 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 "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "ipc/ipc_sync_message_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::WaitableEvent;
@@ skipping 36 matching lines @@
   void AddRef() { }
   void Release() { }
   bool Send(Message* msg) override { return channel_->Send(msg); }
   void WaitForChannelCreation() { channel_created_->Wait(); }
   void CloseChannel() {
     DCHECK(base::MessageLoop::current() == ListenerThread()->message_loop());
     channel_->Close();
   }
   void Start() {
     StartThread(&listener_thread_, base::MessageLoop::TYPE_DEFAULT);
-    ListenerThread()->message_loop()->PostTask(
+    ListenerThread()->task_runner()->PostTask(
         FROM_HERE, base::Bind(&Worker::OnStart, this));
   }
   void Shutdown() {
     // The IPC thread needs to outlive SyncChannel. We can't do this in
     // ~Worker(), since that'll reset the vtable pointer (to Worker's), which
     // may result in a race conditions. See http://crbug.com/25841.
     WaitableEvent listener_done(false, false), ipc_done(false, false);
-    ListenerThread()->message_loop()->PostTask(
+    ListenerThread()->task_runner()->PostTask(
         FROM_HERE, base::Bind(&Worker::OnListenerThreadShutdown1, this,
                               &listener_done, &ipc_done));
     listener_done.Wait();
     ipc_done.Wait();
     ipc_thread_.Stop();
     listener_thread_.Stop();
     is_shutdown_ = true;
   }
   void OverrideThread(base::Thread* overrided_thread) {
     DCHECK(overrided_thread_ == NULL);
@@ skipping 51 matching lines @@
     SyncChannelTestMsg_Double::WriteReplyParams(reply_msg, result);
     Send(reply_msg);
   }
 
   virtual void OnNestedTestMsg(Message* reply_msg) {
     NOTREACHED();
   }
 
   virtual SyncChannel* CreateChannel() {
     scoped_ptr<SyncChannel> channel = SyncChannel::Create(
-        channel_name_, mode_, this, ipc_thread_.message_loop_proxy().get(),
-        true, &shutdown_event_);
+        channel_name_, mode_, this, ipc_thread_.task_runner().get(), true,
+        &shutdown_event_);
     return channel.release();
   }
 
   base::Thread* ListenerThread() {
     return overrided_thread_ ? overrided_thread_ : &listener_thread_;
   }
 
   const base::Thread& ipc_thread() const { return ipc_thread_; }
 
  private:
@@ skipping 16 matching lines @@
     ipc_thread_.message_loop()->PostTask(
         FROM_HERE, base::Bind(&Worker::OnIPCThreadShutdown, this,
                               listener_event, ipc_event));
   }
 
   void OnIPCThreadShutdown(WaitableEvent* listener_event,
                            WaitableEvent* ipc_event) {
     base::RunLoop().RunUntilIdle();
     ipc_event->Signal();
 
-    listener_thread_.message_loop()->PostTask(
-        FROM_HERE, base::Bind(&Worker::OnListenerThreadShutdown2, this,
-                              listener_event));
+    listener_thread_.task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&Worker::OnListenerThreadShutdown2, this, listener_event));
   }
 
   void OnListenerThreadShutdown2(WaitableEvent* listener_event) {
     base::RunLoop().RunUntilIdle();
     listener_event->Signal();
   }
 
   bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(Worker, message)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelTestMsg_Double, OnDoubleDelay)
@@ skipping 111 matching lines @@
         create_pipe_now_(create_pipe_now) { }
 
   void Run() override {
     SendAnswerToLife(false, true);
     Done();
   }
 
   SyncChannel* CreateChannel() override {
     SyncChannel* channel =
         SyncChannel::Create(channel_name(), mode(), this,
-                            ipc_thread().message_loop_proxy().get(),
-                            create_pipe_now_,
+                            ipc_thread().task_runner().get(), create_pipe_now_,
                             shutdown_event()).release();
     return channel;
   }
 
   bool create_pipe_now_;
 };
 
 class TwoStepClient : public Worker {
  public:
   TwoStepClient(bool create_pipe_now)
       : Worker(Channel::MODE_CLIENT, "simple_client"),
         create_pipe_now_(create_pipe_now) { }
 
   void OnAnswer(int* answer) override {
     *answer = 42;
     Done();
   }
 
   SyncChannel* CreateChannel() override {
     SyncChannel* channel =
         SyncChannel::Create(channel_name(), mode(), this,
-                            ipc_thread().message_loop_proxy().get(),
-                            create_pipe_now_,
+                            ipc_thread().task_runner().get(), create_pipe_now_,
                             shutdown_event()).release();
     return channel;
   }
 
   bool create_pipe_now_;
 };
 
 void TwoStep(bool create_server_pipe_now, bool create_client_pipe_now) {
   std::vector<Worker*> workers;
   workers.push_back(new TwoStepServer(create_server_pipe_now));
@@ skipping 527 matching lines @@
 void TimeoutCallback() {
   timeout_occurred = true;
 }
 
 class DoneEventRaceServer : public Worker {
  public:
   DoneEventRaceServer()
       : Worker(Channel::MODE_SERVER, "done_event_race_server") { }
 
   void Run() override {
-    base::MessageLoop::current()->PostTask(FROM_HERE,
-                                           base::Bind(&NestedCallback, this));
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&TimeoutCallback),
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&NestedCallback, this));
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&TimeoutCallback),
         base::TimeDelta::FromSeconds(9));
     // Even though we have a timeout on the Send, it will succeed since for this
     // bug, the reply message comes back and is deserialized, however the done
     // event wasn't set.  So we indirectly use the timeout task to notice if a
     // timeout occurred.
     SendAnswerToLife(true, true);
     DCHECK(!timeout_occurred);
     Done();
   }
 };
 
 // Tests http://b/1474092 - that if after the done_event is set but before
 // OnObjectSignaled is called another message is sent out, then after its
 // reply comes back OnObjectSignaled will be called for the first message.
 TEST_F(IPCSyncChannelTest, DoneEventRace) {
   std::vector<Worker*> workers;
   workers.push_back(new DoneEventRaceServer());
   workers.push_back(new SimpleClient());
   RunTest(workers);
 }
 
 //------------------------------------------------------------------------------
 
 class TestSyncMessageFilter : public SyncMessageFilter {
  public:
-  TestSyncMessageFilter(base::WaitableEvent* shutdown_event,
-                        Worker* worker,
-                        scoped_refptr<base::MessageLoopProxy> message_loop)
+  TestSyncMessageFilter(
+      base::WaitableEvent* shutdown_event,
+      Worker* worker,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : SyncMessageFilter(shutdown_event),
         worker_(worker),
-        message_loop_(message_loop) {
-  }
+        task_runner_(task_runner) {}
 
   void OnFilterAdded(Sender* sender) override {
     SyncMessageFilter::OnFilterAdded(sender);
-    message_loop_->PostTask(
+    task_runner_->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();
   }
 
  private:
   ~TestSyncMessageFilter() override {}
 
   Worker* worker_;
-  scoped_refptr<base::MessageLoopProxy> message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
 class SyncMessageFilterServer : public Worker {
  public:
   SyncMessageFilterServer()
       : Worker(Channel::MODE_SERVER, "sync_message_filter_server"),
         thread_("helper_thread") {
     base::Thread::Options options;
     options.message_loop_type = base::MessageLoop::TYPE_DEFAULT;
     thread_.StartWithOptions(options);
     filter_ = new TestSyncMessageFilter(shutdown_event(), this,
-                                        thread_.message_loop_proxy());
+                                        thread_.task_runner());
   }
 
   void Run() override {
     channel()->AddFilter(filter_.get());
   }
 
   base::Thread thread_;
   scoped_refptr<TestSyncMessageFilter> filter_;
 };
 
 // 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(
+    ListenerThread()->task_runner()->PostTask(
         FROM_HERE, base::Bind(base::IgnoreResult(&ServerSendAfterClose::Send),
                               this, new SyncChannelTestMsg_NoArgs));
     return true;
   }
 
   bool send_result() const {
     return send_result_;
   }
 
  private:
@@ skipping 45 matching lines @@
         sent_ping_event_(sent_ping_event),
         wait_event_(wait_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(
+    ipc_thread().task_runner()->PostTask(
         FROM_HERE, base::Bind(&RestrictedDispatchServer::OnPingSent, this));
   }
 
   void OnPingTTL(int ping, int* out) {
     *out = ping;
     wait_event_->Wait();
   }
 
   base::Thread* ListenerThread() { return Worker::ListenerThread(); }
 
@@ skipping 54 matching lines @@
         server_(server),
         server2_(server2),
         success_(success),
         sent_ping_event_(sent_ping_event) {}
 
   void Run() override {
     // Incoming messages from our channel should only be dispatched when we
     // send a message on that same channel.
     channel()->SetRestrictDispatchChannelGroup(1);
 
-    server_->ListenerThread()->message_loop()->PostTask(
+    server_->ListenerThread()->task_runner()->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";
 
-    non_restricted_channel_ =
-        SyncChannel::Create("non_restricted_channel",
-                            IPC::Channel::MODE_CLIENT,
-                            this,
-                            ipc_thread().message_loop_proxy().get(),
-                            true,
-                            shutdown_event());
+    non_restricted_channel_ = SyncChannel::Create(
+        "non_restricted_channel", IPC::Channel::MODE_CLIENT, this,
+        ipc_thread().task_runner().get(), true, shutdown_event());
 
-    server_->ListenerThread()->message_loop()->PostTask(
+    server_->ListenerThread()->task_runner()->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);
     if (ping_ == 1)
       ++*success_;
     else
       LOG(ERROR) << "Send dispatched message from restricted channel";
 
     Send(new SyncChannelTestMsg_NoArgs);
     if (ping_ == 2)
       ++*success_;
     else
       LOG(ERROR) << "Send failed to dispatch incoming message on same channel";
 
     // Check that the incoming message on the non-restricted channel is
     // dispatched when sending on the restricted channel.
-    server2_->ListenerThread()->message_loop()->PostTask(
+    server2_->ListenerThread()->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&NonRestrictedDispatchServer::OnDoPingTTL, server2_, 3));
     int value = 0;
     Send(new SyncChannelTestMsg_PingTTL(4, &value));
     if (ping_ == 3 && value == 4)
       ++*success_;
     else
       LOG(ERROR) << "Send failed to dispatch message from unrestricted channel";
 
     non_restricted_channel_->Send(new SyncChannelTestMsg_Done);
@@ skipping 201 matching lines @@
         server_(server),
         peer_(peer),
         server_ready_event_(server_ready_event),
         events_(events),
         received_msg_(false),
         received_noarg_reply_(false),
         done_issued_(false) {}
 
   void Run() override {
     server_ready_event_->Wait();
-    server_->ListenerThread()->message_loop()->PostTask(
+    server_->ListenerThread()->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&RestrictedDispatchDeadlockServer::OnDoServerTask, server_));
-    peer_->ListenerThread()->message_loop()->PostTask(
+    peer_->ListenerThread()->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&RestrictedDispatchDeadlockClient2::OnDoClient2Task, peer_));
     events_[0]->Wait();
     events_[1]->Wait();
     DCHECK(received_msg_ == false);
 
     Message* message = new SyncChannelTestMsg_NoArgs;
     message->set_unblock(true);
     Send(message);
     received_noarg_reply_ = true;
@@ skipping 112 matching lines @@
     other_channel_->Send(new SyncChannelTestMsg_Done);
     other_channel_.reset();
     Done();
   }
 
   void Run() override {
     channel()->SetRestrictDispatchChannelGroup(group_);
     if (is_first())
       event1_->Signal();
     event2_->Wait();
-    other_channel_ =
-        SyncChannel::Create(other_channel_name_,
-                            IPC::Channel::MODE_CLIENT,
-                            this,
-                            ipc_thread().message_loop_proxy().get(),
-                            true,
-                            shutdown_event());
+    other_channel_ = SyncChannel::Create(
+        other_channel_name_, IPC::Channel::MODE_CLIENT, this,
+        ipc_thread().task_runner().get(), true, shutdown_event());
     other_channel_->SetRestrictDispatchChannelGroup(group_);
     if (!is_first()) {
       event1_->Signal();
       return;
     }
     *success_ = 0;
     int value = 0;
     OnPingTTL(3, &value);
     *success_ += (value == 3);
     OnPingTTL(4, &value);
@@ skipping 53 matching lines @@
 // it will send another message to Server2. While sending that second message it
 // will receive a reply from Server1 with the unblock flag.
 
 class ReentrantReplyServer1 : public Worker {
  public:
   ReentrantReplyServer1(WaitableEvent* server_ready)
       : Worker("reentrant_reply1", Channel::MODE_SERVER),
         server_ready_(server_ready) { }
 
   void Run() override {
-    server2_channel_ =
-        SyncChannel::Create("reentrant_reply2",
-                            IPC::Channel::MODE_CLIENT,
-                            this,
-                            ipc_thread().message_loop_proxy().get(),
-                            true,
-                            shutdown_event());
+    server2_channel_ = SyncChannel::Create(
+        "reentrant_reply2", IPC::Channel::MODE_CLIENT, this,
+        ipc_thread().task_runner().get(), true, shutdown_event());
     server_ready_->Signal();
     Message* msg = new SyncChannelTestMsg_Reentrant1();
     server2_channel_->Send(msg);
     server2_channel_.reset();
     Done();
   }
 
  private:
   bool OnMessageReceived(const Message& message) override {
     IPC_BEGIN_MESSAGE_MAP(ReentrantReplyServer1, message)
@@ skipping 158 matching lines @@
 }
 
 // Windows needs to send an out-of-band secret to verify the client end of the
 // channel. Test that we still connect correctly in that case.
 TEST_F(IPCSyncChannelTest, Verified) {
   Verified();
 }
 
 }  // namespace
 }  // namespace IPC