Remove usage of ScopedTaskScheduler from PipelineIntegrationTestBase.

ScopedTaskScheduler is deprecated.

Bug: 708584
Change-Id: I148560146aa121d8e83fc416b1f86e35934d9054
Reviewed-on: https://chromium-review.googlesource.com/586915Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Commit-Queue: Francois Doray <fdoray@chromium.org>
Cr-Commit-Position: refs/heads/master@{#490817}

media/test/pipeline_integration_test.cc

@@ -608,7 +608,7 @@ TEST_F(PipelineIntegrationTest, PlaybackWithAudioTrackDisabledThenEnabled) {
   // Disable audio.
   std::vector<MediaTrack::Id> empty;
   pipeline_->OnEnabledAudioTracksChanged(empty);
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
 
   // Seek to flush the pipeline and ensure there's no prerolled audio data.
   ASSERT_TRUE(Seek(base::TimeDelta()));
@@ -625,7 +625,7 @@ TEST_F(PipelineIntegrationTest, PlaybackWithAudioTrackDisabledThenEnabled) {
   std::vector<MediaTrack::Id> audio_track_id;
   audio_track_id.push_back("2");
   pipeline_->OnEnabledAudioTracksChanged(audio_track_id);
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
 
   // Restart playback from 500ms position.
   ASSERT_TRUE(Seek(k500ms));
@@ -641,7 +641,7 @@ TEST_F(PipelineIntegrationTest, PlaybackWithVideoTrackDisabledThenEnabled) {
 
   // Disable video.
   pipeline_->OnSelectedVideoTrackChanged(base::nullopt);
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
 
   // Seek to flush the pipeline and ensure there's no prerolled video data.
   ASSERT_TRUE(Seek(base::TimeDelta()));
@@ -660,7 +660,7 @@ TEST_F(PipelineIntegrationTest, PlaybackWithVideoTrackDisabledThenEnabled) {
 
   // Re-enable video.
   pipeline_->OnSelectedVideoTrackChanged(MediaTrack::Id("1"));
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
 
   // Seek to flush video pipeline and reset the video hash again to clear state
   // if some prerolled frames got hashed after enabling video.
@@ -1199,7 +1199,7 @@ TEST_F(PipelineIntegrationTest, MediaSource_Remove_Updates_BufferedRanges) {
 
   source.RemoveRange(base::TimeDelta::FromMilliseconds(1000),
                      base::TimeDelta::FromMilliseconds(k320WebMFileDurationMs));
-  base::RunLoop().RunUntilIdle();
+  scoped_task_environment_.RunUntilIdle();
 
   buffered_ranges = pipeline_->GetBufferedTimeRanges();
   EXPECT_EQ(1u, buffered_ranges.size());
@@ -1235,7 +1235,7 @@ TEST_F(PipelineIntegrationTest, MediaSource_FillUp_Buffer) {
     source.EvictCodedFrames(media_time, file->data_size());
     ASSERT_TRUE(
         source.AppendAtTime(media_time, file->data(), file->data_size()));
-    base::RunLoop().RunUntilIdle();
+    scoped_task_environment_.RunUntilIdle();
 
     buffered_ranges = pipeline_->GetBufferedTimeRanges();
   } while (buffered_ranges.size() == 1 &&

media/test/pipeline_integration_test_base.cc

@@ -10,6 +10,7 @@
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/media_log.h"
@@ -107,7 +108,9 @@ class RendererFactoryImpl final : public PipelineTestRendererFactory {
 PipelineIntegrationTestBase::PipelineIntegrationTestBase()
     : hashing_enabled_(false),
       clockless_playback_(false),
-      pipeline_(new PipelineImpl(message_loop_.task_runner(), &media_log_)),
+      pipeline_(
+          new PipelineImpl(scoped_task_environment_.GetMainThreadTaskRunner(),
+                           &media_log_)),
       ended_(false),
       pipeline_status_(PIPELINE_OK),
       last_video_frame_format_(PIXEL_FORMAT_UNKNOWN),
@@ -137,7 +140,7 @@ void PipelineIntegrationTestBase::OnSeeked(base::TimeDelta seek_time,
 
 void PipelineIntegrationTestBase::OnStatusCallback(PipelineStatus status) {
   pipeline_status_ = status;
-  message_loop_.task_runner()->PostTask(
+  scoped_task_environment_.GetMainThreadTaskRunner()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
@@ -166,29 +169,29 @@ void PipelineIntegrationTestBase::OnEnded() {
   DCHECK(!ended_);
   ended_ = true;
   pipeline_status_ = PIPELINE_OK;
-  message_loop_.task_runner()->PostTask(
+  scoped_task_environment_.GetMainThreadTaskRunner()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 bool PipelineIntegrationTestBase::WaitUntilOnEnded() {
-  if (ended_)
-    return (pipeline_status_ == PIPELINE_OK);
+  if (!ended_)
     base::RunLoop().Run();
   EXPECT_TRUE(ended_);
+  scoped_task_environment_.RunUntilIdle();
   return ended_ && (pipeline_status_ == PIPELINE_OK);
 }
 
 PipelineStatus PipelineIntegrationTestBase::WaitUntilEndedOrError() {
-  if (ended_ || pipeline_status_ != PIPELINE_OK)
-    return pipeline_status_;
+  if (!ended_ && pipeline_status_ == PIPELINE_OK)
     base::RunLoop().Run();
+  scoped_task_environment_.RunUntilIdle();
   return pipeline_status_;
 }
 
 void PipelineIntegrationTestBase::OnError(PipelineStatus status) {
   DCHECK_NE(status, PIPELINE_OK);
   pipeline_status_ = status;
-  message_loop_.task_runner()->PostTask(
+  scoped_task_environment_.GetMainThreadTaskRunner()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
@@ -253,6 +256,7 @@ PipelineStatus PipelineIntegrationTestBase::StartInternal(
                    base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
                               base::Unretained(this)));
   base::RunLoop().Run();
+  scoped_task_environment_.RunUntilIdle();
   return pipeline_status_;
 }
 
@@ -312,6 +316,7 @@ bool PipelineIntegrationTestBase::Seek(base::TimeDelta seek_time) {
   pipeline_->Seek(seek_time, base::Bind(&PipelineIntegrationTestBase::OnSeeked,
                                         base::Unretained(this), seek_time));
   run_loop.Run();
+  scoped_task_environment_.RunUntilIdle();
   EXPECT_CALL(*this, OnBufferingStateChange(_)).Times(AnyNumber());
   return (pipeline_status_ == PIPELINE_OK);
 }
@@ -320,6 +325,7 @@ bool PipelineIntegrationTestBase::Suspend() {
   pipeline_->Suspend(base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
                                 base::Unretained(this)));
   base::RunLoop().Run();
+  scoped_task_environment_.RunUntilIdle();
   return (pipeline_status_ == PIPELINE_OK);
 }
 
@@ -335,6 +341,7 @@ bool PipelineIntegrationTestBase::Resume(base::TimeDelta seek_time) {
                     base::Bind(&PipelineIntegrationTestBase::OnSeeked,
                                base::Unretained(this), seek_time));
   run_loop.Run();
+  scoped_task_environment_.RunUntilIdle();
   return (pipeline_status_ == PIPELINE_OK);
 }
 
@@ -358,7 +365,7 @@ void PipelineIntegrationTestBase::QuitAfterCurrentTimeTask(
     return;
   }
 
-  message_loop_.task_runner()->PostDelayedTask(
+  scoped_task_environment_.GetMainThreadTaskRunner()->PostDelayedTask(
       FROM_HERE,
       base::BindOnce(&PipelineIntegrationTestBase::QuitAfterCurrentTimeTask,
                      base::Unretained(this), quit_time,
@@ -373,13 +380,14 @@ bool PipelineIntegrationTestBase::WaitUntilCurrentTimeIsAfter(
   DCHECK(wait_time <= pipeline_->GetMediaDuration());
 
   base::RunLoop run_loop;
-  message_loop_.task_runner()->PostDelayedTask(
+  scoped_task_environment_.GetMainThreadTaskRunner()->PostDelayedTask(
       FROM_HERE,
       base::BindOnce(&PipelineIntegrationTestBase::QuitAfterCurrentTimeTask,
                      base::Unretained(this), wait_time,
                      run_loop.QuitWhenIdleClosure()),
       base::TimeDelta::FromMilliseconds(10));
   run_loop.Run();
+  scoped_task_environment_.RunUntilIdle();
   return (pipeline_status_ == PIPELINE_OK);
 }
 
@@ -388,9 +396,8 @@ void PipelineIntegrationTestBase::CreateDemuxer(
   data_source_ = std::move(data_source);
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
-  task_scheduler_.reset(new base::test::ScopedTaskScheduler(&message_loop_));
   demuxer_ = std::unique_ptr<Demuxer>(new FFmpegDemuxer(
-      message_loop_.task_runner(), data_source_.get(),
+      scoped_task_environment_.GetMainThreadTaskRunner(), data_source_.get(),
       base::Bind(&PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB,
                  base::Unretained(this)),
       base::Bind(&PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB,
@@ -407,18 +414,20 @@ std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer(
       clockless_playback_, base::TimeDelta::FromSecondsD(1.0 / 60),
       base::Bind(&PipelineIntegrationTestBase::OnVideoFramePaint,
                  base::Unretained(this)),
-      message_loop_.task_runner()));
+      scoped_task_environment_.GetMainThreadTaskRunner()));
 
   // Disable frame dropping if hashing is enabled.
   std::unique_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
-      message_loop_.task_runner(), message_loop_.task_runner().get(),
+      scoped_task_environment_.GetMainThreadTaskRunner(),
+      scoped_task_environment_.GetMainThreadTaskRunner().get(),
       video_sink_.get(),
       base::Bind(&CreateVideoDecodersForTest, &media_log_,
                  prepend_video_decoders_cb),
       false, nullptr, &media_log_));
 
   if (!clockless_playback_) {
-    audio_sink_ = new NullAudioSink(message_loop_.task_runner());
+    audio_sink_ =
+        new NullAudioSink(scoped_task_environment_.GetMainThreadTaskRunner());
   } else {
     clockless_audio_sink_ = new ClocklessAudioSink(OutputDeviceInfo(
         "", OUTPUT_DEVICE_STATUS_OK,
@@ -431,12 +440,13 @@ std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer(
   }
 
   std::unique_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
-      message_loop_.task_runner(),
+      scoped_task_environment_.GetMainThreadTaskRunner(),
       (clockless_playback_)
           ? static_cast<AudioRendererSink*>(clockless_audio_sink_.get())
           : audio_sink_.get(),
       base::Bind(&CreateAudioDecodersForTest, &media_log_,
-                 message_loop_.task_runner(), prepend_audio_decoders_cb),
+                 scoped_task_environment_.GetMainThreadTaskRunner(),
+                 prepend_audio_decoders_cb),
       &media_log_));
   if (hashing_enabled_) {
     if (clockless_playback_)
@@ -446,8 +456,8 @@ std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer(
   }
 
   std::unique_ptr<RendererImpl> renderer_impl(
-      new RendererImpl(message_loop_.task_runner(), std::move(audio_renderer),
-                       std::move(video_renderer)));
+      new RendererImpl(scoped_task_environment_.GetMainThreadTaskRunner(),
+                       std::move(audio_renderer), std::move(video_renderer)));
 
   // Prevent non-deterministic buffering state callbacks from firing (e.g., slow
   // machine, valgrind).
@@ -582,6 +592,7 @@ PipelineStatus PipelineIntegrationTestBase::StartPipelineWithMediaSource(
                    base::Unretained(encrypted_media)));
   }
   base::RunLoop().Run();
+  scoped_task_environment_.RunUntilIdle();
   return pipeline_status_;
 }
 

media/test/pipeline_integration_test_base.h

@@ -10,8 +10,7 @@
 
 #include "base/callback_forward.h"
 #include "base/md5.h"
-#include "base/message_loop/message_loop.h"
-#include "base/test/scoped_task_scheduler.h"
+#include "base/test/scoped_task_environment.h"
 #include "media/audio/clockless_audio_sink.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/demuxer.h"
@@ -143,13 +142,10 @@ class PipelineIntegrationTestBase : public Pipeline::Client {
 
  protected:
   MediaLog media_log_;
-  base::MessageLoop message_loop_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::MD5Context md5_context_;
   bool hashing_enabled_;
   bool clockless_playback_;
-
-  // TaskScheduler is used only for FFmpegDemuxer.
-  std::unique_ptr<base::test::ScopedTaskScheduler> task_scheduler_;
   std::unique_ptr<Demuxer> demuxer_;
   std::unique_ptr<DataSource> data_source_;
   std::unique_ptr<PipelineImpl> pipeline_;