media: Update calls from RunAllPending() to RunUntilIdle().

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 <string>
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "media/audio/audio_output_dispatcher_impl.h"
@@ skipping 139 matching lines @@
         .WillRepeatedly(Return(message_loop_.message_loop_proxy()));
     InitDispatcher(base::TimeDelta::FromMilliseconds(kTestCloseDelayMs));
   }
 
   virtual void TearDown() {
     // All paused proxies should have been closed at this point.
     EXPECT_EQ(0u, dispatcher_impl_->paused_proxies_);
 
     // This is necessary to free all proxy objects that have been
     // closed by the test.
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
   }
 
   virtual void InitDispatcher(base::TimeDelta close_delay) {
     // Use a low sample rate and large buffer size when testing otherwise the
     // FakeAudioOutputStream will keep the message loop busy indefinitely; i.e.,
-    // RunAllPending() will never terminate.
+    // RunUntilIdle() will never terminate.
     params_ = AudioParameters(AudioParameters::AUDIO_PCM_LINEAR,
                               CHANNEL_LAYOUT_STEREO, 8000, 16, 2048);
     dispatcher_impl_ = new AudioOutputDispatcherImpl(&manager(),
                                                      params_,
                                                      close_delay);
 #if defined(ENABLE_AUDIO_MIXER)
     mixer_ = new AudioOutputMixer(&manager(), params_, close_delay);
 #endif
 
     // Necessary to know how long the dispatcher will wait before posting
     // StopStreamTask.
     pause_delay_ = dispatcher_impl_->pause_delay_;
   }
 
   virtual void OnStart() {}
 
   MockAudioManager& manager() {
     return manager_;
   }
 
   // Wait for the close timer to fire.
   void WaitForCloseTimer(const int timer_delay_ms) {
-    message_loop_.RunAllPending();  // OpenTask() may reset the timer.
+    message_loop_.RunUntilIdle();  // OpenTask() may reset the timer.
     base::PlatformThread::Sleep(
         base::TimeDelta::FromMilliseconds(timer_delay_ms) * 2);
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
   }
 
   // Methods that do actual tests.
   void OpenAndClose(AudioOutputDispatcher* dispatcher) {
     MockAudioOutputStream stream(&manager_, params_);
 
     EXPECT_CALL(manager(), MakeAudioOutputStream(_))
         .WillOnce(Return(&stream));
     EXPECT_CALL(stream, Open())
         .WillOnce(Return(true));
@@ skipping 114 matching lines @@
         .WillOnce(Return(true));
     EXPECT_CALL(stream, Close())
         .Times(1);
 
     AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher);
     EXPECT_TRUE(proxy->Open());
 
     // Simulate a delay.
     base::PlatformThread::Sleep(
         base::TimeDelta::FromMilliseconds(kTestCloseDelayMs) * 2);
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
 
     // Verify expectation before calling Close().
     Mock::VerifyAndClear(&stream);
 
     proxy->Close();
     EXPECT_FALSE(stream.stop_called());
     EXPECT_FALSE(stream.start_called());
   }
 
   void TwoStreams_OnePlaying(AudioOutputDispatcher* dispatcher) {
@@ skipping 15 matching lines @@
         .WillOnce(Return(true));
     EXPECT_CALL(stream2, Close())
         .Times(1);
 
     AudioOutputProxy* proxy1 = new AudioOutputProxy(dispatcher);
     AudioOutputProxy* proxy2 = new AudioOutputProxy(dispatcher);
     EXPECT_TRUE(proxy1->Open());
     EXPECT_TRUE(proxy2->Open());
 
     proxy1->Start(&callback_);
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
     OnStart();
     proxy1->Stop();
 
     proxy1->Close();
     proxy2->Close();
     EXPECT_TRUE(stream1.stop_called());
     EXPECT_TRUE(stream1.start_called());
     EXPECT_FALSE(stream2.stop_called());
     EXPECT_FALSE(stream2.start_called());
   }
@@ skipping 48 matching lines @@
         .WillOnce(Return(true));
     EXPECT_CALL(stream, Close())
         .Times(1);
 
     AudioOutputProxy* proxy = new AudioOutputProxy(dispatcher_impl_);
     EXPECT_TRUE(proxy->Open());
 
     // Simulate a delay.
     base::PlatformThread::Sleep(
         base::TimeDelta::FromMilliseconds(kTestCloseDelayMs) * 2);
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
 
     // Verify expectation before calling Close().
     Mock::VerifyAndClear(&stream);
 
     // |stream| is closed at this point. Start() should reopen it again.
     EXPECT_CALL(manager(), MakeAudioOutputStream(_))
         .WillOnce(Return(reinterpret_cast<AudioOutputStream*>(NULL)));
 
     EXPECT_CALL(callback_, OnError(_, _))
         .Times(1);
@@ skipping 19 matching lines @@
 class AudioOutputResamplerTest : public AudioOutputProxyTest {
  public:
   virtual void TearDown() {
     AudioOutputProxyTest::TearDown();
   }
 
   virtual void InitDispatcher(base::TimeDelta close_delay) {
     AudioOutputProxyTest::InitDispatcher(close_delay);
     // Use a low sample rate and large buffer size when testing otherwise the
     // FakeAudioOutputStream will keep the message loop busy indefinitely; i.e.,
-    // RunAllPending() will never terminate.
+    // RunUntilIdle() will never terminate.
     resampler_params_ = AudioParameters(
         AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
         16000, 16, 1024);
     resampler_ = new AudioOutputResampler(
         &manager(), params_, resampler_params_, close_delay);
   }
 
   virtual void OnStart() {
     // Let start run for a bit.
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
     base::PlatformThread::Sleep(
         base::TimeDelta::FromMilliseconds(kStartRunTimeMs));
   }
 
  protected:
   AudioParameters resampler_params_;
   scoped_refptr<AudioOutputResampler> resampler_;
 };
 
 TEST_F(AudioOutputProxyTest, CreateAndClose) {
@@ skipping 398 matching lines @@
   WaitForCloseTimer(kTestCloseDelayMs);
   EXPECT_TRUE(stream1.stop_called());
   EXPECT_TRUE(stream1.start_called());
   EXPECT_TRUE(stream2.stop_called());
   EXPECT_TRUE(stream2.start_called());
   EXPECT_FALSE(stream3.stop_called());
   EXPECT_FALSE(stream3.start_called());
 }
 
 }  // namespace media