Remove calls to deprecated MessageLoop methods in ipc.

ipc/attachment_broker_mac_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 <fcntl.h>
 #include <mach/mach_vm.h>
 #include <stddef.h>
 #include <sys/mman.h>
 
 #include <memory>
 #include <tuple>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/mach_logging.h"
 #include "base/memory/free_deleter.h"
 #include "base/memory/shared_memory.h"
+#include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/spin_wait.h"
 #include "base/time/time.h"
 #include "ipc/attachment_broker_messages.h"
 #include "ipc/attachment_broker_privileged_mac.h"
 #include "ipc/attachment_broker_unprivileged_mac.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_messages.h"
@@ skipping 544 matching lines @@
   std::unique_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
       IPCTestBase::GetChannelName(channel_name), &listener));
   globals->broker->RegisterCommunicationChannel(channel.get(), nullptr);
   CHECK(channel->Connect());
 
   globals->initial_resident_size = GetResidentSize();
 
   while (true) {
     if (globals->message_logging)
       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()) {
       if (globals->message_logging)
         LOG(INFO) << "Privileged process running callback.";
       callback(channel.get(), listener.get_first_message(), globals.get());
       if (globals->message_logging)
         LOG(INFO) << "Privileged process finishing callback.";
       listener.pop_first_message();
     }
   }
 
   if (active_names_at_start != IPC::GetActiveNameCount()) {
     LOG(INFO) << "Memory leak!.";
   }
   LOG(INFO) << "Privileged process end.";
   return 0;
 }
 
 // An unprivileged process makes a shared memory region, and writes a string to
 // it. The SharedMemoryHandle is sent to the privileged process using Chrome
 // IPC. The privileged process checks that it received the same memory region.
 TEST_F(IPCAttachmentBrokerMacTest, SendSharedMemoryHandle) {
   CommonSetUp("SendSharedMemoryHandle");
 
   SendMessage1(kDataBuffer1);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void SendSharedMemoryHandleCallback(IPC::Sender* sender,
                                     const IPC::Message& message,
                                     ChildProcessGlobals* globals) {
   bool success = CheckContentsOfMessage1(message, kDataBuffer1);
   SendControlMessage(sender, success);
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandle) {
   return CommonPrivilegedProcessMain(&SendSharedMemoryHandleCallback,
                                      "SendSharedMemoryHandle");
 }
 
 // Similar to SendSharedMemoryHandle, but sends a very long shared memory
 // region.
 TEST_F(IPCAttachmentBrokerMacTest, SendSharedMemoryHandleLong) {
   CommonSetUp("SendSharedMemoryHandleLong");
 
   std::string buffer(1 << 23, 'a');
   SendMessage1(buffer);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void SendSharedMemoryHandleLongCallback(IPC::Sender* sender,
                                         const IPC::Message& message,
                                         ChildProcessGlobals* globals) {
   std::string buffer(1 << 23, 'a');
   bool success = CheckContentsOfMessage1(message, buffer);
   SendControlMessage(sender, success);
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandleLong) {
   return CommonPrivilegedProcessMain(&SendSharedMemoryHandleLongCallback,
                                      "SendSharedMemoryHandleLong");
 }
 
 // Similar to SendSharedMemoryHandle, but sends two different shared memory
 // regions in two messages.
 TEST_F(IPCAttachmentBrokerMacTest, SendTwoMessagesDifferentSharedMemoryHandle) {
   CommonSetUp("SendTwoMessagesDifferentSharedMemoryHandle");
 
   SendMessage1(kDataBuffer1);
   SendMessage1(kDataBuffer2);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void SendTwoMessagesDifferentSharedMemoryHandleCallback(
     IPC::Sender* sender,
     const IPC::Message& message,
     ChildProcessGlobals* globals) {
   static int count = 0;
   static bool success = true;
   ++count;
@@ skipping 20 matching lines @@
     std::unique_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
 
     for (int i = 0; i < 2; ++i) {
       IPC::Message* message =
           new TestSharedMemoryHandleMsg1(100, shared_memory->handle(), 200);
       sender()->Send(message);
     }
   }
 
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void SendTwoMessagesSameSharedMemoryHandleCallback(
     IPC::Sender* sender,
     const IPC::Message& message,
     ChildProcessGlobals* globals) {
   static int count = 0;
   static base::SharedMemoryHandle handle1;
   ++count;
@@ skipping 23 matching lines @@
 
   {
     std::unique_ptr<base::SharedMemory> shared_memory1(
         MakeSharedMemory(kDataBuffer1));
     std::unique_ptr<base::SharedMemory> shared_memory2(
         MakeSharedMemory(kDataBuffer2));
     IPC::Message* message = new TestSharedMemoryHandleMsg2(
         shared_memory1->handle(), shared_memory2->handle());
     sender()->Send(message);
   }
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void SendOneMessageWithTwoDifferentSharedMemoryHandlesCallback(
     IPC::Sender* sender,
     const IPC::Message& message,
     ChildProcessGlobals* globals) {
   base::SharedMemoryHandle handle1;
   base::SharedMemoryHandle handle2;
   if (!GetSharedMemoryHandlesFromMsg2(message, &handle1, &handle2)) {
@@ skipping 20 matching lines @@
        SendOneMessageWithTwoSameSharedMemoryHandles) {
   CommonSetUp("SendOneMessageWithTwoSameSharedMemoryHandles");
 
   {
     std::unique_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
     IPC::Message* message = new TestSharedMemoryHandleMsg2(
         shared_memory->handle(), shared_memory->handle());
     sender()->Send(message);
   }
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void SendOneMessageWithTwoSameSharedMemoryHandlesCallback(
     IPC::Sender* sender,
     const IPC::Message& message,
     ChildProcessGlobals* globals) {
   base::SharedMemoryHandle handle1;
   base::SharedMemoryHandle handle2;
   if (!GetSharedMemoryHandlesFromMsg2(message, &handle1, &handle2)) {
@@ skipping 34 matching lines @@
         MakeFileDescriptor(fp1, kDataBuffer3));
     base::FileDescriptor file_descriptor2(
         MakeFileDescriptor(fp2, kDataBuffer4));
 
     IPC::Message* message = new TestSharedMemoryHandleMsg3(
         file_descriptor1, shared_memory1->handle(), file_descriptor2,
         shared_memory2->handle());
     sender()->Send(message);
   }
 
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void SendPosixFDAndMachPortCallback(IPC::Sender* sender,
                                     const IPC::Message& message,
                                     ChildProcessGlobals* globals) {
   TestSharedMemoryHandleMsg3::Schema::Param p;
   if (!TestSharedMemoryHandleMsg3::Read(&message, &p)) {
     LOG(ERROR) << "Failed to deserialize message.";
     SendControlMessage(sender, false);
@@ skipping 37 matching lines @@
     std::unique_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
     mach_port_urefs_t ref_count = IPC::GetMachRefCount(
         shared_memory->handle().GetMemoryObject(), MACH_PORT_RIGHT_SEND);
 
     IPC::Message* message =
         new TestSharedMemoryHandleMsg1(100, shared_memory->handle(), 200);
     sender()->Send(message);
 
     // Wait until the child process has sent this process a message.
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
 
     // Wait for any asynchronous activity to complete.
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     // Get the received attachment.
     IPC::BrokerableAttachment::AttachmentId* id = get_observer()->get_id();
     ASSERT_TRUE(id);
     scoped_refptr<IPC::BrokerableAttachment> received_attachment;
     get_broker()->GetAttachmentWithId(*id, &received_attachment);
     ASSERT_NE(received_attachment.get(), nullptr);
 
     // Check that it's has the same name, but that the ref count has increased.
     base::mac::ScopedMachSendRight memory_object(
@@ skipping 41 matching lines @@
       CreateChannelFactory(GetTestChannelHandle(), thread->task_runner().get()),
       true);
 
   ASSERT_TRUE(StartClient());
 
   MachPostForkSetUp();
   active_names_at_start_ = IPC::GetActiveNameCount();
   get_proxy_listener()->set_listener(get_result_listener());
 
   SendMessage1(kDataBuffer1);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   CheckChildResult();
 
   // There should be no leaked names.
   EXPECT_EQ(active_names_at_start_, IPC::GetActiveNameCount());
 
   // Close the channel so the client's OnChannelError() gets fired.
   channel_proxy()->Close();
 
   EXPECT_TRUE(WaitForClientShutdown());
@@ skipping 21 matching lines @@
   {
     std::unique_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
     base::SharedMemoryHandle new_handle;
     ASSERT_TRUE(shared_memory->ShareToProcess(0, &new_handle));
     IPC::Message* message =
         new TestSharedMemoryHandleMsg1(100, new_handle, 200);
     sender()->Send(message);
   }
 
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void ShareToProcessCallback(IPC::Sender* sender,
                             const IPC::Message& message,
                             ChildProcessGlobals* globals) {
   bool success = CheckContentsOfMessage1(message, kDataBuffer1);
   SendControlMessage(sender, success);
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(ShareToProcess) {
   return CommonPrivilegedProcessMain(&ShareToProcessCallback, "ShareToProcess");
 }
 
 // Similar to ShareToProcess, but instead shares the memory object only with
 // read permissions.
 TEST_F(IPCAttachmentBrokerMacTest, ShareReadOnlyToProcess) {
   CommonSetUp("ShareReadOnlyToProcess");
 
   {
     std::unique_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
     base::SharedMemoryHandle new_handle;
     ASSERT_TRUE(shared_memory->ShareReadOnlyToProcess(0, &new_handle));
     IPC::Message* message =
         new TestSharedMemoryHandleMsg1(100, new_handle, 200);
     sender()->Send(message);
   }
 
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void ShareReadOnlyToProcessCallback(IPC::Sender* sender,
                                     const IPC::Message& message,
                                     ChildProcessGlobals* globals) {
   base::SharedMemoryHandle shm(GetSharedMemoryHandleFromMsg1(message));
 
   // Try to map the memory as writable.
   std::unique_ptr<base::SharedMemory> shared_memory(
@@ skipping 48 matching lines @@
       sender()->Send(new AttachmentBrokerMsg_DuplicateMachPort(wire_format));
 
       // Send a dummy message, which will trigger the callback handler in the
       // child process.
       sender()->Send(new TestSharedMemoryHandleMsg4(1));
     }
 
     int received_message_count = 0;
     while (received_message_count < kMessagesToTest) {
       // Wait until the child process has sent this process a message.
-      base::MessageLoop::current()->Run();
+      base::RunLoop().Run();
 
       // Wait for any asynchronous activity to complete.
-      base::MessageLoop::current()->RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
 
       while (get_proxy_listener()->has_message()) {
         get_proxy_listener()->pop_first_message();
         received_message_count++;
       }
     }
 
     for (int i = 0; i < kMessagesToTest; ++i) {
       IPC::BrokerableAttachment::AttachmentId* id = &ids[i];
       ASSERT_TRUE(id);
@@ skipping 44 matching lines @@
 
 // Tests the memory usage characteristics of attachment brokering a single large
 // message. This test has the *potential* to be flaky, since it compares
 // resident memory at different points in time, and that measurement is
 // non-deterministic.
 TEST_F(IPCAttachmentBrokerMacTest, MemoryUsageLargeMessage) {
   CommonSetUp("MemoryUsageLargeMessage");
 
   std::string test_string(g_large_message_size, 'a');
   SendMessage1(test_string);
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   CommonTearDown();
 }
 
 void MemoryUsageLargeMessageCallback(IPC::Sender* sender,
                                      const IPC::Message& message,
                                      ChildProcessGlobals* globals) {
   EXPECT_LE(GetResidentSize(),
             globals->initial_resident_size + g_expected_memory_increase);
 
   base::SharedMemoryHandle shm(GetSharedMemoryHandleFromMsg1(message));
@@ skipping 35 matching lines @@
   CommonSetUp("MemoryUsageManyMessages");
 
   for (int i = 0; i < g_large_message_count; ++i) {
     std::string message = base::IntToString(i);
     message += '\0';
     size_t end = message.size();
     message.resize(g_medium_message_size);
     std::fill(message.begin() + end, message.end(), 'a');
     SendMessage1(message);
 
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   if (get_result_listener()->get_result() == RESULT_UNKNOWN)
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
 
   CommonTearDown();
 }
 
 void MemoryUsageManyMessagesCallback(IPC::Sender* sender,
                                      const IPC::Message& message,
                                      ChildProcessGlobals* globals) {
   static int message_index = 0;
 
   {
@@ skipping 42 matching lines @@
     SendControlMessage(sender, success);
   }
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(MemoryUsageManyMessages) {
   return CommonPrivilegedProcessMain(&MemoryUsageManyMessagesCallback,
                                      "MemoryUsageManyMessages");
 }
 
 }  // namespace