Remove calls to deprecated MessageLoop methods in media.

media/audio/audio_output_proxy_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 <memory>
 #include <string>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/audio_output_resampler.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 138 matching lines @@
     // FakeAudioOutputStream will keep the message loop busy indefinitely; i.e.,
     // RunUntilIdle() will never terminate.
     params_ = AudioParameters(AudioParameters::AUDIO_PCM_LINEAR,
                               CHANNEL_LAYOUT_STEREO, 8000, 16, 2048);
     InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));
   }
 
   void TearDown() override {
     // This is necessary to free all proxy objects that have been
     // closed by the test.
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   virtual void InitDispatcher(base::TimeDelta close_delay) {
     dispatcher_impl_ = new AudioOutputDispatcherImpl(&manager(),
                                                      params_,
                                                      std::string(),
                                                      close_delay);
   }
 
   virtual void OnStart() {}
@@ skipping 255 matching lines @@
     resampler_params_ = AudioParameters(
         AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
         16000, 16, 1024);
     resampler_ = new AudioOutputResampler(
         &manager(), params_, resampler_params_, std::string(), close_delay);
   }
 
   void OnStart() override {
     // Let Start() run for a bit.
     base::RunLoop run_loop;
-    message_loop_.PostDelayedTask(
-        FROM_HERE,
-        run_loop.QuitClosure(),
+    message_loop_.task_runner()->PostDelayedTask(
+        FROM_HERE, run_loop.QuitClosure(),
         base::TimeDelta::FromMilliseconds(kStartRunTimeMs));
     run_loop.Run();
   }
 
  protected:
   AudioParameters resampler_params_;
   scoped_refptr<AudioOutputResampler> resampler_;
 };
 
 TEST_F(AudioOutputProxyTest, CreateAndClose) {
@@ skipping 259 matching lines @@
                   _, _))
       .WillOnce(Return(&fake_stream));
   EXPECT_CALL(fake_stream, Open()).WillOnce(Return(true));
   AudioOutputProxy* proxy = new AudioOutputProxy(resampler_.get());
   EXPECT_TRUE(proxy->Open());
   CloseAndWaitForCloseTimer(proxy, &fake_stream);
 
   // Once all proxies have been closed, AudioOutputResampler will start the
   // reinitialization timer and execute it after the close delay elapses.
   base::RunLoop run_loop;
-  message_loop_.PostDelayedTask(
+  message_loop_.task_runner()->PostDelayedTask(
       FROM_HERE, run_loop.QuitClosure(),
       base::TimeDelta::FromMilliseconds(2 * kTestCloseDelayMs));
   run_loop.Run();
 
   // Verify a non-fake stream can be created.
   MockAudioOutputStream real_stream(&manager_, params_);
   EXPECT_CALL(manager(),
               MakeAudioOutputStream(
                   testing::Property(&AudioParameters::format,
                                     testing::Ne(AudioParameters::AUDIO_FAKE)),
                   _, _))
       .WillOnce(Return(&real_stream));
 
   // Stream1 should be able to successfully open and start.
   EXPECT_CALL(real_stream, Open()).WillOnce(Return(true));
   proxy = new AudioOutputProxy(resampler_.get());
   EXPECT_TRUE(proxy->Open());
   CloseAndWaitForCloseTimer(proxy, &real_stream);
 }
 
 }  // namespace media