ipc: Use base::MessageLoop.

ipc/ipc_sync_channel.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_sync_channel.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
@@ skipping 377 matching lines @@
 }
 
 void SyncChannel::SyncContext::OnWaitableEventSignaled(WaitableEvent* event) {
   if (event == shutdown_event_) {
     // Process shut down before we can get a reply to a synchronous message.
     // Cancel pending Send calls, which will end up setting the send done event.
     CancelPendingSends();
   } else {
     // We got the reply, timed out or the process shutdown.
     DCHECK_EQ(GetSendDoneEvent(), event);
-    MessageLoop::current()->QuitNow();
+    base::MessageLoop::current()->QuitNow();
   }
 }
 
 base::WaitableEventWatcher::EventCallback
     SyncChannel::SyncContext::MakeWaitableEventCallback() {
   return base::Bind(&SyncChannel::SyncContext::OnWaitableEventSignaled, this);
 }
 
 SyncChannel::SyncChannel(
     const IPC::ChannelHandle& channel_handle,
@@ skipping 126 matching lines @@
     old_event = old_send_done_event_watcher->GetWatchedEvent();
     old_send_done_event_watcher->StopWatching();
   }
 
   sync_msg_queue->set_top_send_done_watcher(&send_done_watcher);
 
   send_done_watcher.StartWatching(context->GetSendDoneEvent(),
                                   context->MakeWaitableEventCallback());
 
   {
-    MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
-    MessageLoop::current()->Run();
+    base::MessageLoop::ScopedNestableTaskAllower allow(
+        base::MessageLoop::current());
+    base::MessageLoop::current()->Run();
   }
 
   sync_msg_queue->set_top_send_done_watcher(old_send_done_event_watcher);
   if (old_send_done_event_watcher && old_event) {
     old_send_done_event_watcher->StartWatching(old_event, old_callback);
   }
 }
 
 void SyncChannel::OnWaitableEventSignaled(WaitableEvent* event) {
   DCHECK(event == sync_context()->GetDispatchEvent());
@@ skipping 12 matching lines @@
   // manual reset since the object watcher might otherwise reset the event
   // when we're doing a WaitMany.
   dispatch_watcher_callback_ =
       base::Bind(&SyncChannel::OnWaitableEventSignaled,
                   base::Unretained(this));
   dispatch_watcher_.StartWatching(sync_context()->GetDispatchEvent(),
                                   dispatch_watcher_callback_);
 }
 
 }  // namespace IPC