Allow media track switching.

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 117 matching lines @@
   DCHECK_NE(status, PIPELINE_OK);
   pipeline_status_ = status;
   message_loop_.task_runner()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 PipelineStatus PipelineIntegrationTestBase::StartInternal(
     std::unique_ptr<DataSource> data_source,
     CdmContext* cdm_context,
     uint8_t test_type,
-    ScopedVector<VideoDecoder> prepend_video_decoders,
-    ScopedVector<AudioDecoder> prepend_audio_decoders) {
+    CreateVideoDecodersCB prepend_video_decoders_cb,
+    CreateAudioDecodersCB prepend_audio_decoders_cb) {
   hashing_enabled_ = test_type & kHashed;
   clockless_playback_ = test_type & kClockless;
 
   EXPECT_CALL(*this, OnMetadata(_))
       .Times(AtMost(1))
       .WillRepeatedly(SaveArg<0>(&metadata_));
   EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(AnyNumber());
   EXPECT_CALL(*this, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(AnyNumber());
@@ skipping 22 matching lines @@
     pipeline_->SetCdm(
         cdm_context, base::Bind(&PipelineIntegrationTestBase::DecryptorAttached,
                                 base::Unretained(this)));
   }
 
   // Should never be called as the required decryption keys for the encrypted
   // media files are provided in advance.
   EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
 
   pipeline_->Start(
-      demuxer_.get(), CreateRenderer(std::move(prepend_video_decoders),
-                                     std::move(prepend_audio_decoders)),
-      this, base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
-                       base::Unretained(this)));
+      demuxer_.get(),
+      CreateRenderer(prepend_video_decoders_cb, prepend_audio_decoders_cb),
+      this,
+      base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
+                 base::Unretained(this)));
   base::RunLoop().Run();
   return pipeline_status_;
 }
 
 PipelineStatus PipelineIntegrationTestBase::StartWithFile(
     const std::string& filename,
     CdmContext* cdm_context,
     uint8_t test_type,
-    ScopedVector<VideoDecoder> prepend_video_decoders,
-    ScopedVector<AudioDecoder> prepend_audio_decoders) {
+    CreateVideoDecodersCB prepend_video_decoders_cb,
+    CreateAudioDecodersCB prepend_audio_decoders_cb) {
   std::unique_ptr<FileDataSource> file_data_source(new FileDataSource());
   base::FilePath file_path(GetTestDataFilePath(filename));
   CHECK(file_data_source->Initialize(file_path)) << "Is " << file_path.value()
                                                  << " missing?";
   return StartInternal(std::move(file_data_source), cdm_context, test_type,
-                       std::move(prepend_video_decoders),
-                       std::move(prepend_audio_decoders));
+                       prepend_video_decoders_cb, prepend_audio_decoders_cb);
 }
 
 PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename) {
   return StartWithFile(filename, nullptr, kNormal);
 }
 
 PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename,
                                                   CdmContext* cdm_context) {
   return StartWithFile(filename, cdm_context, kNormal);
 }
 
 PipelineStatus PipelineIntegrationTestBase::Start(
     const std::string& filename,
     uint8_t test_type,
-    ScopedVector<VideoDecoder> prepend_video_decoders,
-    ScopedVector<AudioDecoder> prepend_audio_decoders) {
-  return StartWithFile(filename, nullptr, test_type,
-                       std::move(prepend_video_decoders),
-                       std::move(prepend_audio_decoders));
+    CreateVideoDecodersCB prepend_video_decoders_cb,
+    CreateAudioDecodersCB prepend_audio_decoders_cb) {
+  return StartWithFile(filename, nullptr, test_type, prepend_video_decoders_cb,
+                       prepend_audio_decoders_cb);
 }
 
 PipelineStatus PipelineIntegrationTestBase::Start(const uint8_t* data,
                                                   size_t size,
                                                   uint8_t test_type) {
   return StartInternal(base::MakeUnique<MemoryDataSource>(data, size), nullptr,
                        test_type);
 }
 
 void PipelineIntegrationTestBase::Play() {
@@ skipping 85 matching lines @@
   demuxer_ = std::unique_ptr<Demuxer>(new FFmpegDemuxer(
       message_loop_.task_runner(), data_source_.get(),
       base::Bind(&PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB,
                  base::Unretained(this)),
       base::Bind(&PipelineIntegrationTestBase::DemuxerMediaTracksUpdatedCB,
                  base::Unretained(this)),
       new MediaLog()));
 #endif
 }
 
-std::unique_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer(
-    ScopedVector<VideoDecoder> prepend_video_decoders,
-    ScopedVector<AudioDecoder> prepend_audio_decoders) {
-  ScopedVector<VideoDecoder> video_decoders = std::move(prepend_video_decoders);
+ScopedVector<VideoDecoder> CreateVideoDecodersForTest(
+    CreateVideoDecodersCB prepend_video_decoders_cb) {
+  ScopedVector<VideoDecoder> video_decoders;
+
+  if (!prepend_video_decoders_cb.is_null()) {
+    video_decoders = prepend_video_decoders_cb.Run();
+    DCHECK(!video_decoders.empty());
+  }
+
 #if !defined(MEDIA_DISABLE_LIBVPX)
   video_decoders.push_back(new VpxVideoDecoder());
 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
 
 // Android does not have an ffmpeg video decoder.
 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(OS_ANDROID)
   video_decoders.push_back(
       new FFmpegVideoDecoder(make_scoped_refptr(new MediaLog())));
 #endif
+  return video_decoders;
+}
 
+ScopedVector<AudioDecoder> CreateAudioDecodersForTest(
+    const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+    CreateAudioDecodersCB prepend_audio_decoders_cb) {
+  ScopedVector<AudioDecoder> audio_decoders;
+
+  if (!prepend_audio_decoders_cb.is_null()) {
+    audio_decoders = prepend_audio_decoders_cb.Run();
+    DCHECK(!audio_decoders.empty());
+  }
+
+#if !defined(MEDIA_DISABLE_FFMPEG)
+  audio_decoders.push_back(
+      new FFmpegAudioDecoder(media_task_runner, new MediaLog()));
+#endif
+  return audio_decoders;
+}
+
+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()));
 
   // 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(), std::move(video_decoders), false, nullptr,
-      new MediaLog()));
-
-  ScopedVector<AudioDecoder> audio_decoders = std::move(prepend_audio_decoders);
-
-#if !defined(MEDIA_DISABLE_FFMPEG)
-  audio_decoders.push_back(
-      new FFmpegAudioDecoder(message_loop_.task_runner(), new MediaLog()));
-#endif
+      video_sink_.get(),
+      base::Bind(&CreateVideoDecodersForTest, prepend_video_decoders_cb), false,
+      nullptr, new MediaLog()));
 
   if (!clockless_playback_) {
     audio_sink_ = new NullAudioSink(message_loop_.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(),
       (clockless_playback_)
           ? static_cast<AudioRendererSink*>(clockless_audio_sink_.get())
           : audio_sink_.get(),
-      std::move(audio_decoders), new MediaLog()));
+      base::Bind(&CreateAudioDecodersForTest, message_loop_.task_runner(),
+                 prepend_audio_decoders_cb),
+      new MediaLog()));
   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),
                        std::move(video_renderer)));
@@ skipping 57 matching lines @@
   DCHECK(clockless_playback_);
   return clockless_audio_sink_->render_time();
 }
 
 base::TimeTicks DummyTickClock::NowTicks() {
   now_ += base::TimeDelta::FromSeconds(60);
   return now_;
 }
 
 }  // namespace media