Remove calls to deprecated MessageLoop methods on Windows and Linux.

media/audio/audio_output_device_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 <stdint.h>
 
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/sync_socket.h"
 #include "base/task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/audio/audio_output_device.h"
 #include "media/audio/sample_rates.h"
 #include "media/base/test_helpers.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 124 matching lines @@
       base::WrapUnique(audio_output_ipc_), io_loop_.task_runner(), 0, device_id,
       url::Origin(),
       base::TimeDelta::FromMilliseconds(kAuthTimeoutForTestingMs));
 }
 
 void AudioOutputDeviceTest::SetDevice(const std::string& device_id) {
   CreateDevice(device_id);
   EXPECT_CALL(*audio_output_ipc_,
               RequestDeviceAuthorization(audio_device_.get(), 0, device_id, _));
   audio_device_->RequestDeviceAuthorization();
-  io_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Simulate response from browser
   OutputDeviceStatus device_status =
       (device_id == kUnauthorizedDeviceId)
           ? OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED
           : OUTPUT_DEVICE_STATUS_OK;
   ReceiveAuthorization(device_status);
 
   audio_device_->Initialize(default_audio_parameters_,
                             &callback_);
 }
 
 void AudioOutputDeviceTest::CheckDeviceStatus(OutputDeviceStatus status) {
   DCHECK(!io_loop_.task_runner()->BelongsToCurrentThread());
   EXPECT_EQ(status, audio_device_->GetOutputDeviceInfo().device_status());
 }
 
 void AudioOutputDeviceTest::ReceiveAuthorization(OutputDeviceStatus status) {
   device_status_ = status;
   if (device_status_ != OUTPUT_DEVICE_STATUS_OK)
     EXPECT_CALL(*audio_output_ipc_, CloseStream());
 
   audio_device_->OnDeviceAuthorized(device_status_, default_audio_parameters_,
                                     kDefaultDeviceId);
-  io_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 void AudioOutputDeviceTest::StartAudioDevice() {
   if (device_status_ == OUTPUT_DEVICE_STATUS_OK)
     EXPECT_CALL(*audio_output_ipc_, CreateStream(audio_device_.get(), _));
   else
     EXPECT_CALL(callback_, OnRenderError());
 
   audio_device_->Start();
-  io_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 void AudioOutputDeviceTest::CreateStream() {
   const int kMemorySize = CalculateMemorySize();
 
   ASSERT_TRUE(shared_memory_.CreateAndMapAnonymous(kMemorySize));
   memset(shared_memory_.memory(), 0xff, kMemorySize);
 
   ASSERT_TRUE(CancelableSyncSocket::CreatePair(&browser_socket_,
                                                &renderer_socket_));
 
   // Create duplicates of the handles we pass to AudioOutputDevice since
   // ownership will be transferred and AudioOutputDevice is responsible for
   // freeing.
   SyncSocket::TransitDescriptor audio_device_socket_descriptor;
   ASSERT_TRUE(renderer_socket_.PrepareTransitDescriptor(
       base::GetCurrentProcessHandle(), &audio_device_socket_descriptor));
   base::SharedMemoryHandle duplicated_memory_handle;
   ASSERT_TRUE(shared_memory_.ShareToProcess(base::GetCurrentProcessHandle(),
                                             &duplicated_memory_handle));
 
   audio_device_->OnStreamCreated(
       duplicated_memory_handle,
       SyncSocket::UnwrapHandle(audio_device_socket_descriptor), kMemorySize);
-  io_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 void AudioOutputDeviceTest::ExpectRenderCallback() {
   // We should get a 'play' notification when we call OnStreamCreated().
   // Respond by asking for some audio data.  This should ask our callback
   // to provide some audio data that AudioOutputDevice then writes into the
   // shared memory section.
   const int kMemorySize = CalculateMemorySize();
 
   EXPECT_CALL(*audio_output_ipc_, PlayStream())
@@ skipping 10 matching lines @@
   EXPECT_CALL(callback_, Render(_, _, _))
       .WillOnce(DoAll(QuitLoop(io_loop_.task_runner()),
                       Return(kNumberOfFramesToProcess)));
 }
 
 void AudioOutputDeviceTest::WaitUntilRenderCallback() {
   // Don't hang the test if we never get the Render() callback.
   io_loop_.task_runner()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       TestTimeouts::action_timeout());
-  io_loop_.Run();
+  base::RunLoop().Run();
 }
 
 void AudioOutputDeviceTest::StopAudioDevice() {
   if (device_status_ == OUTPUT_DEVICE_STATUS_OK)
     EXPECT_CALL(*audio_output_ipc_, CloseStream());
 
   audio_device_->Stop();
-  io_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(AudioOutputDeviceTest, Initialize) {
   // Tests that the object can be constructed, initialized and destructed
   // without having ever been started.
   StopAudioDevice();
 }
 
 // Calls Start() followed by an immediate Stop() and check for the basic message
 // filter messages being sent in that case.
@@ skipping 79 matching lines @@
 
   media::WaitableMessageLoopEvent event;
 
   // Request device info on another thread.
   thread.task_runner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&AudioOutputDeviceTest::CheckDeviceStatus,
                  base::Unretained(this), OUTPUT_DEVICE_STATUS_ERROR_TIMED_OUT),
       event.GetClosure());
 
-  io_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Runs the loop and waits for |thread| to call event's closure.
   event.RunAndWait();
 
   audio_device_->Stop();
-  io_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 
 }  // namespace media.