Remove usage of ScopedTaskScheduler.

media/test/pipeline_integration_test_base.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 "media/test/pipeline_integration_test_base.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ skipping 88 matching lines @@
 
  private:
   PipelineIntegrationTestBase* integration_test_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererFactoryImpl);
 };
 
 PipelineIntegrationTestBase::PipelineIntegrationTestBase()
     : hashing_enabled_(false),
       clockless_playback_(false),
-      pipeline_(new PipelineImpl(message_loop_.task_runner(), &media_log_)),
+      pipeline_(new PipelineImpl(main_thread_task_runner_, &media_log_)),
       ended_(false),
       pipeline_status_(PIPELINE_OK),
       last_video_frame_format_(PIXEL_FORMAT_UNKNOWN),
       last_video_frame_color_space_(COLOR_SPACE_UNSPECIFIED),
       current_duration_(kInfiniteDuration),
       renderer_factory_(new RendererFactoryImpl(this)) {
   ResetVideoHash();
   EXPECT_CALL(*this, OnVideoAverageKeyframeDistanceUpdate()).Times(AnyNumber());
 }
 
 PipelineIntegrationTestBase::~PipelineIntegrationTestBase() {
   if (pipeline_->IsRunning())
     Stop();
 
   demuxer_.reset();
   pipeline_.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 // TODO(xhwang): Method definitions in this file needs to be reordered.
 
 void PipelineIntegrationTestBase::OnSeeked(base::TimeDelta seek_time,
                                            PipelineStatus status) {
   EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   pipeline_status_ = status;
 }
 
 void PipelineIntegrationTestBase::OnStatusCallback(PipelineStatus status) {
   pipeline_status_ = status;
-  message_loop_.task_runner()->PostTask(
-      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  main_thread_task_runner_->PostTask(FROM_HERE,
+                                     base::MessageLoop::QuitWhenIdleClosure());
 }
 
 void PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB(
     EmeInitDataType type,
     const std::vector<uint8_t>& init_data) {
   DCHECK(!init_data.empty());
   CHECK(!encrypted_media_init_data_cb_.is_null());
   encrypted_media_init_data_cb_.Run(type, init_data);
 }
 
 void PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB(
     std::unique_ptr<MediaTracks> tracks) {
   CHECK(tracks);
   CHECK_GT(tracks->tracks().size(), 0u);
 
   // Verify that track ids are unique.
   std::set<MediaTrack::Id> track_ids;
   for (const auto& track : tracks->tracks()) {
     EXPECT_EQ(track_ids.end(), track_ids.find(track->id()));
     track_ids.insert(track->id());
   }
 }
 
 void PipelineIntegrationTestBase::OnEnded() {
   DCHECK(!ended_);
   ended_ = true;
   pipeline_status_ = PIPELINE_OK;
-  message_loop_.task_runner()->PostTask(
-      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  main_thread_task_runner_->PostTask(FROM_HERE,
+                                     base::MessageLoop::QuitWhenIdleClosure());
 }
 
 bool PipelineIntegrationTestBase::WaitUntilOnEnded() {
   if (ended_)
     return (pipeline_status_ == PIPELINE_OK);
   base::RunLoop().Run();
   EXPECT_TRUE(ended_);
   return ended_ && (pipeline_status_ == PIPELINE_OK);
 }
 
 PipelineStatus PipelineIntegrationTestBase::WaitUntilEndedOrError() {
   if (ended_ || pipeline_status_ != PIPELINE_OK)
     return pipeline_status_;
   base::RunLoop().Run();
   return pipeline_status_;
 }
 
 void PipelineIntegrationTestBase::OnError(PipelineStatus status) {
   DCHECK_NE(status, PIPELINE_OK);
   pipeline_status_ = status;
-  message_loop_.task_runner()->PostTask(
-      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+  main_thread_task_runner_->PostTask(FROM_HERE,
+                                     base::MessageLoop::QuitWhenIdleClosure());
 }
 
 PipelineStatus PipelineIntegrationTestBase::StartInternal(
     std::unique_ptr<DataSource> data_source,
     CdmContext* cdm_context,
     uint8_t test_type,
     CreateVideoDecodersCB prepend_video_decoders_cb,
     CreateAudioDecodersCB prepend_audio_decoders_cb) {
   hashing_enabled_ = test_type & kHashed;
   clockless_playback_ = test_type & kClockless;
@@ skipping 89 matching lines @@
   pipeline_->SetPlaybackRate(1);
 }
 
 void PipelineIntegrationTestBase::Pause() {
   pipeline_->SetPlaybackRate(0);
 }
 
 bool PipelineIntegrationTestBase::Seek(base::TimeDelta seek_time) {
   ended_ = false;
 
+  base::RunLoop run_loop;
   EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
-      .WillOnce(InvokeWithoutArgs(&message_loop_, &base::MessageLoop::QuitNow));
+      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   pipeline_->Seek(seek_time, base::Bind(&PipelineIntegrationTestBase::OnSeeked,
                                         base::Unretained(this), seek_time));
-  base::RunLoop().Run();
+  run_loop.Run();
   EXPECT_CALL(*this, OnBufferingStateChange(_)).Times(AnyNumber());
   return (pipeline_status_ == PIPELINE_OK);
 }
 
 bool PipelineIntegrationTestBase::Suspend() {
   pipeline_->Suspend(base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
                                 base::Unretained(this)));
   base::RunLoop().Run();
   return (pipeline_status_ == PIPELINE_OK);
 }
 
 bool PipelineIntegrationTestBase::Resume(base::TimeDelta seek_time) {
   ended_ = false;
 
+  base::RunLoop run_loop;
   EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
-      .WillOnce(InvokeWithoutArgs(&message_loop_, &base::MessageLoop::QuitNow));
+      .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   pipeline_->Resume(renderer_factory_->CreateRenderer(CreateVideoDecodersCB(),
                                                       CreateAudioDecodersCB()),
                     seek_time,
                     base::Bind(&PipelineIntegrationTestBase::OnSeeked,
                                base::Unretained(this), seek_time));
-  base::RunLoop().Run();
+  run_loop.Run();
   return (pipeline_status_ == PIPELINE_OK);
 }
 
 void PipelineIntegrationTestBase::Stop() {
   DCHECK(pipeline_->IsRunning());
   pipeline_->Stop();
   base::RunLoop().RunUntilIdle();
 }
 
 void PipelineIntegrationTestBase::FailTest(PipelineStatus status) {
   DCHECK_NE(PIPELINE_OK, status);
   OnError(status);
 }
 
 void PipelineIntegrationTestBase::QuitAfterCurrentTimeTask(
     const base::TimeDelta& quit_time) {
   if (pipeline_->GetMediaTime() >= quit_time ||
       pipeline_status_ != PIPELINE_OK) {
-    message_loop_.QuitWhenIdle();
+    base::MessageLoop::current()->QuitWhenIdle();
     return;
   }
 
-  message_loop_.task_runner()->PostDelayedTask(
+  main_thread_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&PipelineIntegrationTestBase::QuitAfterCurrentTimeTask,
                  base::Unretained(this), quit_time),
       base::TimeDelta::FromMilliseconds(10));
 }
 
 bool PipelineIntegrationTestBase::WaitUntilCurrentTimeIsAfter(
     const base::TimeDelta& wait_time) {
   DCHECK(pipeline_->IsRunning());
   DCHECK_GT(pipeline_->GetPlaybackRate(), 0);
   DCHECK(wait_time <= pipeline_->GetMediaDuration());
 
-  message_loop_.task_runner()->PostDelayedTask(
+  main_thread_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&PipelineIntegrationTestBase::QuitAfterCurrentTimeTask,
                  base::Unretained(this), wait_time),
       base::TimeDelta::FromMilliseconds(10));
   base::RunLoop().Run();
   return (pipeline_status_ == PIPELINE_OK);
 }
 
 void PipelineIntegrationTestBase::CreateDemuxer(
     std::unique_ptr<DataSource> data_source) {
   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(),
+      main_thread_task_runner_, data_source_.get(),
       base::Bind(&PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB,
                  base::Unretained(this)),
       base::Bind(&PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB,
                  base::Unretained(this)),
       &media_log_));
 #endif
 }
 
 std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer(
     CreateVideoDecodersCB prepend_video_decoders_cb,
     CreateAudioDecodersCB prepend_audio_decoders_cb) {
   // Simulate a 60Hz rendering sink.
   video_sink_.reset(new NullVideoSink(
       clockless_playback_, base::TimeDelta::FromSecondsD(1.0 / 60),
       base::Bind(&PipelineIntegrationTestBase::OnVideoFramePaint,
                  base::Unretained(this)),
-      message_loop_.task_runner()));
+      main_thread_task_runner_));
 
   // Disable frame dropping if hashing is enabled.
-  std::unique_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
-      message_loop_.task_runner(), message_loop_.task_runner().get(),
-      video_sink_.get(),
-      base::Bind(&CreateVideoDecodersForTest, &media_log_,
-                 prepend_video_decoders_cb),
-      false, nullptr, &media_log_));
+  std::unique_ptr<VideoRenderer> video_renderer(
+      new VideoRendererImpl(main_thread_task_runner_,
+                            main_thread_task_runner_.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(main_thread_task_runner_);
   } else {
     clockless_audio_sink_ = new ClocklessAudioSink(OutputDeviceInfo(
         "", OUTPUT_DEVICE_STATUS_OK,
         // Don't allow the audio renderer to resample buffers if hashing is
         // enabled:
         hashing_enabled_
             ? AudioParameters()
             : AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
                               CHANNEL_LAYOUT_STEREO, 44100, 16, 512)));
   }
 
   std::unique_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
-      message_loop_.task_runner(),
+      main_thread_task_runner_,
       (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),
+                 main_thread_task_runner_, prepend_audio_decoders_cb),
       &media_log_));
   if (hashing_enabled_) {
     if (clockless_playback_)
       clockless_audio_sink_->StartAudioHashForTesting();
     else
       audio_sink_->StartAudioHashForTesting();
   }
 
   std::unique_ptr<RendererImpl> renderer_impl(
-      new RendererImpl(message_loop_.task_runner(), std::move(audio_renderer),
+      new RendererImpl(main_thread_task_runner_, std::move(audio_renderer),
                        std::move(video_renderer)));
 
   // Prevent non-deterministic buffering state callbacks from firing (e.g., slow
   // machine, valgrind).
   renderer_impl->DisableUnderflowForTesting();
 
   if (clockless_playback_)
     renderer_impl->EnableClocklessVideoPlaybackForTesting();
 
   return std::move(renderer_impl);
@@ skipping 115 matching lines @@
   base::RunLoop().Run();
   return pipeline_status_;
 }
 
 base::TimeTicks DummyTickClock::NowTicks() {
   now_ += base::TimeDelta::FromSeconds(60);
   return now_;
 }
 
 }  // namespace media