Update PluginInstance for audio support for content decryption.

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"
@@ skipping 78 matching lines @@
   DecryptingAudioDecoderTest()
       : decoder_(new StrictMock<DecryptingAudioDecoder>(
             base::Bind(&Identity<scoped_refptr<base::MessageLoopProxy> >,
                        message_loop_.message_loop_proxy()),
             base::Bind(
                 &DecryptingAudioDecoderTest::RequestDecryptorNotification,
                 base::Unretained(this)))),
         decryptor_(new StrictMock<MockDecryptor>()),
         demuxer_(new StrictMock<MockDemuxerStream>()),
         encrypted_buffer_(CreateFakeEncryptedBuffer()),
-        decoded_frame_(new DataBuffer(kFakeAudioFrameSize)),
+        decoded_frame_(NULL),
         end_of_stream_frame_(new DataBuffer(0)),
-        decoded_frame_list_(1, decoded_frame_) {
+        decoded_frame_list_() {
+    // TODO(xhwang): Fix this after DataBuffer(data, size) is public.
+    scoped_refptr<DataBuffer> buffer = new DataBuffer(kFakeAudioFrameSize);
+    buffer->SetDataSize(kFakeAudioFrameSize);
+    decoded_frame_ = buffer;
+    decoded_frame_list_.push_back(decoded_frame_);
   }
 
   void InitializeAndExpectStatus(const AudioDecoderConfig& config,
                                  PipelineStatus status) {
     EXPECT_CALL(*demuxer_, audio_decoder_config())
         .WillRepeatedly(ReturnRef(config));
 
     decoder_->Initialize(demuxer_, NewExpectedStatusCB(status),
                          base::Bind(&MockStatisticsCB::OnStatistics,
                                     base::Unretained(&statistics_cb_)));
@@ skipping 206 matching lines @@
   EXPECT_CALL(statistics_cb_, OnStatistics(_))
       .Times(2);
 
   ReadAndExpectFrameReadyWith(AudioDecoder::kOk, decoded_frame_);
 }
 
 // Test the case where the decryptor returns multiple decoded frames.
 TEST_F(DecryptingAudioDecoderTest, DecryptAndDecode_MultipleFrames) {
   Initialize();
 
-  scoped_refptr<Buffer> decoded_frame_a(new DataBuffer(kFakeAudioFrameSize));
-  scoped_refptr<Buffer> decoded_frame_b(new DataBuffer(kFakeAudioFrameSize));
-  decoded_frame_list_.push_back(decoded_frame_a);
-  decoded_frame_list_.push_back(decoded_frame_b);
+  scoped_refptr<DataBuffer> frame_a = new DataBuffer(kFakeAudioFrameSize);
+  frame_a->SetDataSize(kFakeAudioFrameSize);
+  scoped_refptr<DataBuffer> frame_b = new DataBuffer(kFakeAudioFrameSize);
+  frame_b->SetDataSize(kFakeAudioFrameSize);
+  decoded_frame_list_.push_back(frame_a);
+  decoded_frame_list_.push_back(frame_b);
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(ReturnBuffer(encrypted_buffer_));
   EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
       .WillOnce(RunCallback2(Decryptor::kSuccess, decoded_frame_list_));
   EXPECT_CALL(statistics_cb_, OnStatistics(_));
 
   ReadAndExpectFrameReadyWith(AudioDecoder::kOk, decoded_frame_);
-  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, decoded_frame_a);
-  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, decoded_frame_b);
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, frame_a);
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, frame_b);
 }
 
 // Test the case where the decryptor receives end-of-stream buffer.
 TEST_F(DecryptingAudioDecoderTest, DecryptAndDecode_EndOfStream) {
   Initialize();
   EnterNormalDecodingState();
   EnterEndOfStreamState();
 }
 
-// Test the case where the decryptor returns multiple decoded frames, the last
-// of which is end-of-stream frame.
-TEST_F(DecryptingAudioDecoderTest, DecryptAndDecode_MultipleFramesWithEos) {
-  Initialize();
-
-  scoped_refptr<Buffer> decoded_frame_a(new DataBuffer(kFakeAudioFrameSize));
-  scoped_refptr<Buffer> decoded_frame_b(new DataBuffer(kFakeAudioFrameSize));
-  Decryptor::AudioBuffers second_decoded_frame_list;
-  second_decoded_frame_list.push_back(decoded_frame_a);
-  second_decoded_frame_list.push_back(decoded_frame_b);
-  second_decoded_frame_list.push_back(end_of_stream_frame_);
-
-  EXPECT_CALL(*demuxer_, Read(_))
-      .WillOnce(ReturnBuffer(encrypted_buffer_))
-      .WillOnce(ReturnBuffer(DecoderBuffer::CreateEOSBuffer()));
-  EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
-      .WillOnce(RunCallback2(Decryptor::kSuccess, decoded_frame_list_))
-      .WillOnce(RunCallback2(Decryptor::kSuccess, second_decoded_frame_list));
-  // Expect only one OnStatistics() here because EOS input buffer doesn't
-  // trigger statistics reporting.
-  EXPECT_CALL(statistics_cb_, OnStatistics(_));
-
-  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, decoded_frame_);
-  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, decoded_frame_a);
-  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, decoded_frame_b);
-  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, end_of_stream_frame_);
-}
-
 // Test the case where the a key is added when the decryptor is in
 // kWaitingForKey state.
 TEST_F(DecryptingAudioDecoderTest, KeyAdded_DuringWaitingForKey) {
   Initialize();
   EnterWaitingForKeyState();
 
   EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
       .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_frame_list_));
   EXPECT_CALL(statistics_cb_, OnStatistics(_));
   EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, decoded_frame_));
@@ skipping 115 matching lines @@
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(ReturnConfigChanged());
 
   // TODO(xhwang): Update this test when kConfigChanged is supported in
   // DecryptingAudioDecoder.
   ReadAndExpectFrameReadyWith(AudioDecoder::kDecodeError, NULL);
 }
 
 }  // namespace media