Remove calls to deprecated MessageLoop methods on Windows and Linux.

ipc/attachment_broker_privileged_win_unittest.cc

 // Copyright 2015 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"
 
 #include <windows.h>
 
 #include <memory>
 #include <tuple>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/shared_memory_handle.h"
+#include "base/run_loop.h"
 #include "base/win/scoped_handle.h"
 #include "ipc/attachment_broker_privileged_win.h"
 #include "ipc/attachment_broker_unprivileged_win.h"
 #include "ipc/handle_attachment_win.h"
 #include "ipc/handle_win.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_messages.h"
 
@@ skipping 321 matching lines @@
 // checks that the file has the same contents in the privileged process.
 TEST_F(IPCAttachmentBrokerPrivilegedWinTest, SendHandle) {
   Init("SendHandle");
 
   CommonSetUp();
   ResultListener result_listener;
   get_proxy_listener()->set_listener(&result_listener);
 
   HANDLE h = CreateTempFile();
   SendMessageWithAttachment(h);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Check the result.
   ASSERT_EQ(ProxyListener::MESSAGE_RECEIVED,
             get_proxy_listener()->get_reason());
   ASSERT_EQ(result_listener.get_result(), RESULT_SUCCESS);
 
   CommonTearDown();
 }
 
 // Similar to SendHandle, except the file HANDLE attached to the message has
 // neither read nor write permissions.
 TEST_F(IPCAttachmentBrokerPrivilegedWinTest,
        SendHandleWithoutPermissions) {
   Init("SendHandleWithoutPermissions");
 
   CommonSetUp();
   ResultListener result_listener;
   get_proxy_listener()->set_listener(&result_listener);
 
   HANDLE h = CreateTempFile();
   HANDLE h2;
   BOOL result = ::DuplicateHandle(GetCurrentProcess(), h, GetCurrentProcess(),
                                   &h2, 0, FALSE, DUPLICATE_CLOSE_SOURCE);
   ASSERT_TRUE(result);
   IPC::HandleWin handle_win(h2, IPC::HandleWin::DUPLICATE);
   IPC::Message* message = new TestHandleWinMsg(100, handle_win, 200);
   sender()->Send(message);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Check the result.
   ASSERT_EQ(ProxyListener::MESSAGE_RECEIVED,
             get_proxy_listener()->get_reason());
   ASSERT_EQ(result_listener.get_result(), RESULT_SUCCESS);
 
   CommonTearDown();
 }
 
 // Similar to SendHandle, except the attachment's destination process is this
 // process. This is an unrealistic scenario, but simulates an unprivileged
 // process sending an attachment to another unprivileged process.
 TEST_F(IPCAttachmentBrokerPrivilegedWinTest, SendHandleToSelf) {
   Init("SendHandleToSelf");
 
   set_broker(new MockBroker);
 
   PreConnectSetUp();
   // Technically, the channel is an endpoint, but we need the proxy listener to
   // receive the messages so that it can quit the message loop.
   channel()->SetAttachmentBrokerEndpoint(false);
   PostConnectSetUp();
   get_proxy_listener()->set_listener(get_broker());
 
   HANDLE h = CreateTempFile();
   SendMessageWithAttachment(h);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Get the received attachment.
   IPC::BrokerableAttachment::AttachmentId* id = get_observer()->get_id();
   scoped_refptr<IPC::BrokerableAttachment> received_attachment;
   get_broker()->GetAttachmentWithId(*id, &received_attachment);
   ASSERT_NE(received_attachment.get(), nullptr);
 
   // Check that it's a different entry in the HANDLE table.
   ScopedHandle h2(GetHandleFromBrokeredAttachment(received_attachment));
   EXPECT_NE(h2.Get(), h);
@@ skipping 16 matching lines @@
 
   HANDLE h = CreateTempFile();
   HANDLE h2;
   BOOL result = ::DuplicateHandle(GetCurrentProcess(), h, GetCurrentProcess(),
                                   &h2, 0, FALSE, DUPLICATE_SAME_ACCESS);
   ASSERT_TRUE(result);
   IPC::HandleWin handle_win1(h, IPC::HandleWin::FILE_READ_WRITE);
   IPC::HandleWin handle_win2(h2, IPC::HandleWin::FILE_READ_WRITE);
   IPC::Message* message = new TestTwoHandleWinMsg(handle_win1, handle_win2);
   sender()->Send(message);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Check the result.
   ASSERT_EQ(ProxyListener::MESSAGE_RECEIVED,
             get_proxy_listener()->get_reason());
   ASSERT_EQ(result_listener.get_result(), RESULT_SUCCESS);
 
   CommonTearDown();
 }
 
 // Similar to SendHandle, but sends the same message twice.
 TEST_F(IPCAttachmentBrokerPrivilegedWinTest, SendHandleTwice) {
   Init("SendHandleTwice");
 
   CommonSetUp();
   ResultListener result_listener;
   get_proxy_listener()->set_listener(&result_listener);
 
   HANDLE h = CreateTempFile();
   HANDLE h2;
   BOOL result = ::DuplicateHandle(GetCurrentProcess(), h, GetCurrentProcess(),
                                   &h2, 0, FALSE, DUPLICATE_SAME_ACCESS);
   ASSERT_TRUE(result);
   SendMessageWithAttachment(h);
   SendMessageWithAttachment(h2);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Check the result.
   ASSERT_EQ(ProxyListener::MESSAGE_RECEIVED,
             get_proxy_listener()->get_reason());
   ASSERT_EQ(result_listener.get_result(), RESULT_SUCCESS);
 
   CommonTearDown();
 }
 
 // An unprivileged process makes a shared memory region and sends it to the
 // privileged process.
 TEST_F(IPCAttachmentBrokerPrivilegedWinTest, SendSharedMemoryHandle) {
   Init("SendSharedMemoryHandle");
 
   CommonSetUp();
   ResultListener result_listener;
   get_proxy_listener()->set_listener(&result_listener);
 
   std::unique_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
   shared_memory->CreateAndMapAnonymous(kSharedMemorySize);
   memcpy(shared_memory->memory(), kDataBuffer, strlen(kDataBuffer));
   sender()->Send(new TestSharedMemoryHandleMsg1(shared_memory->handle()));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   // Check the result.
   ASSERT_EQ(ProxyListener::MESSAGE_RECEIVED,
             get_proxy_listener()->get_reason());
   ASSERT_EQ(result_listener.get_result(), RESULT_SUCCESS);
 
   CommonTearDown();
 }
 
 using OnMessageReceivedCallback = void (*)(IPC::Sender* sender,
                                            const IPC::Message& message);
 
 int CommonPrivilegedProcessMain(OnMessageReceivedCallback callback,
                                 const char* channel_name) {
   LOG(INFO) << "Privileged process start.";
   base::MessageLoopForIO main_message_loop;
   ProxyListener listener;
 
   // Set up IPC channel.
   IPC::AttachmentBrokerPrivilegedWin broker;
   std::unique_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
       IPCTestBase::GetChannelName(channel_name), &listener));
   broker.RegisterCommunicationChannel(channel.get(), nullptr);
   CHECK(channel->Connect());
 
   while (true) {
     LOG(INFO) << "Privileged process spinning run loop.";
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     ProxyListener::Reason reason = listener.get_reason();
     if (reason == ProxyListener::CHANNEL_ERROR)
       break;
 
     while (listener.has_message()) {
       LOG(INFO) << "Privileged process running callback.";
       callback(channel.get(), listener.get_first_message());
       LOG(INFO) << "Privileged process finishing callback.";
       listener.pop_first_message();
     }
@@ skipping 120 matching lines @@
       memcmp(shared_memory->memory(), kDataBuffer, strlen(kDataBuffer)) == 0;
   SendControlMessage(sender, success);
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandle) {
   return CommonPrivilegedProcessMain(&SendSharedMemoryHandleCallback,
                                      "SendSharedMemoryHandle");
 }
 
 }  // namespace