Remove calls to deprecated MessageLoop methods on Windows and Linux.

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 "remoting/host/win/worker_process_launcher.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_process_information.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/host_exit_codes.h"
 #include "remoting/host/ipc_util.h"
@@ skipping 302 matching lines @@
 
 void WorkerProcessLauncherTest::StopWorker() {
   launcher_.reset();
   DisconnectClient();
   channel_name_.clear();
   channel_server_.reset();
   task_runner_ = nullptr;
 }
 
 void WorkerProcessLauncherTest::QuitMainMessageLoop() {
-  message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  message_loop_.task_runner()->PostTask(
+      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 void WorkerProcessLauncherTest::DoLaunchProcess() {
   EXPECT_TRUE(event_handler_);
   EXPECT_FALSE(worker_process_.IsValid());
 
   WCHAR notepad[MAX_PATH + 1];
   ASSERT_GT(ExpandEnvironmentStrings(
       L"\045SystemRoot\045\\system32\\notepad.exe", notepad, MAX_PATH), 0u);
 
@@ skipping 36 matching lines @@
       .Times(1)
       .WillRepeatedly(Invoke(this, &WorkerProcessLauncherTest::LaunchProcess));
 
   EXPECT_CALL(server_listener_, OnChannelConnected(_))
       .Times(0);
   EXPECT_CALL(server_listener_, OnPermanentError(_))
       .Times(0);
 
   StartWorker();
   StopWorker();
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 // Starts and connects to the worker process. Expect OnChannelConnected to be
 // called.
 TEST_F(WorkerProcessLauncherTest, StartAndConnect) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
       .Times(1)
       .WillRepeatedly(Invoke(
           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 
   EXPECT_CALL(server_listener_, OnChannelConnected(_))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(this,
                                   &WorkerProcessLauncherTest::StopWorker));
   EXPECT_CALL(server_listener_, OnPermanentError(_))
       .Times(0);
 
   StartWorker();
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 // Kills the worker process after the 1st connect and expects it to be
 // restarted.
 TEST_F(WorkerProcessLauncherTest, Restart) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
       .Times(2)
       .WillRepeatedly(Invoke(
           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
   Expectation first_connect =
       EXPECT_CALL(server_listener_, OnChannelConnected(_))
           .Times(2)
           .WillOnce(InvokeWithoutArgs(CreateFunctor(
               &WorkerProcessLauncherTest::TerminateWorker,
               base::Unretained(this),
               CONTROL_C_EXIT)))
           .WillOnce(InvokeWithoutArgs(this,
                                       &WorkerProcessLauncherTest::StopWorker));
 
   EXPECT_CALL(server_listener_, OnPermanentError(_))
       .Times(0);
 
   StartWorker();
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 // Drops the IPC channel to the worker process after the 1st connect and expects
 // the worker process to be restarted.
 TEST_F(WorkerProcessLauncherTest, DropIpcChannel) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
       .Times(2)
       .WillRepeatedly(Invoke(
           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 
   Expectation first_connect =
       EXPECT_CALL(server_listener_, OnChannelConnected(_))
           .Times(2)
           .WillOnce(InvokeWithoutArgs(
               this, &WorkerProcessLauncherTest::DisconnectClient))
           .WillOnce(InvokeWithoutArgs(
               this, &WorkerProcessLauncherTest::StopWorker));
 
   EXPECT_CALL(server_listener_, OnPermanentError(_))
       .Times(0);
 
   StartWorker();
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 // Returns a permanent error exit code and expects OnPermanentError() to be
 // invoked.
 TEST_F(WorkerProcessLauncherTest, PermanentError) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
       .Times(1)
       .WillRepeatedly(Invoke(
           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 
   EXPECT_CALL(server_listener_, OnChannelConnected(_))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(CreateFunctor(
           &WorkerProcessLauncherTest::TerminateWorker,
           base::Unretained(this),
           kMinPermanentErrorExitCode)));
   EXPECT_CALL(server_listener_, OnPermanentError(_))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(this,
                                   &WorkerProcessLauncherTest::StopWorker));
 
   StartWorker();
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 // Requests the worker to crash and expects it to honor the request.
 TEST_F(WorkerProcessLauncherTest, Crash) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
       .Times(2)
       .WillRepeatedly(Invoke(
           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 
   EXPECT_CALL(server_listener_, OnChannelConnected(_))
       .Times(2)
       .WillOnce(InvokeWithoutArgs(this,
                                   &WorkerProcessLauncherTest::CrashWorker))
       .WillOnce(InvokeWithoutArgs(this,
                                   &WorkerProcessLauncherTest::StopWorker));
 
   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(CreateFunctor(
           &WorkerProcessLauncherTest::TerminateWorker,
           base::Unretained(this),
           EXCEPTION_BREAKPOINT)));
 
   StartWorker();
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 // Requests the worker to crash and terminates the worker even if it does not
 // comply.
 TEST_F(WorkerProcessLauncherTest, CrashAnyway) {
   EXPECT_CALL(*launcher_delegate_, LaunchProcess(_))
       .Times(2)
       .WillRepeatedly(Invoke(
           this, &WorkerProcessLauncherTest::LaunchProcessAndConnect));
 
   EXPECT_CALL(server_listener_, OnChannelConnected(_))
       .Times(2)
       .WillOnce(InvokeWithoutArgs(this,
                                   &WorkerProcessLauncherTest::CrashWorker))
       .WillOnce(InvokeWithoutArgs(this,
                                   &WorkerProcessLauncherTest::StopWorker));
 
   // Ignore the crash request and try send another message to the launcher.
   EXPECT_CALL(client_listener_, OnCrash(_, _, _))
       .Times(1)
       .WillOnce(InvokeWithoutArgs(
           this, &WorkerProcessLauncherTest::SendFakeMessageToLauncher));
 
   StartWorker();
-  message_loop_.Run();
+  base::RunLoop().Run();
 }
 
 }  // namespace remoting