Encrypted Media: Add config change support in DecryptingAudioDecoder.

media/filters/decrypting_audio_decoder_unittest.cc

Index: media/filters/decrypting_audio_decoder_unittest.cc
diff --git a/media/filters/decrypting_audio_decoder_unittest.cc b/media/filters/decrypting_audio_decoder_unittest.cc
index efc68151050f28cc87d3234579ce3b9f79a916aa..1aa39e707779e283b3eb445eb6ef5b4e0d7d1db0 100644
--- a/media/filters/decrypting_audio_decoder_unittest.cc
+++ b/media/filters/decrypting_audio_decoder_unittest.cc
@@ -108,13 +108,13 @@ class DecryptingAudioDecoderTest : public testing::Test {
     EXPECT_CALL(*decryptor_, RegisterNewKeyCB(Decryptor::kAudio, _))
         .WillOnce(SaveArg<1>(&key_added_cb_));
 
-    AudioDecoderConfig config(kCodecVorbis, kSampleFormatPlanarF32,
-                              CHANNEL_LAYOUT_STEREO, 44100, NULL, 0, true);
-    InitializeAndExpectStatus(config, PIPELINE_OK);
+    config_.Initialize(kCodecVorbis, kSampleFormatPlanarF32,
+                       CHANNEL_LAYOUT_STEREO, 44100, NULL, 0, true, true);
+    InitializeAndExpectStatus(config_, PIPELINE_OK);
 
-    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());
+    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());
   }
 
   void ReadAndExpectFrameReadyWith(
@@ -221,6 +221,7 @@ class DecryptingAudioDecoderTest : public testing::Test {
   scoped_ptr<StrictMock<MockDecryptor> > decryptor_;
   scoped_refptr<StrictMock<MockDemuxerStream> > demuxer_;
   MockStatisticsCB statistics_cb_;
+  AudioDecoderConfig config_;
 
   DemuxerStream::ReadCB pending_demuxer_read_cb_;
   Decryptor::DecoderInitCB pending_init_cb_;
@@ -336,6 +337,50 @@ TEST_F(DecryptingAudioDecoderTest, DecryptAndDecode_EndOfStream) {
   EnterEndOfStreamState();
 }
 
+// Test aborted read on the demuxer stream.
+TEST_F(DecryptingAudioDecoderTest, DemuxerRead_Aborted) {
+  Initialize();
+
+  // ReturnBuffer() with NULL triggers aborted demuxer read.
+  EXPECT_CALL(*demuxer_, Read(_))
+      .WillOnce(ReturnBuffer(scoped_refptr<DecoderBuffer>()));
+
+  ReadAndExpectFrameReadyWith(AudioDecoder::kAborted, NULL);
+}
+
+// Test config change on the demuxer stream.
+TEST_F(DecryptingAudioDecoderTest, DemuxerRead_ConfigChange) {
+  Initialize();
+
+  EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kAudio));
+  EXPECT_CALL(*decryptor_, InitializeAudioDecoderMock(_, _))
+      .WillOnce(RunCallback<1>(true));
+  EXPECT_CALL(*demuxer_, Read(_))
+      .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
+                               scoped_refptr<DecoderBuffer>()))
+      .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
+  EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
+      .WillRepeatedly(RunCallback<1>(Decryptor::kSuccess, decoded_frame_list_));
+  EXPECT_CALL(statistics_cb_, OnStatistics(_));
+
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, decoded_frame_);
+}
+
+// Test config change failure.
+TEST_F(DecryptingAudioDecoderTest, DemuxerRead_ConfigChangeFailed) {
+  Initialize();
+
+  EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kAudio));
+  EXPECT_CALL(*decryptor_, InitializeAudioDecoderMock(_, _))
+      .WillOnce(RunCallback<1>(false));
+  EXPECT_CALL(*demuxer_, Read(_))
+      .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
+                               scoped_refptr<DecoderBuffer>()))
+      .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
+
+  ReadAndExpectFrameReadyWith(AudioDecoder::kDecodeError, NULL);
+}
+
 // Test the case where the a key is added when the decryptor is in
 // kWaitingForKey state.
 TEST_F(DecryptingAudioDecoderTest, KeyAdded_DuringWaitingForKey) {
@@ -383,8 +428,9 @@ TEST_F(DecryptingAudioDecoderTest, Reset_DuringIdleAfterDecodedOneFrame) {
   Reset();
 }
 
-// Test resetting when the decoder is in kPendingDemuxerRead state.
-TEST_F(DecryptingAudioDecoderTest, Reset_DuringPendingDemuxerRead) {
+// Test resetting when the decoder is in kPendingDemuxerRead state and the read
+// callback is returned with kOk.
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringDemuxerRead_Ok) {
   Initialize();
   EnterPendingReadState();
 
@@ -396,79 +442,120 @@ TEST_F(DecryptingAudioDecoderTest, Reset_DuringPendingDemuxerRead) {
   message_loop_.RunUntilIdle();
 }
 
-// Test resetting when the decoder is in kPendingDecode state.
-TEST_F(DecryptingAudioDecoderTest, Reset_DuringPendingDecode) {
+// Test resetting when the decoder is in kPendingDemuxerRead state and the read
+// callback is returned with kAborted.
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringDemuxerRead_Aborted) {
   Initialize();
-  EnterPendingDecodeState();
+  EnterPendingReadState();
 
+  // Make sure we get a NULL audio frame returned.
   EXPECT_CALL(*this, FrameReady(AudioDecoder::kAborted, IsNull()));
 
   Reset();
+  base::ResetAndReturn(&pending_demuxer_read_cb_).Run(DemuxerStream::kAborted,
+                                                      NULL);
+  message_loop_.RunUntilIdle();
 }
 
-// Test resetting when the decoder is in kWaitingForKey state.
-TEST_F(DecryptingAudioDecoderTest, Reset_DuringWaitingForKey) {
+// Test resetting when the decoder is in kPendingDemuxerRead state and the read
+// callback is returned with kConfigChanged.
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringDemuxerRead_ConfigChange) {
   Initialize();
-  EnterWaitingForKeyState();
+  EnterPendingReadState();
 
+  Reset();
+
+  // Even during pending reset, the decoder still needs to be initialized with
+  // the new config.
+  EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kAudio));
+  EXPECT_CALL(*decryptor_, InitializeAudioDecoderMock(_, _))
+      .WillOnce(RunCallback<1>(true));
   EXPECT_CALL(*this, FrameReady(AudioDecoder::kAborted, IsNull()));
 
-  Reset();
+  base::ResetAndReturn(&pending_demuxer_read_cb_)
+      .Run(DemuxerStream::kConfigChanged, NULL);
+  message_loop_.RunUntilIdle();
 }
 
-// Test resetting when the decoder has hit end of stream and is in
-// kDecodeFinished state.
-TEST_F(DecryptingAudioDecoderTest, Reset_AfterDecodeFinished) {
+// Test resetting when the decoder is in kPendingDemuxerRead state, the read
+// callback is returned with kConfigChanged and the config change fails.
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringDemuxerRead_ConfigChangeFailed) {
   Initialize();
-  EnterNormalDecodingState();
-  EnterEndOfStreamState();
+  EnterPendingReadState();
+
   Reset();
+
+  // Even during pending reset, the decoder still needs to be initialized with
+  // the new config.
+  EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kAudio));
+  EXPECT_CALL(*decryptor_, InitializeAudioDecoderMock(_, _))
+      .WillOnce(RunCallback<1>(false));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kDecodeError, IsNull()));
+
+  base::ResetAndReturn(&pending_demuxer_read_cb_)
+      .Run(DemuxerStream::kConfigChanged, NULL);
+  message_loop_.RunUntilIdle();
 }
 
-// Test resetting after the decoder has been reset.
-TEST_F(DecryptingAudioDecoderTest, Reset_AfterReset) {
+// Test resetting when the decoder is in kPendingConfigChange state.
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringPendingConfigChange) {
   Initialize();
   EnterNormalDecodingState();
+
+  EXPECT_CALL(*demuxer_, Read(_))
+      .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
+                               scoped_refptr<DecoderBuffer>()));
+  EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kAudio));
+  EXPECT_CALL(*decryptor_, InitializeAudioDecoderMock(_, _))
+      .WillOnce(SaveArg<1>(&pending_init_cb_));
+
+  decoder_->Read(base::Bind(&DecryptingAudioDecoderTest::FrameReady,
+                            base::Unretained(this)));
+  message_loop_.RunUntilIdle();
+  EXPECT_FALSE(pending_init_cb_.is_null());
+
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kAborted, IsNull()));
+
   Reset();
-  Reset();
+  base::ResetAndReturn(&pending_init_cb_).Run(true);
+  message_loop_.RunUntilIdle();
 }
 
-// Test aborted read on the demuxer stream.
-TEST_F(DecryptingAudioDecoderTest, DemuxerRead_Aborted) {
+// Test resetting when the decoder is in kPendingDecode state.
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringPendingDecode) {
   Initialize();
+  EnterPendingDecodeState();
 
-  // ReturnBuffer() with NULL triggers aborted demuxer read.
-  EXPECT_CALL(*demuxer_, Read(_))
-      .WillOnce(ReturnBuffer(scoped_refptr<DecoderBuffer>()));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kAborted, IsNull()));
 
-  ReadAndExpectFrameReadyWith(AudioDecoder::kAborted, NULL);
+  Reset();
 }
 
-// Test aborted read on the demuxer stream when the decoder is being reset.
-TEST_F(DecryptingAudioDecoderTest, DemuxerRead_AbortedDuringReset) {
+// Test resetting when the decoder is in kWaitingForKey state.
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringWaitingForKey) {
   Initialize();
-  EnterPendingReadState();
+  EnterWaitingForKeyState();
 
-  // Make sure we get a NULL audio frame returned.
   EXPECT_CALL(*this, FrameReady(AudioDecoder::kAborted, IsNull()));
 
   Reset();
-  base::ResetAndReturn(&pending_demuxer_read_cb_).Run(DemuxerStream::kAborted,
-                                                      NULL);
-  message_loop_.RunUntilIdle();
 }
 
-// Test config change on the demuxer stream.
-TEST_F(DecryptingAudioDecoderTest, DemuxerRead_ConfigChanged) {
+// Test resetting when the decoder has hit end of stream and is in
+// kDecodeFinished state.
+TEST_F(DecryptingAudioDecoderTest, Reset_AfterDecodeFinished) {
   Initialize();
+  EnterNormalDecodingState();
+  EnterEndOfStreamState();
+  Reset();
+}
 
-  EXPECT_CALL(*demuxer_, Read(_))
-      .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
-                               scoped_refptr<DecoderBuffer>()));
-
-  // TODO(xhwang): Update this test when kConfigChanged is supported in
-  // DecryptingAudioDecoder.
-  ReadAndExpectFrameReadyWith(AudioDecoder::kDecodeError, NULL);
+// Test resetting after the decoder has been reset.
+TEST_F(DecryptingAudioDecoderTest, Reset_AfterReset) {
+  Initialize();
+  EnterNormalDecodingState();
+  Reset();
+  Reset();
 }
 
 }  // namespace media