ipc: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ipc/ipc_channel_nacl.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_channel_nacl.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <sys/types.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/simple_thread.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message_attachment_set.h"
 #include "native_client/src/public/imc_syscalls.h"
 #include "native_client/src/public/imc_types.h"
 
 namespace IPC {
 
 struct MessageContents {
@@ skipping 39 matching lines @@
  public:
   // |pipe|: A file descriptor from which we will read using imc_recvmsg.
   // |data_read_callback|: A callback we invoke (on the main thread) when we
   //                       have read data.
   // |failure_callback|: A callback we invoke when we have a failure reading
   //                     from |pipe|.
   // |main_message_loop|: A proxy for the main thread, where we will invoke the
   //                      above callbacks.
   ReaderThreadRunner(
       int pipe,
-      base::Callback<void (scoped_ptr<MessageContents>)> data_read_callback,
-      base::Callback<void ()> failure_callback,
-      scoped_refptr<base::MessageLoopProxy> main_message_loop);
+      base::Callback<void(scoped_ptr<MessageContents>)> data_read_callback,
+      base::Callback<void()> failure_callback,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner);
 
   // DelegateSimpleThread implementation. Reads data from the pipe in a loop
   // until either we are told to quit or a read fails.
   void Run() override;
 
  private:
   int pipe_;
   base::Callback<void (scoped_ptr<MessageContents>)> data_read_callback_;
   base::Callback<void ()> failure_callback_;
-  scoped_refptr<base::MessageLoopProxy> main_message_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ReaderThreadRunner);
 };
 
 ChannelNacl::ReaderThreadRunner::ReaderThreadRunner(
     int pipe,
-    base::Callback<void (scoped_ptr<MessageContents>)> data_read_callback,
-    base::Callback<void ()> failure_callback,
-    scoped_refptr<base::MessageLoopProxy> main_message_loop)
+    base::Callback<void(scoped_ptr<MessageContents>)> data_read_callback,
+    base::Callback<void()> failure_callback,
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
     : pipe_(pipe),
       data_read_callback_(data_read_callback),
       failure_callback_(failure_callback),
-      main_message_loop_(main_message_loop) {
+      main_task_runner_(main_task_runner) {
 }
 
 void ChannelNacl::ReaderThreadRunner::Run() {
   while (true) {
     scoped_ptr<MessageContents> msg_contents(new MessageContents);
     bool success = ReadDataOnReaderThread(pipe_, msg_contents.get());
     if (success) {
-      main_message_loop_->PostTask(FROM_HERE,
+      main_task_runner_->PostTask(
+          FROM_HERE,
           base::Bind(data_read_callback_, base::Passed(&msg_contents)));
     } else {
-      main_message_loop_->PostTask(FROM_HERE, failure_callback_);
+      main_task_runner_->PostTask(FROM_HERE, failure_callback_);
       // Because the read failed, we know we're going to quit. Don't bother
       // trying to read again.
       return;
     }
   }
 }
 
 ChannelNacl::ChannelNacl(const IPC::ChannelHandle& channel_handle,
                          Mode mode,
                          Listener* listener)
@@ skipping 28 matching lines @@
 bool ChannelNacl::Connect() {
   if (pipe_ == -1) {
     DLOG(WARNING) << "Channel creation failed: " << pipe_name_;
     return false;
   }
 
   // Note that Connect is called on the "Channel" thread (i.e., the same thread
   // where Channel::Send will be called, and the same thread that should receive
   // messages). The constructor might be invoked on another thread (see
   // ChannelProxy for an example of that). Therefore, we must wait until Connect
-  // is called to decide which MessageLoopProxy to pass to ReaderThreadRunner.
-  reader_thread_runner_.reset(
-      new ReaderThreadRunner(
-          pipe_,
-          base::Bind(&ChannelNacl::DidRecvMsg,
-                     weak_ptr_factory_.GetWeakPtr()),
-          base::Bind(&ChannelNacl::ReadDidFail,
-                     weak_ptr_factory_.GetWeakPtr()),
-          base::MessageLoopProxy::current()));
+  // is called to decide which SingleThreadTaskRunner to pass to
+  // ReaderThreadRunner.
+  reader_thread_runner_.reset(new ReaderThreadRunner(
+      pipe_,
+      base::Bind(&ChannelNacl::DidRecvMsg, weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&ChannelNacl::ReadDidFail, weak_ptr_factory_.GetWeakPtr()),
+      base::ThreadTaskRunnerHandle::Get()));
   reader_thread_.reset(
       new base::DelegateSimpleThread(reader_thread_runner_.get(),
                                      "ipc_channel_nacl reader thread"));
   reader_thread_->Start();
   waiting_connect_ = false;
   // If there were any messages queued before connection, send them.
   ProcessOutgoingMessages();
-  base::MessageLoopProxy::current()->PostTask(FROM_HERE,
-      base::Bind(&ChannelNacl::CallOnChannelConnected,
-                 weak_ptr_factory_.GetWeakPtr()));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&ChannelNacl::CallOnChannelConnected,
+                            weak_ptr_factory_.GetWeakPtr()));
 
   return true;
 }
 
 void ChannelNacl::Close() {
   // For now, we assume that at shutdown, the reader thread will be woken with
   // a failure (see NaClIPCAdapter::BlockingRead and CloseChannel). Or... we
   // might simply be killed with no chance to clean up anyway :-).
   // If untrusted code tries to close the channel prior to shutdown, it's likely
   // to hang.
@@ skipping 181 matching lines @@
 // Channel's methods
 
 // static
 scoped_ptr<Channel> Channel::Create(
     const IPC::ChannelHandle &channel_handle, Mode mode, Listener* listener) {
   return scoped_ptr<Channel>(
       new ChannelNacl(channel_handle, mode, listener));
 }
 
 }  // namespace IPC