ipc: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ipc/ipc_send_fds_test.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 "build/build_config.h"
 
 #if defined(OS_POSIX)
 #if defined(OS_MACOSX)
 extern "C" {
 #include <sandbox.h>
 }
 #endif
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include <queue>
 
 #include "base/callback.h"
 #include "base/file_descriptor_posix.h"
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
 #include "base/pickle.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "ipc/ipc_message_attachment_set.h"
 #include "ipc/ipc_message_utils.h"
 #include "ipc/ipc_test_base.h"
 
 #if defined(OS_POSIX)
 #include "base/macros.h"
 #endif
 
 namespace {
@@ skipping 208 matching lines @@
   }
 
   void Init() {
     IPC::ChannelHandle in_handle("IN");
     in = IPC::Channel::CreateServer(in_handle, &null_listener_);
     IPC::ChannelHandle out_handle(
         "OUT", base::FileDescriptor(in->TakeClientFileDescriptor()));
     out = IPC::Channel::CreateClient(out_handle, &cb_listener_);
     // PostTask the connect calls to make sure the callbacks happens
     // on the right threads.
-    in_thread_->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&PipeChannelHelper::Connect, in.get()));
-    out_thread_->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&PipeChannelHelper::Connect, out.get()));
+    in_thread_->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&PipeChannelHelper::Connect, in.get()));
+    out_thread_->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&PipeChannelHelper::Connect, out.get()));
   }
 
   static void DestroyChannel(scoped_ptr<IPC::Channel> *c,
                              base::WaitableEvent *event) {
     c->reset(0);
     event->Signal();
   }
 
   ~PipeChannelHelper() {
     base::WaitableEvent a(true, false);
     base::WaitableEvent b(true, false);
-    in_thread_->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&PipeChannelHelper::DestroyChannel, &in, &a));
-    out_thread_->message_loop()->PostTask(
-        FROM_HERE,
-        base::Bind(&PipeChannelHelper::DestroyChannel, &out, &b));
+    in_thread_->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&PipeChannelHelper::DestroyChannel, &in, &a));
+    out_thread_->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&PipeChannelHelper::DestroyChannel, &out, &b));
     a.Wait();
     b.Wait();
   }
 
   static void Connect(IPC::Channel *channel) {
     EXPECT_TRUE(channel->Connect());
   }
 
   void Send(int fd) {
     CHECK_EQ(base::MessageLoop::current(), in_thread_->message_loop());
@@ skipping 28 matching lines @@
 class IPCMultiSendingFdsTest : public testing::Test {
  public:
   IPCMultiSendingFdsTest() : received_(true, false) {}
 
   void Producer(PipeChannelHelper* dest,
                 base::Thread* t,
                 int pipes_to_send) {
     for (int i = 0; i < pipes_to_send; i++) {
       received_.Reset();
       std::pair<int, int> pipe_fds = make_socket_pair();
-      t->message_loop()->PostTask(
-          FROM_HERE,
-          base::Bind(&PipeChannelHelper::Send,
-                     base::Unretained(dest),
-                     pipe_fds.second));
+      t->task_runner()->PostTask(
+          FROM_HERE, base::Bind(&PipeChannelHelper::Send,
+                                base::Unretained(dest), pipe_fds.second));
       char tmp = 'x';
       CHECK_EQ(1, HANDLE_EINTR(write(pipe_fds.first, &tmp, 1)));
       CHECK_EQ(0, IGNORE_EINTR(close(pipe_fds.first)));
       received_.Wait();
     }
   }
 
   void ConsumerHandleFD(int fd) {
     char tmp = 'y';
     CHECK_EQ(1, HANDLE_EINTR(read(fd, &tmp, 1)));
@@ skipping 39 matching lines @@
   base::WaitableEvent received_;
 };
 
 TEST_F(IPCMultiSendingFdsTest, StressTest) {
   Run();
 }
 
 }  // namespace
 
 #endif  // defined(OS_POSIX)