ipc: Use base::MessageLoop.

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.
 
 #include "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 52 matching lines @@
     CHECK(is_shutdown_);
   }
   void AddRef() { }
   void Release() { }
   virtual bool Send(Message* msg) OVERRIDE { return channel_->Send(msg); }
   bool SendWithTimeout(Message* msg, int timeout_ms) {
     return channel_->SendWithTimeout(msg, timeout_ms);
   }
   void WaitForChannelCreation() { channel_created_->Wait(); }
   void CloseChannel() {
-    DCHECK(MessageLoop::current() == ListenerThread()->message_loop());
+    DCHECK(base::MessageLoop::current() == ListenerThread()->message_loop());
     channel_->Close();
   }
   void Start() {
-    StartThread(&listener_thread_, MessageLoop::TYPE_DEFAULT);
-    ListenerThread()->message_loop()->PostTask(
-        FROM_HERE, base::Bind(&Worker::OnStart, this));
+    StartThread(&listener_thread_, base::MessageLoop::TYPE_DEFAULT);
+    ListenerThread()->message_loop()
+        ->PostTask(FROM_HERE, base::Bind(&Worker::OnStart, this));

[agl, 2013/04/30 17:38:49]

This specific change is just formatting and is making the code worse. This one
should be changed back.

[xhwang, 2013/04/30 17:46:54]

Done.

   }
   void Shutdown() {
     // The IPC thread needs to outlive SyncChannel. We can't do this in
     // ~Worker(), since that'll reset the vtable pointer (to Worker's), which
     // may result in a race conditions. See http://crbug.com/25841.
     WaitableEvent listener_done(false, false), ipc_done(false, false);
     ListenerThread()->message_loop()->PostTask(
         FROM_HERE, base::Bind(&Worker::OnListenerThreadShutdown1, this,
                               &listener_done, &ipc_done));
     listener_done.Wait();
@@ skipping 72 matching lines @@
   base::Thread* ListenerThread() {
     return overrided_thread_ ? overrided_thread_ : &listener_thread_;
   }
 
   const base::Thread& ipc_thread() const { return ipc_thread_; }
 
  private:
   // Called on the listener thread to create the sync channel.
   void OnStart() {
     // Link ipc_thread_, listener_thread_ and channel_ altogether.
-    StartThread(&ipc_thread_, MessageLoop::TYPE_IO);
+    StartThread(&ipc_thread_, base::MessageLoop::TYPE_IO);
     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();
 
@@ skipping 23 matching lines @@
     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)
     IPC_END_MESSAGE_MAP()
     return true;
   }
 
-  void StartThread(base::Thread* thread, MessageLoop::Type type) {
+  void StartThread(base::Thread* thread, base::MessageLoop::Type type) {
     base::Thread::Options options;
     options.message_loop_type = type;
     thread->StartWithOptions(options);
   }
 
   scoped_ptr<WaitableEvent> done_;
   scoped_ptr<WaitableEvent> channel_created_;
   std::string channel_name_;
   Channel::Mode mode_;
   scoped_ptr<SyncChannel> channel_;
@@ skipping 32 matching lines @@
     workers[i]->done_event()->Wait();
 
   for (size_t i = 0; i < workers.size(); ++i) {
     workers[i]->Shutdown();
     delete workers[i];
   }
 }
 
 class IPCSyncChannelTest : public testing::Test {
  private:
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
 };
 
 //------------------------------------------------------------------------------
 
 class SimpleServer : public Worker {
  public:
   explicit SimpleServer(bool pump_during_send)
       : Worker(Channel::MODE_SERVER, "simpler_server"),
         pump_during_send_(pump_during_send) { }
   virtual void Run() OVERRIDE {
@@ skipping 714 matching lines @@
 void TimeoutCallback() {
   timeout_occurred = true;
 }
 
 class DoneEventRaceServer : public Worker {
  public:
   DoneEventRaceServer()
       : Worker(Channel::MODE_SERVER, "done_event_race_server") { }
 
   virtual void Run() OVERRIDE {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(&NestedCallback, this));
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::Bind(&NestedCallback, this));
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&TimeoutCallback),
         base::TimeDelta::FromSeconds(9));
     // Even though we have a timeout on the Send, it will succeed since for this
     // bug, the reply message comes back and is deserialized, however the done
     // event wasn't set.  So we indirectly use the timeout task to notice if a
     // timeout occurred.
     SendAnswerToLife(true, 10000, true);
     DCHECK(!timeout_occurred);
     Done();
@@ skipping 44 matching lines @@
   Worker* worker_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
 };
 
 class SyncMessageFilterServer : public Worker {
  public:
   SyncMessageFilterServer()
       : Worker(Channel::MODE_SERVER, "sync_message_filter_server"),
         thread_("helper_thread") {
     base::Thread::Options options;
-    options.message_loop_type = MessageLoop::TYPE_DEFAULT;
+    options.message_loop_type = base::MessageLoop::TYPE_DEFAULT;
     thread_.StartWithOptions(options);
     filter_ = new TestSyncMessageFilter(shutdown_event(), this,
                                         thread_.message_loop_proxy());
   }
 
   virtual void Run() OVERRIDE {
     channel()->AddFilter(filter_.get());
   }
 
   base::Thread thread_;
@@ skipping 798 matching lines @@
 }
 
 // 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