Remove calls to deprecated MessageLoop methods in media.

media/blink/multibuffer_data_source_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 233 matching lines @@
     GURL gurl(url);
     data_source_.reset(new MockMultibufferDataSource(
         gurl, cors_mode, message_loop_.task_runner(), url_index_,
         view_->mainFrame()->toWebLocalFrame(), &host_));
     data_source_->SetPreload(preload_);
 
     response_generator_.reset(new TestResponseGenerator(gurl, kFileSize));
     EXPECT_CALL(*this, OnInitialize(expected));
     data_source_->Initialize(base::Bind(
         &MultibufferDataSourceTest::OnInitialize, base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
 
     // Not really loading until after OnInitialize is called.
     EXPECT_EQ(data_source_->downloading(), false);
   }
 
   void Initialize(const char* url, bool expected) {
     InitializeWithCORS(url, expected, UrlData::CORS_UNSPECIFIED);
   }
 
   // Helper to initialize tests with a valid 200 response.
@@ skipping 29 matching lines @@
   }
 
   // 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 (loading()) {
       data_provider()->didFail(url_loader(),
                                response_generator_->GenerateError());
-      message_loop_.RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
     }
 
     data_source_->Stop();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void Respond(const WebURLResponse& response) {
     EXPECT_TRUE(url_loader());
     if (!active_loader())
       return;
     data_provider()->didReceiveResponse(url_loader(), response);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void ReceiveData(int size) {
     EXPECT_TRUE(url_loader());
     if (!url_loader())
       return;
     std::unique_ptr<char[]> data(new char[size]);
     memset(data.get(), 0xA5, size);  // Arbitrary non-zero value.
 
     data_provider()->didReceiveData(url_loader(), data.get(), size, size);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void FinishLoading() {
     EXPECT_TRUE(url_loader());
     if (!url_loader())
       return;
     data_provider()->didFinishLoading(url_loader(), 0, -1);
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void FailLoading() {
     data_provider()->didFail(url_loader(),
                              response_generator_->GenerateError());
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void Restart() {
     EXPECT_TRUE(data_provider());
     EXPECT_FALSE(active_loader_allownull());
     if (!data_provider())
       return;
     data_provider()->Start();
   }
 
   MOCK_METHOD1(ReadCallback, void(int size));
 
   void ReadAt(int64_t position, int64_t howmuch = kDataSize) {
     data_source_->Read(position, howmuch, buffer_,
                        base::Bind(&MultibufferDataSourceTest::ReadCallback,
                                   base::Unretained(this)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   void ExecuteMixedResponseSuccessTest(const WebURLResponse& response1,
                                        const WebURLResponse& response2) {
     EXPECT_CALL(host_, SetTotalBytes(kFileSize));
     EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
     EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
     EXPECT_CALL(*this, ReadCallback(kDataSize)).Times(2);
 
     Respond(response1);
@@ skipping 237 matching lines @@
 
 TEST_F(MultibufferDataSourceTest, Http_AbortWhileReading) {
   InitializeWith206Response();
 
   // Make sure there's a pending read -- we'll expect it to error.
   ReadAt(kFileSize);
 
   // Abort!!!
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   data_source_->Abort();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(loading());
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, File_AbortWhileReading) {
   InitializeWithFileResponse();
 
   // Make sure there's a pending read -- we'll expect it to error.
   ReadAt(kFileSize);
 
   // Abort!!!
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   data_source_->Abort();
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(loading());
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, Http_Retry) {
   InitializeWith206Response();
 
   // Read to advance our position.
   EXPECT_CALL(*this, ReadCallback(kDataSize));
@@ skipping 264 matching lines @@
   data_source_->Read(0, arraysize(buffer), buffer,
                      base::Bind(&MultibufferDataSourceTest::ReadCallback,
                                 base::Unretained(this)));
 
   // The outstanding read should fail before the stop callback runs.
   {
     InSequence s;
     EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
     data_source_->Stop();
   }
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(MultibufferDataSourceTest, DefaultValues) {
   InitializeWith206Response();
 
   // Ensure we have sane values for default loading scenario.
   EXPECT_EQ(MultibufferDataSource::AUTO, preload());
   EXPECT_EQ(2 << 20, preload_low());
   EXPECT_EQ(3 << 20, preload_high());
 
   EXPECT_EQ(0, data_source_bitrate());
   EXPECT_EQ(0.0, data_source_playback_rate());
 
   EXPECT_TRUE(loading());
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, SetBitrate) {
   InitializeWith206Response();
 
   data_source_->SetBitrate(1234);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1234, data_source_bitrate());
 
   // Read so far ahead to cause the loader to get recreated.
   TestMultiBufferDataProvider* old_loader = data_provider();
   ReadAt(kFarReadPosition);
   Respond(response_generator_->Generate206(kFarReadPosition));
 
   // Verify loader changed but still has same bitrate.
   EXPECT_NE(old_loader, data_provider());
 
   EXPECT_TRUE(loading());
   EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, MediaPlaybackRateChanged) {
   InitializeWith206Response();
 
   data_source_->MediaPlaybackRateChanged(2.0);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2.0, data_source_playback_rate());
 
   // Read so far ahead to cause the loader to get recreated.
   TestMultiBufferDataProvider* old_loader = data_provider();
   ReadAt(kFarReadPosition);
   Respond(response_generator_->Generate206(kFarReadPosition));
 
   // Verify loader changed but still has same playback rate.
   EXPECT_NE(old_loader, data_provider());
 
@@ skipping 41 matching lines @@
       GURL(kHttpUrl), UrlData::CORS_UNSPECIFIED, message_loop_.task_runner(),
       url_index_, view_->mainFrame()->toWebLocalFrame(), &host2);
   source2.SetPreload(preload_);
 
   EXPECT_CALL(*this, OnInitialize(true));
 
   // This call would not be expected if we were not sharing data.
   EXPECT_CALL(host2, SetTotalBytes(response_generator_->content_length()));
   source2.Initialize(base::Bind(&MultibufferDataSourceTest::OnInitialize,
                                 base::Unretained(this)));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Always loading after initialize.
   EXPECT_EQ(source2.downloading(), true);
 
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, Http_Read_Seek) {
   InitializeWith206Response();
 
@@ skipping 271 matching lines @@
   GURL gurl(kHttpUrl);
   data_source_.reset(new MockMultibufferDataSource(
       gurl, UrlData::CORS_UNSPECIFIED, message_loop_.task_runner(), url_index_,
       view_->mainFrame()->toWebLocalFrame(), &host_));
   data_source_->SetPreload(preload_);
 
   response_generator_.reset(new TestResponseGenerator(gurl, kDataSize + 1));
   EXPECT_CALL(*this, OnInitialize(true));
   data_source_->Initialize(base::Bind(&MultibufferDataSourceTest::OnInitialize,
                                       base::Unretained(this)));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Not really loading until after OnInitialize is called.
   EXPECT_EQ(data_source_->downloading(), false);
 
   EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
   Respond(response_generator_->Generate206(0));
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
   ReceiveData(kDataSize);
 
   // Read a bit from the beginning.
@@ skipping 96 matching lines @@
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
   FinishLoading();
 
   // Done loading, now we should know the length.
   EXPECT_TRUE(data_source_->GetSize(&len));
   EXPECT_EQ(kDataSize, len);
   Stop();
 }
 
 }  // namespace media