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

webkit/media/buffered_data_source_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/bind.h"
 #include "base/message_loop.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_data_source_host.h"
 #include "media/base/mock_filters.h"
@@ skipping 97 matching lines @@
 
   void Initialize(const char* url, bool expected) {
     GURL gurl(url);
     response_generator_.reset(new TestResponseGenerator(gurl, kFileSize));
 
     ExpectCreateResourceLoader();
     EXPECT_CALL(*this, OnInitialize(expected));
     data_source_->Initialize(
         gurl, BufferedResourceLoader::kUnspecified, base::Bind(
             &BufferedDataSourceTest::OnInitialize, base::Unretained(this)));
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
 
     bool is_http = gurl.SchemeIs(kHttpScheme) || gurl.SchemeIs(kHttpsScheme);
     EXPECT_EQ(data_source_->downloading(), is_http);
   }
 
   // Helper to initialize tests with a valid 206 response.
   void InitializeWith206Response() {
     Initialize(kHttpUrl, true);
 
     EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
     Respond(response_generator_->Generate206(0));
   }
 
   // Helper to initialize tests with a valid file:// response.
   void InitializeWithFileResponse() {
     Initialize(kFileUrl, true);
 
     EXPECT_CALL(host_, SetTotalBytes(kFileSize));
     EXPECT_CALL(host_, AddBufferedByteRange(0, kFileSize));
     Respond(response_generator_->GenerateFileResponse(0));
   }
 
   // Stops any active loaders and shuts down the data source.
   //
   // This typically happens when the page is closed and for our purposes is
   // appropriate to do when tearing down a test.
   void Stop() {
     if (data_source_->loading()) {
       loader()->didFail(url_loader(), response_generator_->GenerateError());
-      message_loop_.RunAllPending();
+      message_loop_.RunUntilIdle();
     }
 
     data_source_->Stop(media::NewExpectedClosure());
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
   }
 
   void ExpectCreateResourceLoader() {
     EXPECT_CALL(*data_source_, CreateResourceLoader(_, _))
         .WillOnce(Invoke(data_source_.get(),
                          &MockBufferedDataSource::CreateMockResourceLoader));
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
   }
 
   void Respond(const WebURLResponse& response) {
     loader()->didReceiveResponse(url_loader(), response);
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
   }
 
   void ReceiveData(int size) {
     scoped_array<char> data(new char[size]);
     memset(data.get(), 0xA5, size);  // Arbitrary non-zero value.
 
     loader()->didReceiveData(url_loader(), data.get(), size, size);
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
   }
 
   void FinishLoading() {
     data_source_->set_loading(false);
     loader()->didFinishLoading(url_loader(), 0);
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
   }
 
   MOCK_METHOD1(ReadCallback, void(int size));
 
   void ReadAt(int64 position) {
     data_source_->Read(position, kDataSize, buffer_,
                        base::Bind(&BufferedDataSourceTest::ReadCallback,
                                   base::Unretained(this)));
-    message_loop_.RunAllPending();
+    message_loop_.RunUntilIdle();
   }
 
   // Accessors for private variables on |data_source_|.
   BufferedResourceLoader* loader() {
     return data_source_->loader_.get();
   }
   WebURLLoader* url_loader() {
     return loader()->active_loader_->loader_.get();
   }
 
@@ skipping 128 matching lines @@
 
 TEST_F(BufferedDataSourceTest, Http_AbortWhileReading) {
   InitializeWith206Response();
 
   // Make sure there's a pending read -- we'll expect it to error.
   ReadAt(0);
 
   // Abort!!!
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   data_source_->Abort();
-  message_loop_.RunAllPending();
+  message_loop_.RunUntilIdle();
 
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, File_AbortWhileReading) {
   InitializeWithFileResponse();
 
   // Make sure there's a pending read -- we'll expect it to error.
   ReadAt(0);
 
   // Abort!!!
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   data_source_->Abort();
-  message_loop_.RunAllPending();
+  message_loop_.RunUntilIdle();
 
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Http_Retry) {
   InitializeWith206Response();
 
   // Read to advance our position.
   EXPECT_CALL(*this, ReadCallback(kDataSize));
@@ skipping 125 matching lines @@
 
   // Stop() the data source, using a callback that lets us verify that it was
   // called before Stop() returns. This is to make sure that the callback does
   // not require |message_loop_| to execute tasks before being called.
   bool stop_done_called = false;
   EXPECT_TRUE(data_source_->loading());
   data_source_->Stop(base::Bind(&SetTrue, &stop_done_called));
 
   // Verify that the callback was called inside the Stop() call.
   EXPECT_TRUE(stop_done_called);
-  message_loop_.RunAllPending();
+  message_loop_.RunUntilIdle();
 }
 
 TEST_F(BufferedDataSourceTest, DefaultValues) {
   InitializeWith206Response();
 
   // Ensure we have sane values for default loading scenario.
   EXPECT_EQ(AUTO, preload());
   EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
 
   EXPECT_EQ(0, data_source_bitrate());
   EXPECT_EQ(0.0f, data_source_playback_rate());
   EXPECT_EQ(0, loader_bitrate());
   EXPECT_EQ(0.0f, loader_playback_rate());
 
   EXPECT_TRUE(data_source_->loading());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, SetBitrate) {
   InitializeWith206Response();
 
   data_source_->SetBitrate(1234);
-  message_loop_.RunAllPending();
+  message_loop_.RunUntilIdle();
   EXPECT_EQ(1234, data_source_bitrate());
   EXPECT_EQ(1234, loader_bitrate());
 
   // Read so far ahead to cause the loader to get recreated.
   BufferedResourceLoader* old_loader = loader();
   ExpectCreateResourceLoader();
   ReadAt(kFarReadPosition);
   Respond(response_generator_->Generate206(kFarReadPosition));
 
   // Verify loader changed but still has same bitrate.
   EXPECT_NE(old_loader, loader());
   EXPECT_EQ(1234, loader_bitrate());
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, SetPlaybackRate) {
   InitializeWith206Response();
 
   data_source_->SetPlaybackRate(2.0f);
-  message_loop_.RunAllPending();
+  message_loop_.RunUntilIdle();
   EXPECT_EQ(2.0f, data_source_playback_rate());
   EXPECT_EQ(2.0f, loader_playback_rate());
 
   // Read so far ahead to cause the loader to get recreated.
   BufferedResourceLoader* old_loader = loader();
   ExpectCreateResourceLoader();
   ReadAt(kFarReadPosition);
   Respond(response_generator_->Generate206(kFarReadPosition));
 
   // Verify loader changed but still has same playback rate.
@@ skipping 51 matching lines @@
   InitializeWithFileResponse();
 
   EXPECT_FALSE(data_source_->downloading());
   FinishLoading();
   EXPECT_FALSE(data_source_->downloading());
 
   Stop();
 }
 
 }  // namespace webkit_media