MockDemuxerStream keeps audio/video decoder configs.

TEST=media_unittests pass.

Review URL: https://chromiumcodereview.appspot.com/13936006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@196281 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 88 insertions, 143 deletions

diff --git a/media/filters/audio_decoder_selector_unittest.cc b/media/filters/audio_decoder_selector_unittest.cc
index ce65ce9..b509bcd 100644
--- a/media/filters/audio_decoder_selector_unittest.cc
+++ b/media/filters/audio_decoder_selector_unittest.cc
@@ -16,7 +16,6 @@ using ::testing::IsNull;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
-using ::testing::ReturnRef;
 using ::testing::StrictMock;
 
 namespace media {
@@ -30,21 +29,13 @@ class AudioDecoderSelectorTest : public ::testing::Test {
   };
 
   AudioDecoderSelectorTest()
-      : clear_audio_config_(
-            kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
-            NULL, 0, false),
-        encrypted_audio_config_(
-            kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
-            NULL, 0, true),
-        demuxer_stream_(new StrictMock<MockDemuxerStream>()),
+      : demuxer_stream_(
+            new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)),
         decryptor_(new NiceMock<MockDecryptor>()),
         decoder_1_(new StrictMock<MockAudioDecoder>()),
         decoder_2_(new StrictMock<MockAudioDecoder>()) {
     all_decoders_.push_back(decoder_1_);
     all_decoders_.push_back(decoder_2_);
-
-    EXPECT_CALL(*demuxer_stream_, type())
-        .WillRepeatedly(Return(DemuxerStream::AUDIO));
   }
 
   MOCK_METHOD1(OnStatistics, void(const PipelineStatistics&));
@@ -60,13 +51,17 @@ class AudioDecoderSelectorTest : public ::testing::Test {
   }
 
   void UseClearStream() {
-    EXPECT_CALL(*demuxer_stream_, audio_decoder_config())
-        .WillRepeatedly(ReturnRef(clear_audio_config_));
+    AudioDecoderConfig clear_audio_config(
+        kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
+        NULL, 0, false);
+    demuxer_stream_->set_audio_decoder_config(clear_audio_config);
   }
 
   void UseEncryptedStream() {
-    EXPECT_CALL(*demuxer_stream_, audio_decoder_config())
-        .WillRepeatedly(ReturnRef(encrypted_audio_config_));
+    AudioDecoderConfig encrypted_audio_config(
+        kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
+        NULL, 0, true);
+    demuxer_stream_->set_audio_decoder_config(encrypted_audio_config);
   }
 
   void InitializeDecoderSelector(DecryptorCapability decryptor_capability,
@@ -112,8 +107,6 @@ class AudioDecoderSelectorTest : public ::testing::Test {
 
   // Fixture members.
   scoped_ptr<AudioDecoderSelector> decoder_selector_;
-  AudioDecoderConfig clear_audio_config_;
-  AudioDecoderConfig encrypted_audio_config_;
   scoped_refptr<StrictMock<MockDemuxerStream> > demuxer_stream_;
   // Use NiceMock since we don't care about most of calls on the decryptor, e.g.
   // RegisterNewKeyCB().
diff --git a/media/filters/audio_renderer_impl_unittest.cc b/media/filters/audio_renderer_impl_unittest.cc
index 2a3fef1..23e829c4 100644
--- a/media/filters/audio_renderer_impl_unittest.cc
+++ b/media/filters/audio_renderer_impl_unittest.cc
@@ -24,7 +24,6 @@ using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Invoke;
 using ::testing::Return;
-using ::testing::ReturnRef;
 using ::testing::NiceMock;
 using ::testing::StrictMock;
 
@@ -39,26 +38,24 @@ class AudioRendererImplTest : public ::testing::Test {
  public:
   // Give the decoder some non-garbage media properties.
   AudioRendererImplTest()
-      : demuxer_stream_(new MockDemuxerStream()),
-        decoder_(new MockAudioDecoder()),
-        audio_config_(kCodecVorbis, kSampleFormatPlanarF32,
-                      CHANNEL_LAYOUT_STEREO, 44100, NULL, 0, false) {
-    EXPECT_CALL(*demuxer_stream_, type())
-        .WillRepeatedly(Return(DemuxerStream::AUDIO));
-    EXPECT_CALL(*demuxer_stream_, audio_decoder_config())
-        .WillRepeatedly(ReturnRef(audio_config_));
+      : demuxer_stream_(new MockDemuxerStream(DemuxerStream::AUDIO)),
+        decoder_(new MockAudioDecoder()) {
+    AudioDecoderConfig audio_config(kCodecVorbis, kSampleFormatPlanarF32,
+        CHANNEL_LAYOUT_STEREO, 44100, NULL, 0, false);
+    demuxer_stream_->set_audio_decoder_config(audio_config);
 
     // Used to save callbacks and run them at a later time.
     EXPECT_CALL(*decoder_, Read(_))
         .WillRepeatedly(Invoke(this, &AudioRendererImplTest::ReadDecoder));
 
     // Set up audio properties.
+    const AudioDecoderConfig& config = demuxer_stream_->audio_decoder_config();
     EXPECT_CALL(*decoder_, bits_per_channel())
-        .WillRepeatedly(Return(audio_config_.bits_per_channel()));
+        .WillRepeatedly(Return(config.bits_per_channel()));
     EXPECT_CALL(*decoder_, channel_layout())
         .WillRepeatedly(Return(CHANNEL_LAYOUT_MONO));
     EXPECT_CALL(*decoder_, samples_per_second())
-        .WillRepeatedly(Return(audio_config_.samples_per_second()));
+        .WillRepeatedly(Return(config.samples_per_second()));
 
     ScopedVector<AudioDecoder> decoders;
     decoders.push_back(decoder_);
@@ -376,7 +373,6 @@ class AudioRendererImplTest : public ::testing::Test {
   // Used for satisfying reads.
   AudioDecoder::ReadCB read_cb_;
   scoped_ptr<AudioTimestampHelper> next_timestamp_;
-  AudioDecoderConfig audio_config_;
 
   WaitableMessageLoopEvent ended_event_;
 
diff --git a/media/filters/decrypting_audio_decoder_unittest.cc b/media/filters/decrypting_audio_decoder_unittest.cc
index dccf419..af0e81e 100644
--- a/media/filters/decrypting_audio_decoder_unittest.cc
+++ b/media/filters/decrypting_audio_decoder_unittest.cc
@@ -21,7 +21,6 @@
 using ::testing::_;
 using ::testing::AtMost;
 using ::testing::IsNull;
-using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
@@ -78,7 +77,7 @@ class DecryptingAudioDecoderTest : public testing::Test {
                 &DecryptingAudioDecoderTest::RequestDecryptorNotification,
                 base::Unretained(this)))),
         decryptor_(new StrictMock<MockDecryptor>()),
-        demuxer_(new StrictMock<MockDemuxerStream>()),
+        demuxer_(new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)),
         encrypted_buffer_(CreateFakeEncryptedBuffer()),
         decoded_frame_(NULL),
         end_of_stream_frame_(DataBuffer::CreateEOSBuffer()),
@@ -92,9 +91,7 @@ class DecryptingAudioDecoderTest : public testing::Test {
 
   void InitializeAndExpectStatus(const AudioDecoderConfig& config,
                                  PipelineStatus status) {
-    EXPECT_CALL(*demuxer_, audio_decoder_config())
-        .WillRepeatedly(ReturnRef(config));
-
+    demuxer_->set_audio_decoder_config(config);
     decoder_->Initialize(demuxer_, NewExpectedStatusCB(status),
                          base::Bind(&MockStatisticsCB::OnStatistics,
                                     base::Unretained(&statistics_cb_)));
@@ -363,8 +360,7 @@ TEST_F(DecryptingAudioDecoderTest, DemuxerRead_ConfigChange) {
   EXPECT_NE(new_config.channel_layout(), config_.channel_layout());
   EXPECT_NE(new_config.samples_per_second(), config_.samples_per_second());
 
-  EXPECT_CALL(*demuxer_, audio_decoder_config())
-      .WillRepeatedly(ReturnRef(new_config));
+  demuxer_->set_audio_decoder_config(new_config);
   EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kAudio));
   EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _))
       .WillOnce(RunCallback<1>(true));
@@ -492,8 +488,7 @@ TEST_F(DecryptingAudioDecoderTest, Reset_DuringDemuxerRead_ConfigChange) {
 
   // Even during pending reset, the decoder still needs to be initialized with
   // the new config.
-  EXPECT_CALL(*demuxer_, audio_decoder_config())
-      .WillRepeatedly(ReturnRef(new_config));
+  demuxer_->set_audio_decoder_config(new_config);
   EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kAudio));
   EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _))
       .WillOnce(RunCallback<1>(true));
diff --git a/media/filters/decrypting_demuxer_stream_unittest.cc b/media/filters/decrypting_demuxer_stream_unittest.cc
index 3a06f1d..4a73172 100644
--- a/media/filters/decrypting_demuxer_stream_unittest.cc
+++ b/media/filters/decrypting_demuxer_stream_unittest.cc
@@ -19,7 +19,6 @@
 using ::testing::_;
 using ::testing::IsNull;
 using ::testing::Return;
-using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
@@ -77,19 +76,17 @@ class DecryptingDemuxerStreamTest : public testing::Test {
                 &DecryptingDemuxerStreamTest::RequestDecryptorNotification,
                 base::Unretained(this)))),
         decryptor_(new StrictMock<MockDecryptor>()),
-        input_audio_stream_(new StrictMock<MockDemuxerStream>()),
-        input_video_stream_(new StrictMock<MockDemuxerStream>()),
+        input_audio_stream_(
+            new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)),
+        input_video_stream_(
+            new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
         encrypted_buffer_(CreateFakeEncryptedBuffer()),
         decrypted_buffer_(new DecoderBuffer(kFakeBufferSize)) {
   }
 
   void InitializeAudioAndExpectStatus(const AudioDecoderConfig& config,
                                       PipelineStatus status) {
-    EXPECT_CALL(*input_audio_stream_, audio_decoder_config())
-        .WillRepeatedly(ReturnRef(config));
-    EXPECT_CALL(*input_audio_stream_, type())
-        .WillRepeatedly(Return(DemuxerStream::AUDIO));
-
+    input_audio_stream_->set_audio_decoder_config(config);
     demuxer_stream_->Initialize(input_audio_stream_,
                                 NewExpectedStatusCB(status));
     message_loop_.RunUntilIdle();
@@ -97,11 +94,7 @@ class DecryptingDemuxerStreamTest : public testing::Test {
 
   void InitializeVideoAndExpectStatus(const VideoDecoderConfig& config,
                                       PipelineStatus status) {
-    EXPECT_CALL(*input_video_stream_, video_decoder_config())
-        .WillRepeatedly(ReturnRef(config));
-    EXPECT_CALL(*input_video_stream_, type())
-        .WillRepeatedly(Return(DemuxerStream::VIDEO));
-
+    input_video_stream_->set_video_decoder_config(config);
     demuxer_stream_->Initialize(input_video_stream_,
                                 NewExpectedStatusCB(status));
     message_loop_.RunUntilIdle();
@@ -416,9 +409,7 @@ TEST_F(DecryptingDemuxerStreamTest, DemuxerRead_ConfigChanged) {
   AudioDecoderConfig new_config(
       kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 88200, NULL,
       0, true);
-
-  EXPECT_CALL(*input_audio_stream_, audio_decoder_config())
-      .WillRepeatedly(ReturnRef(new_config));
+  input_audio_stream_->set_audio_decoder_config(new_config);
 
   EXPECT_CALL(*input_audio_stream_, Read(_))
       .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
diff --git a/media/filters/decrypting_video_decoder_unittest.cc b/media/filters/decrypting_video_decoder_unittest.cc
index db51ff2..a31404b 100644
--- a/media/filters/decrypting_video_decoder_unittest.cc
+++ b/media/filters/decrypting_video_decoder_unittest.cc
@@ -78,7 +78,7 @@ class DecryptingVideoDecoderTest : public testing::Test {
                 &DecryptingVideoDecoderTest::RequestDecryptorNotification,
                 base::Unretained(this)))),
         decryptor_(new StrictMock<MockDecryptor>()),
-        demuxer_(new StrictMock<MockDemuxerStream>()),
+        demuxer_(new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
         encrypted_buffer_(CreateFakeEncryptedBuffer()),
         decoded_video_frame_(VideoFrame::CreateBlackFrame(kCodedSize)),
         null_video_frame_(scoped_refptr<VideoFrame>()),
@@ -91,8 +91,7 @@ class DecryptingVideoDecoderTest : public testing::Test {
 
   void InitializeAndExpectStatus(const VideoDecoderConfig& config,
                                  PipelineStatus status) {
-    EXPECT_CALL(*demuxer_, video_decoder_config())
-        .WillRepeatedly(ReturnRef(config));
+    demuxer_->set_video_decoder_config(config);
     EXPECT_CALL(*this, RequestDecryptorNotification(_))
         .WillOnce(RunCallbackIfNotNull(decryptor_.get()));
 
@@ -109,11 +108,11 @@ class DecryptingVideoDecoderTest : public testing::Test {
     EXPECT_CALL(*decryptor_, RegisterNewKeyCB(Decryptor::kVideo, _))
         .WillOnce(SaveArg<1>(&key_added_cb_));
 
-    config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
-                       kCodedSize, kVisibleRect, kNaturalSize,
-                       NULL, 0, true, true);
-
-    InitializeAndExpectStatus(config_, PIPELINE_OK);
+    VideoDecoderConfig config(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
+                              kVideoFormat,
+                              kCodedSize, kVisibleRect, kNaturalSize,
+                              NULL, 0, true);
+    InitializeAndExpectStatus(config, PIPELINE_OK);
   }
 
   void ReadAndExpectFrameReadyWith(
@@ -239,7 +238,6 @@ class DecryptingVideoDecoderTest : public testing::Test {
   scoped_ptr<StrictMock<MockDecryptor> > decryptor_;
   scoped_refptr<StrictMock<MockDemuxerStream> > demuxer_;
   MockStatisticsCB statistics_cb_;
-  VideoDecoderConfig config_;
 
   DemuxerStream::ReadCB pending_demuxer_read_cb_;
   Decryptor::DecoderInitCB pending_init_cb_;
@@ -565,11 +563,12 @@ TEST_F(DecryptingVideoDecoderTest, Reset_AfterReset) {
 
 // Test stopping when the decoder is in kDecryptorRequested state.
 TEST_F(DecryptingVideoDecoderTest, Stop_DuringDecryptorRequested) {
-  config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
-                     kCodedSize, kVisibleRect, kNaturalSize,
-                     NULL, 0, true, true);
-  EXPECT_CALL(*demuxer_, video_decoder_config())
-      .WillRepeatedly(ReturnRef(config_));
+  VideoDecoderConfig config(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
+                            kVideoFormat,
+                            kCodedSize, kVisibleRect, kNaturalSize,
+                            NULL, 0, true);
+  demuxer_->set_video_decoder_config(config);
+
   DecryptorReadyCB decryptor_ready_cb;
   EXPECT_CALL(*this, RequestDecryptorNotification(_))
       .WillOnce(SaveArg<0>(&decryptor_ready_cb));
@@ -594,10 +593,11 @@ TEST_F(DecryptingVideoDecoderTest, Stop_DuringPendingDecoderInit) {
   EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
       .WillOnce(SaveArg<1>(&pending_init_cb_));
 
-  config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
-                     kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, true,
-                     true);
-  InitializeAndExpectStatus(config_, DECODER_ERROR_NOT_SUPPORTED);
+  VideoDecoderConfig config(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
+                            kVideoFormat,
+                            kCodedSize, kVisibleRect, kNaturalSize,
+                            NULL, 0, true);
+  InitializeAndExpectStatus(config, DECODER_ERROR_NOT_SUPPORTED);
   EXPECT_FALSE(pending_init_cb_.is_null());
 
   Stop();
diff --git a/media/filters/ffmpeg_audio_decoder_unittest.cc b/media/filters/ffmpeg_audio_decoder_unittest.cc
index 6a9aecd..4ffbcb7 100644
--- a/media/filters/ffmpeg_audio_decoder_unittest.cc
+++ b/media/filters/ffmpeg_audio_decoder_unittest.cc
@@ -18,7 +18,6 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
-using ::testing::ReturnRef;
 using ::testing::StrictMock;
 
 namespace media {
@@ -31,7 +30,7 @@ class FFmpegAudioDecoderTest : public testing::Test {
  public:
   FFmpegAudioDecoderTest()
       : decoder_(new FFmpegAudioDecoder(message_loop_.message_loop_proxy())),
-        demuxer_(new StrictMock<MockDemuxerStream>()) {
+        demuxer_(new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)) {
     FFmpegGlue::InitializeFFmpeg();
 
     vorbis_extradata_ = ReadTestDataFile("vorbis-extradata");
@@ -53,23 +52,19 @@ class FFmpegAudioDecoderTest : public testing::Test {
 
     // Push in an EOS buffer.
     encoded_audio_.push_back(DecoderBuffer::CreateEOSBuffer());
-
-    config_.Initialize(kCodecVorbis,
-                       kSampleFormatPlanarF32,
-                       CHANNEL_LAYOUT_STEREO,
-                       44100,
-                       vorbis_extradata_->GetData(),
-                       vorbis_extradata_->GetDataSize(),
-                       false,  // Not encrypted.
-                       true);
   }
 
   virtual ~FFmpegAudioDecoderTest() {}
 
   void Initialize() {
-    EXPECT_CALL(*demuxer_, audio_decoder_config())
-        .WillRepeatedly(ReturnRef(config_));
-
+    AudioDecoderConfig config(kCodecVorbis,
+                              kSampleFormatPlanarF32,
+                              CHANNEL_LAYOUT_STEREO,
+                              44100,
+                              vorbis_extradata_->GetData(),
+                              vorbis_extradata_->GetDataSize(),
+                              false);  // Not encrypted.
+    demuxer_->set_audio_decoder_config(config);
     decoder_->Initialize(demuxer_,
                          NewExpectedStatusCB(PIPELINE_OK),
                          base::Bind(&MockStatisticsCB::OnStatistics,
@@ -120,16 +115,15 @@ class FFmpegAudioDecoderTest : public testing::Test {
 
   std::deque<scoped_refptr<DecoderBuffer> > encoded_audio_;
   std::deque<scoped_refptr<DataBuffer> > decoded_audio_;
-
-  AudioDecoderConfig config_;
 };
 
 TEST_F(FFmpegAudioDecoderTest, Initialize) {
   Initialize();
 
-  EXPECT_EQ(config_.bits_per_channel(), decoder_->bits_per_channel());
-  EXPECT_EQ(config_.channel_layout(), decoder_->channel_layout());
-  EXPECT_EQ(config_.samples_per_second(), decoder_->samples_per_second());
+  const AudioDecoderConfig& config = demuxer_->audio_decoder_config();
+  EXPECT_EQ(config.bits_per_channel(), decoder_->bits_per_channel());
+  EXPECT_EQ(config.channel_layout(), decoder_->channel_layout());
+  EXPECT_EQ(config.samples_per_second(), decoder_->samples_per_second());
 }
 
 TEST_F(FFmpegAudioDecoderTest, ProduceAudioSamples) {
diff --git a/media/filters/ffmpeg_video_decoder_unittest.cc b/media/filters/ffmpeg_video_decoder_unittest.cc
index 1dbb14c..675027c6 100644
--- a/media/filters/ffmpeg_video_decoder_unittest.cc
+++ b/media/filters/ffmpeg_video_decoder_unittest.cc
@@ -28,7 +28,6 @@ using ::testing::AtLeast;
 using ::testing::InSequence;
 using ::testing::IsNull;
 using ::testing::Return;
-using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
@@ -51,7 +50,7 @@ class FFmpegVideoDecoderTest : public testing::Test {
  public:
   FFmpegVideoDecoderTest()
       : decoder_(new FFmpegVideoDecoder(message_loop_.message_loop_proxy())),
-        demuxer_(new StrictMock<MockDemuxerStream>()),
+        demuxer_(new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
         read_cb_(base::Bind(&FFmpegVideoDecoderTest::FrameReady,
                             base::Unretained(this))) {
     FFmpegGlue::InitializeFFmpeg();
@@ -83,9 +82,7 @@ class FFmpegVideoDecoderTest : public testing::Test {
 
   void InitializeWithConfigAndStatus(const VideoDecoderConfig& config,
                                      PipelineStatus status) {
-    EXPECT_CALL(*demuxer_, video_decoder_config())
-        .WillRepeatedly(ReturnRef(config));
-
+    demuxer_->set_video_decoder_config(config);
     decoder_->Initialize(demuxer_, NewExpectedStatusCB(status),
                          base::Bind(&MockStatisticsCB::OnStatistics,
                                     base::Unretained(&statistics_cb_)));
@@ -547,8 +544,7 @@ TEST_F(FFmpegVideoDecoderTest, DemuxerRead_ConfigChange) {
   VideoDecoderConfig new_config(
       kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
       kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, false);
-  EXPECT_CALL(*demuxer_, video_decoder_config())
-      .WillRepeatedly(ReturnRef(new_config));
+  demuxer_->set_video_decoder_config(new_config);
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
                                scoped_refptr<DecoderBuffer>()))
@@ -574,8 +570,7 @@ TEST_F(FFmpegVideoDecoderTest, DemuxerRead_ConfigChangeFailed) {
   VideoDecoderConfig invalid_config(
       kUnknownVideoCodec, VIDEO_CODEC_PROFILE_UNKNOWN, VideoFrame::INVALID,
       kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, false);
-  EXPECT_CALL(*demuxer_, video_decoder_config())
-      .WillRepeatedly(ReturnRef(invalid_config));
+  demuxer_->set_video_decoder_config(invalid_config);
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
                                scoped_refptr<DecoderBuffer>()));
@@ -612,9 +607,7 @@ TEST_F(FFmpegVideoDecoderTest, DemuxerRead_ConfigChangeDuringReset) {
   VideoDecoderConfig new_config(
       kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
       kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, false);
-  EXPECT_CALL(*demuxer_, video_decoder_config())
-      .Times(AtLeast(1))
-      .WillRepeatedly(ReturnRef(new_config));
+  demuxer_->set_video_decoder_config(new_config);
   EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
 
   // Signal a config change.
@@ -656,9 +649,7 @@ TEST_F(FFmpegVideoDecoderTest, DemuxerRead_ConfigChangeFailedDuringReset) {
   VideoDecoderConfig invalid_config(
       kUnknownVideoCodec, VIDEO_CODEC_PROFILE_UNKNOWN, VideoFrame::INVALID,
       kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, false);
-  EXPECT_CALL(*demuxer_, video_decoder_config())
-      .Times(AtLeast(1))
-      .WillRepeatedly(ReturnRef(invalid_config));
+  demuxer_->set_video_decoder_config(invalid_config);
   EXPECT_CALL(*this, FrameReady(VideoDecoder::kDecodeError, IsNull()));
 
   // Signal a config change.
diff --git a/media/filters/video_decoder_selector_unittest.cc b/media/filters/video_decoder_selector_unittest.cc
index a2f1544..65ad8f3 100644
--- a/media/filters/video_decoder_selector_unittest.cc
+++ b/media/filters/video_decoder_selector_unittest.cc
@@ -17,7 +17,6 @@ using ::testing::IsNull;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
-using ::testing::ReturnRef;
 using ::testing::StrictMock;
 
 namespace media {
@@ -36,22 +35,14 @@ class VideoDecoderSelectorTest : public ::testing::Test {
   };
 
   VideoDecoderSelectorTest()
-      : clear_video_config_(
-            kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
-            kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, false),
-        encrypted_video_config_(
-            kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
-            kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, true),
-        demuxer_stream_(new StrictMock<MockDemuxerStream>()),
+      : demuxer_stream_(
+            new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
         decryptor_(new NiceMock<MockDecryptor>()),
         decoder_1_(new StrictMock<MockVideoDecoder>()),
         decoder_2_(new StrictMock<MockVideoDecoder>()) {
     all_decoders_.push_back(decoder_1_);
     all_decoders_.push_back(decoder_2_);
 
-    EXPECT_CALL(*demuxer_stream_, type())
-        .WillRepeatedly(Return(DemuxerStream::VIDEO));
-
     EXPECT_CALL(*decoder_1_, Stop(_))
       .WillRepeatedly(RunClosure<0>());
     EXPECT_CALL(*decoder_2_, Stop(_))
@@ -80,13 +71,17 @@ class VideoDecoderSelectorTest : public ::testing::Test {
   }
 
   void UseClearStream() {
-    EXPECT_CALL(*demuxer_stream_, video_decoder_config())
-        .WillRepeatedly(ReturnRef(clear_video_config_));
+    VideoDecoderConfig clear_video_config(
+        kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
+        kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, false);
+    demuxer_stream_->set_video_decoder_config(clear_video_config);
   }
 
   void UseEncryptedStream() {
-    EXPECT_CALL(*demuxer_stream_, video_decoder_config())
-        .WillRepeatedly(ReturnRef(encrypted_video_config_));
+    VideoDecoderConfig encrypted_video_config(
+        kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
+        kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, true);
+    demuxer_stream_->set_video_decoder_config(encrypted_video_config);
   }
 
   void InitializeDecoderSelector(DecryptorCapability decryptor_capability,
@@ -132,8 +127,6 @@ class VideoDecoderSelectorTest : public ::testing::Test {
 
   // Fixture members.
   scoped_ptr<VideoDecoderSelector> decoder_selector_;
-  VideoDecoderConfig clear_video_config_;
-  VideoDecoderConfig encrypted_video_config_;
   scoped_refptr<StrictMock<MockDemuxerStream> > demuxer_stream_;
   // Use NiceMock since we don't care about most of calls on the decryptor, e.g.
   // RegisterNewKeyCB().
diff --git a/media/filters/video_frame_stream_unittest.cc b/media/filters/video_frame_stream_unittest.cc
index 6fd8301..f97f2d4 100644
--- a/media/filters/video_frame_stream_unittest.cc
+++ b/media/filters/video_frame_stream_unittest.cc
@@ -17,7 +17,6 @@ using ::testing::AtMost;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
-using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
@@ -31,10 +30,8 @@ static const gfx::Size kNaturalSize(320, 240);
 class VideoFrameStreamTest : public testing::TestWithParam<bool> {
  public:
   VideoFrameStreamTest()
-      : video_config_(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
-                      kCodedSize, kVisibleRect, kNaturalSize, NULL, 0,
-                      GetParam()),
-        demuxer_stream_(new StrictMock<MockDemuxerStream>()),
+      : demuxer_stream_(
+            new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
         decryptor_(new NiceMock<MockDecryptor>()),
         decoder_(new StrictMock<MockVideoDecoder>()),
         is_initialized_(false) {
@@ -47,10 +44,11 @@ class VideoFrameStreamTest : public testing::TestWithParam<bool> {
         base::Bind(&VideoFrameStreamTest::SetDecryptorReadyCallback,
                    base::Unretained(this)));
 
-    EXPECT_CALL(*demuxer_stream_, type())
-        .WillRepeatedly(Return(DemuxerStream::VIDEO));
-    EXPECT_CALL(*demuxer_stream_, video_decoder_config())
-        .WillRepeatedly(ReturnRef(video_config_));
+    VideoDecoderConfig video_config(
+        kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
+        kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, GetParam());
+    demuxer_stream_->set_video_decoder_config(video_config);
+
     EXPECT_CALL(*demuxer_stream_, Read(_))
         .WillRepeatedly(RunCallback<0>(DemuxerStream::kOk,
                                        scoped_refptr<DecoderBuffer>()));
@@ -191,7 +189,6 @@ class VideoFrameStreamTest : public testing::TestWithParam<bool> {
   base::MessageLoop message_loop_;
 
   scoped_refptr<VideoFrameStream> video_frame_stream_;
-  VideoDecoderConfig video_config_;
   scoped_refptr<StrictMock<MockDemuxerStream> > demuxer_stream_;
   // Use NiceMock since we don't care about most of calls on the decryptor, e.g.
   // RegisterNewKeyCB().
diff --git a/media/filters/video_renderer_base_unittest.cc b/media/filters/video_renderer_base_unittest.cc
index 1b601ef..e61d95f 100644
--- a/media/filters/video_renderer_base_unittest.cc
+++ b/media/filters/video_renderer_base_unittest.cc
@@ -26,7 +26,6 @@ using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::NotNull;
 using ::testing::Return;
-using ::testing::ReturnRef;
 using ::testing::StrictMock;
 
 namespace media {
@@ -42,9 +41,7 @@ class VideoRendererBaseTest : public ::testing::Test {
  public:
   VideoRendererBaseTest()
       : decoder_(new MockVideoDecoder()),
-        demuxer_stream_(new MockDemuxerStream()),
-        video_config_(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
-                      kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, false) {
+        demuxer_stream_(new MockDemuxerStream(DemuxerStream::VIDEO)) {
     ScopedVector<VideoDecoder> decoders;
     decoders.push_back(decoder_);
 
@@ -56,10 +53,10 @@ class VideoRendererBaseTest : public ::testing::Test {
         base::Bind(&VideoRendererBaseTest::OnSetOpaque, base::Unretained(this)),
         true));
 
-    EXPECT_CALL(*demuxer_stream_, type())
-        .WillRepeatedly(Return(DemuxerStream::VIDEO));
-    EXPECT_CALL(*demuxer_stream_, video_decoder_config())
-        .WillRepeatedly(ReturnRef(video_config_));
+    VideoDecoderConfig video_config(
+        kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
+        kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, false);
+    demuxer_stream_->set_video_decoder_config(video_config);
 
     // We expect these to be called but we don't care how/when.
     EXPECT_CALL(*decoder_, Stop(_))
@@ -354,8 +351,6 @@ class VideoRendererBaseTest : public ::testing::Test {
 
   base::MessageLoop message_loop_;
 
-  VideoDecoderConfig video_config_;
-
   // Used to protect |time_| and |current_frame_|.
   base::Lock lock_;
   base::TimeDelta time_;