FFmpegDemuxer: Clear |extra_data| when enabling bitstream conversion.

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 112 matching lines @@
 void PipelineIntegrationTestBase::OnError(PipelineStatus status) {
   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) {
+    uint8_t test_type,
+    ScopedVector<VideoDecoder> prepend_video_decoders,
+    ScopedVector<AudioDecoder> prepend_audio_decoders) {
   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());
   EXPECT_CALL(*this, OnDurationChange()).Times(AtMost(1));
   EXPECT_CALL(*this, OnVideoNaturalSizeChange(_)).Times(AtMost(1));
   EXPECT_CALL(*this, OnVideoOpacityChange(_)).Times(AtMost(1));
   CreateDemuxer(std::move(data_source));
 
   if (cdm_context) {
     EXPECT_CALL(*this, DecryptorAttached(true));
     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(), this,
-                   base::Bind(&PipelineIntegrationTestBase::OnStatusCallback,
-                              base::Unretained(this)));
+  pipeline_->Start(
+      demuxer_.get(), CreateRenderer(std::move(prepend_video_decoders),
+                                     std::move(prepend_audio_decoders)),
+      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) {
+    uint8_t test_type,
+    ScopedVector<VideoDecoder> prepend_video_decoders,
+    ScopedVector<AudioDecoder> prepend_audio_decoders) {
   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);
+  return StartInternal(std::move(file_data_source), cdm_context, test_type,
+                       std::move(prepend_video_decoders),
+                       std::move(prepend_audio_decoders));
 }
 
 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) {
-  return StartWithFile(filename, nullptr, test_type);
+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));
 }
 
 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 84 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> video_decoders;
+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);
 #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());
 #endif
 
   // 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;
+  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
 
   audio_decoders.push_back(new OpusAudioDecoder(message_loop_.task_runner()));
 
   if (!clockless_playback_) {
     audio_sink_ = new NullAudioSink(message_loop_.task_runner());
@@ skipping 72 matching lines @@
   DCHECK(clockless_playback_);
   return clockless_audio_sink_->render_time();
 }
 
 base::TimeTicks DummyTickClock::NowTicks() {
   now_ += base::TimeDelta::FromSeconds(60);
   return now_;
 }
 
 }  // namespace media