ipc: Convert MessageLoop::RunUntilIdle() usage to base::RunLoop variant.

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.
-//
-// Unit test for SyncChannel.
 
 #include "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
+#include "base/run_loop.h"
 #include "base/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.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;
-using namespace IPC;
 
+namespace IPC {
 namespace {
 
 // Base class for a "process" with listener and IPC threads.
 class Worker : public Listener, public Sender {
  public:
   // Will create a channel without a name.
   Worker(Channel::Mode mode, const std::string& thread_name)
       : done_(new WaitableEvent(false, false)),
         channel_created_(new WaitableEvent(false, false)),
         mode_(mode),
@@ skipping 132 matching lines @@
     channel_.reset(CreateChannel());
     channel_created_->Signal();
     Run();
   }
 
   void OnListenerThreadShutdown1(WaitableEvent* listener_event,
                                  WaitableEvent* ipc_event) {
     // SyncChannel needs to be destructed on the thread that it was created on.
     channel_.reset();
 
-    MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     ipc_thread_.message_loop()->PostTask(
         FROM_HERE, base::Bind(&Worker::OnIPCThreadShutdown, this,
                               listener_event, ipc_event));
   }
 
   void OnIPCThreadShutdown(WaitableEvent* listener_event,
                            WaitableEvent* ipc_event) {
-    MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     ipc_event->Signal();
 
     listener_thread_.message_loop()->PostTask(
         FROM_HERE, base::Bind(&Worker::OnListenerThreadShutdown2, this,
                               listener_event));
   }
 
   void OnListenerThreadShutdown2(WaitableEvent* listener_event) {
-    MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     listener_event->Signal();
   }
 
   virtual bool OnMessageReceived(const Message& message) OVERRIDE {
     IPC_BEGIN_MESSAGE_MAP(Worker, message)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelTestMsg_Double, OnDoubleDelay)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelTestMsg_AnswerToLife,
                                      OnAnswerDelay)
      IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncChannelNestedTestMsg_String,
                                      OnNestedTestMsg)
@@ skipping 1667 matching lines @@
   RunTest(workers);
 }
 
 // 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