Encrypted Media: Update config/state after config changed in DecryptingAudioDecoder.

media/filters/decrypting_audio_decoder_unittest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "media/base/buffers.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/filters/decrypting_audio_decoder.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::AtMost;
 using ::testing::IsNull;
 using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace media {
 
-static const int kFakeAudioFrameSize = 16;
+// Make sure the kFakeAudioFrameSize is a valid frame size for all audio decoder
+// configs used in this test.
+static const int kFakeAudioFrameSize = 48;
 static const uint8 kFakeKeyId[] = { 0x4b, 0x65, 0x79, 0x20, 0x49, 0x44 };
 static const uint8 kFakeIv[DecryptConfig::kDecryptionKeySize] = { 0 };
 
 // Create a fake non-empty encrypted buffer.
 static scoped_refptr<DecoderBuffer> CreateFakeEncryptedBuffer() {
   const int buffer_size = 16;  // Need a non-empty buffer;
   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(buffer_size));
   buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>(new DecryptConfig(
       std::string(reinterpret_cast<const char*>(kFakeKeyId),
                   arraysize(kFakeKeyId)),
@@ skipping 304 matching lines @@
   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();
 
+  // The new config is different from the initial config in bits-per-channel,
+  // channel layout and samples_per_second.
+  AudioDecoderConfig new_config(kCodecVorbis, kSampleFormatPlanarS16,
+                                CHANNEL_LAYOUT_5_1, 88200, NULL, 0, false);
+  EXPECT_NE(new_config.bits_per_channel(), config_.bits_per_channel());
+  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));
   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_);
+
+  EXPECT_EQ(new_config.bits_per_channel(), decoder_->bits_per_channel());
+  EXPECT_EQ(new_config.channel_layout(), decoder_->channel_layout());
+  EXPECT_EQ(new_config.samples_per_second(), decoder_->samples_per_second());
 }
 
 // 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(_))
@@ skipping 81 matching lines @@
 }
 
 // Test resetting when the decoder is in kPendingDemuxerRead state and the read
 // callback is returned with kConfigChanged.
 TEST_F(DecryptingAudioDecoderTest, Reset_DuringDemuxerRead_ConfigChange) {
   Initialize();
   EnterPendingReadState();
 
   Reset();
 
+  // The new config is different from the initial config in bits-per-channel,
+  // channel layout and samples_per_second.
+  AudioDecoderConfig new_config(kCodecVorbis, kSampleFormatPlanarS16,
+                                CHANNEL_LAYOUT_5_1, 88200, NULL, 0, false);
+  EXPECT_NE(new_config.bits_per_channel(), config_.bits_per_channel());
+  EXPECT_NE(new_config.channel_layout(), config_.channel_layout());
+  EXPECT_NE(new_config.samples_per_second(), config_.samples_per_second());
+
   // 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));
   EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kAudio));
   EXPECT_CALL(*decryptor_, InitializeAudioDecoderMock(_, _))
       .WillOnce(RunCallback<1>(true));
   EXPECT_CALL(*this, FrameReady(AudioDecoder::kAborted, IsNull()));
 
   base::ResetAndReturn(&pending_demuxer_read_cb_)
       .Run(DemuxerStream::kConfigChanged, NULL);
   message_loop_.RunUntilIdle();
+
+  EXPECT_EQ(new_config.bits_per_channel(), decoder_->bits_per_channel());
+  EXPECT_EQ(new_config.channel_layout(), decoder_->channel_layout());
+  EXPECT_EQ(new_config.samples_per_second(), decoder_->samples_per_second());
 }
 
 // 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();
   EnterPendingReadState();
 
   Reset();
 
@@ skipping 64 matching lines @@
 
 // Test resetting after the decoder has been reset.
 TEST_F(DecryptingAudioDecoderTest, Reset_AfterReset) {
   Initialize();
   EnterNormalDecodingState();
   Reset();
   Reset();
 }
 
 }  // namespace media