remoting: Use base::MessageLoop.

remoting/host/win/worker_process_launcher_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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/win/scoped_handle.h"
 #include "ipc/ipc_channel.h"
@@ skipping 126 matching lines @@
   // Starts the worker.
   void StartWorker();
 
   // Stops the worker.
   void StopWorker();
 
   // Quits |message_loop_|.
   void QuitMainMessageLoop();
 
  protected:
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   scoped_refptr<AutoThreadTaskRunner> task_runner_;
 
   // Receives messages sent to the worker process.
   MockWorkerListener client_listener_;
 
   // Receives messages sent from the worker process.
   MockIpcDelegate server_listener_;
 
   // Implements WorkerProcessLauncher::Delegate.
   scoped_ptr<MockProcessLauncherDelegate> launcher_delegate_;
@@ skipping 11 matching lines @@
   // The worker process launcher.
   scoped_ptr<WorkerProcessLauncher> launcher_;
 
   // The event signalling termination of the worker process.
   ScopedHandle process_exit_event_;
 
   // True if a permanent error condition should be emulated.
   bool permanent_error_;
 };
 
-
 WorkerProcessLauncherTest::WorkerProcessLauncherTest()
-    : message_loop_(MessageLoop::TYPE_IO),
+    : message_loop_(base::MessageLoop::TYPE_IO),
       client_pid_(GetCurrentProcessId()),
-      permanent_error_(false) {
-}
+      permanent_error_(false) {}
 
 WorkerProcessLauncherTest::~WorkerProcessLauncherTest() {
 }
 
 void WorkerProcessLauncherTest::SetUp() {
   task_runner_ = new AutoThreadTaskRunner(
       message_loop_.message_loop_proxy(),
       base::Bind(&WorkerProcessLauncherTest::QuitMainMessageLoop,
                  base::Unretained(this)));
 
@@ skipping 128 matching lines @@
 
 void WorkerProcessLauncherTest::StopWorker() {
   launcher_.reset();
   DisconnectClient();
   channel_name_.clear();
   channel_server_.reset();
   task_runner_ = NULL;
 }
 
 void WorkerProcessLauncherTest::QuitMainMessageLoop() {
-  message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 }
 
 TEST_F(WorkerProcessLauncherTest, Start) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_, _))
       .Times(1)
       .WillRepeatedly(Invoke(this, &WorkerProcessLauncherTest::LaunchProcess));
 
   EXPECT_CALL(server_listener_, OnChannelConnected(_))
       .Times(0);
   EXPECT_CALL(server_listener_, OnPermanentError())
@@ skipping 152 matching lines @@
   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(
           this, &WorkerProcessLauncherTest::SendFakeMessageToLauncher));
 
   StartWorker();
   message_loop_.Run();
 }
 
 }  // namespace remoting