Add 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/mock_callback.h"
 #include "media/base/mock_filters.h"
-#include "media/base/video_frame.h"
-#include "media/filters/decrypting_video_decoder.h"
+#include "media/filters/decrypting_audio_decoder.h"
 #include "media/filters/ffmpeg_decoder_unittest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::AtMost;
 using ::testing::Invoke;
 using ::testing::IsNull;
 using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 namespace media {
 
-static const VideoFrame::Format kVideoFormat = VideoFrame::YV12;
 static const gfx::Size kCodedSize(320, 240);
 static const gfx::Rect kVisibleRect(320, 240);
 static const gfx::Size kNaturalSize(320, 240);
 static const uint8 kFakeKeyId[] = { 0x4b, 0x65, 0x79, 0x20, 0x49, 0x44 };
 static const uint8 kFakeIv[DecryptConfig::kDecryptionKeySize] = { 0 };
+static const int kFakeAudioFrameSize = 16;
 
 // 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)),
       std::string(reinterpret_cast<const char*>(kFakeIv), arraysize(kFakeIv)),
       0,
@@ skipping 22 matching lines @@
 }
 
 ACTION_P2(ResetAndRunCallback, callback, param) {
   base::ResetAndReturn(callback).Run(param);
 }
 
 MATCHER(IsNullCallback, "") {
   return (arg.is_null());
 }
 
-class DecryptingVideoDecoderTest : public testing::Test {
+class DecryptingAudioDecoderTest : public testing::Test {
  public:
-  DecryptingVideoDecoderTest()
-      : decoder_(new StrictMock<DecryptingVideoDecoder>(
+  DecryptingAudioDecoderTest()
+      : decoder_(new StrictMock<DecryptingAudioDecoder>(
             base::Bind(&Identity<scoped_refptr<base::MessageLoopProxy> >,
                        message_loop_.message_loop_proxy()),
             base::Bind(
-                &DecryptingVideoDecoderTest::RequestDecryptorNotification,
+                &DecryptingAudioDecoderTest::RequestDecryptorNotification,
                 base::Unretained(this)))),
         decryptor_(new StrictMock<MockDecryptor>()),
         demuxer_(new StrictMock<MockDemuxerStream>()),
         encrypted_buffer_(CreateFakeEncryptedBuffer()),
-        decoded_video_frame_(VideoFrame::CreateBlackFrame(kCodedSize)),
-        null_video_frame_(scoped_refptr<VideoFrame>()),
-        end_of_stream_video_frame_(VideoFrame::CreateEmptyFrame()) {
+        default_audio_frame_(new DataBuffer(kFakeAudioFrameSize)),
+        end_of_stream_frame_(new DataBuffer(0)),
+        decoded_frames_(1, default_audio_frame_) {
   }
 
-  virtual ~DecryptingVideoDecoderTest() {
+  virtual ~DecryptingAudioDecoderTest() {
     Stop();
   }
 
-  void InitializeAndExpectStatus(const VideoDecoderConfig& config,
+  void InitializeAndExpectStatus(const AudioDecoderConfig& config,
                                  PipelineStatus status) {
-    EXPECT_CALL(*demuxer_, video_decoder_config())
+    EXPECT_CALL(*demuxer_, audio_decoder_config())
         .WillRepeatedly(ReturnRef(config));
     EXPECT_CALL(*this, RequestDecryptorNotification(_))
         .WillRepeatedly(RunCallback0(decryptor_.get()));
 
     decoder_->Initialize(demuxer_, NewExpectedStatusCB(status),
                          base::Bind(&MockStatisticsCB::OnStatistics,
                                     base::Unretained(&statistics_cb_)));
     message_loop_.RunAllPending();
   }
 
   void Initialize() {
-    EXPECT_CALL(*decryptor_, InitializeVideoDecoderMock(_, _, _))
+    EXPECT_CALL(*decryptor_, InitializeAudioDecoderMock(_, _, _))
         .Times(AtMost(1))
         .WillOnce(DoAll(RunCallback1(true), SaveArg<2>(&key_added_cb_)));
 
-    config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
-                       kCodedSize, kVisibleRect, kNaturalSize,
+    config_.Initialize(kCodecVorbis, 16, CHANNEL_LAYOUT_STEREO, 44100,
                        NULL, 0, true, true);
 
     InitializeAndExpectStatus(config_, PIPELINE_OK);
   }
 
   void ReadAndExpectFrameReadyWith(
-      VideoDecoder::Status status,
-      const scoped_refptr<VideoFrame>& video_frame) {
-    EXPECT_CALL(*this, FrameReady(status, video_frame));
+      AudioDecoder::Status status,
+      const scoped_refptr<Buffer>& audio_frame) {
+    if (status != AudioDecoder::kOk)
+      EXPECT_CALL(*this, FrameReady(status, IsNull()));
+    else
+      EXPECT_CALL(*this, FrameReady(status, audio_frame));
 
-    decoder_->Read(base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+    decoder_->Read(base::Bind(&DecryptingAudioDecoderTest::FrameReady,
                               base::Unretained(this)));
     message_loop_.RunAllPending();
   }
 
-  // Sets up expectations and actions to put DecryptingVideoDecoder in an
+  // Sets up expectations and actions to put DecryptingAudioDecoder in an
   // active normal decoding state.
   void EnterNormalDecodingState() {
+    Decryptor::AudioBuffers end_of_stream_frames_(1,
+                                                  end_of_stream_frame_);
+
     EXPECT_CALL(*demuxer_, Read(_))
         .WillOnce(ReturnBuffer(encrypted_buffer_))
         .WillRepeatedly(ReturnBuffer(DecoderBuffer::CreateEOSBuffer()));
-    EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-        .WillOnce(RunCallback2(Decryptor::kSuccess, decoded_video_frame_))
+    EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
+        .WillOnce(RunCallback2(Decryptor::kSuccess,
+                               decoded_frames_))
         .WillRepeatedly(RunCallback2(Decryptor::kSuccess,
-                                     end_of_stream_video_frame_));
+                                     end_of_stream_frames_));
     EXPECT_CALL(statistics_cb_, OnStatistics(_));
 
-    ReadAndExpectFrameReadyWith(VideoDecoder::kOk, decoded_video_frame_);
+    ReadAndExpectFrameReadyWith(AudioDecoder::kOk, default_audio_frame_);
   }
 
-  // Sets up expectations and actions to put DecryptingVideoDecoder in an end
+  // Sets up expectations and actions to put DecryptingAudioDecoder in an end
   // of stream state. This function must be called after
   // EnterNormalDecodingState() to work.
   void EnterEndOfStreamState() {
-    ReadAndExpectFrameReadyWith(VideoDecoder::kOk, end_of_stream_video_frame_);
+    ReadAndExpectFrameReadyWith(AudioDecoder::kOk, end_of_stream_frame_);
   }
 
   // Make the read callback pending by saving and not firing it.
   void EnterPendingReadState() {
     EXPECT_TRUE(pending_demuxer_read_cb_.is_null());
     EXPECT_CALL(*demuxer_, Read(_))
         .WillOnce(SaveArg<0>(&pending_demuxer_read_cb_));
-    decoder_->Read(base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+    decoder_->Read(base::Bind(&DecryptingAudioDecoderTest::FrameReady,
                               base::Unretained(this)));
     message_loop_.RunAllPending();
     // Make sure the Read() on the decoder triggers a Read() on the demuxer.
     EXPECT_FALSE(pending_demuxer_read_cb_.is_null());
   }
 
-  // Make the video decode callback pending by saving and not firing it.
+  // Make the audio decode callback pending by saving and not firing it.
   void EnterPendingDecodeState() {
-    EXPECT_TRUE(pending_video_decode_cb_.is_null());
+    EXPECT_TRUE(pending_audio_decode_cb_.is_null());
     EXPECT_CALL(*demuxer_, Read(_))
         .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
-    EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(encrypted_buffer_, _))
-        .WillOnce(SaveArg<1>(&pending_video_decode_cb_));
-
-    decoder_->Read(base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+    EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(encrypted_buffer_, _))
+        .WillOnce(SaveArg<1>(&pending_audio_decode_cb_));
+
+    decoder_->Read(base::Bind(&DecryptingAudioDecoderTest::FrameReady,
                               base::Unretained(this)));
     message_loop_.RunAllPending();
     // Make sure the Read() on the decoder triggers a DecryptAndDecode() on the
     // decryptor.
-    EXPECT_FALSE(pending_video_decode_cb_.is_null());
+    EXPECT_FALSE(pending_audio_decode_cb_.is_null());
   }
 
   void EnterWaitingForKeyState() {
     EXPECT_CALL(*demuxer_, Read(_))
         .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
-    EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-        .WillRepeatedly(RunCallback2(Decryptor::kNoKey, null_video_frame_));
-    decoder_->Read(base::Bind(&DecryptingVideoDecoderTest::FrameReady,
+    EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
+        .WillRepeatedly(RunCallback2(Decryptor::kNoKey,
+                                     Decryptor::AudioBuffers()));
+    decoder_->Read(base::Bind(&DecryptingAudioDecoderTest::FrameReady,
                               base::Unretained(this)));
     message_loop_.RunAllPending();
   }
 
-  void AbortPendingVideoDecodeCB() {
-    if (!pending_video_decode_cb_.is_null()) {
-      base::ResetAndReturn(&pending_video_decode_cb_).Run(
-          Decryptor::kSuccess, scoped_refptr<VideoFrame>(NULL));
+  void AbortPendingAudioDecodeCB() {
+    if (!pending_audio_decode_cb_.is_null()) {
+      base::ResetAndReturn(&pending_audio_decode_cb_).Run(
+          Decryptor::kSuccess, Decryptor::AudioBuffers());
     }
   }
 
   void AbortAllPendingCBs() {
     if (!pending_init_cb_.is_null()) {
-      ASSERT_TRUE(pending_video_decode_cb_.is_null());
+      ASSERT_TRUE(pending_audio_decode_cb_.is_null());
       base::ResetAndReturn(&pending_init_cb_).Run(false);
       return;
     }
 
-    AbortPendingVideoDecodeCB();
+    AbortPendingAudioDecodeCB();
   }
 
   void Reset() {
-    EXPECT_CALL(*decryptor_, ResetDecoder(Decryptor::kVideo))
+    EXPECT_CALL(*decryptor_, ResetDecoder(Decryptor::kAudio))
         .WillRepeatedly(InvokeWithoutArgs(
-            this, &DecryptingVideoDecoderTest::AbortPendingVideoDecodeCB));
+            this, &DecryptingAudioDecoderTest::AbortPendingAudioDecodeCB));
 
     decoder_->Reset(NewExpectedClosure());
     message_loop_.RunAllPending();
   }
 
   void Stop() {
-    EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kVideo))
+    EXPECT_CALL(*decryptor_, DeinitializeDecoder(Decryptor::kAudio))
         .WillRepeatedly(InvokeWithoutArgs(
-            this, &DecryptingVideoDecoderTest::AbortAllPendingCBs));
+            this, &DecryptingAudioDecoderTest::AbortAllPendingCBs));
 
     decoder_->Stop(NewExpectedClosure());
     message_loop_.RunAllPending();
   }
 
   MOCK_METHOD1(RequestDecryptorNotification,
-               void(const DecryptingVideoDecoder::DecryptorNotificationCB&));
-
-  MOCK_METHOD2(FrameReady, void(VideoDecoder::Status,
-                                const scoped_refptr<VideoFrame>&));
+               void(const DecryptingAudioDecoder::DecryptorNotificationCB&));
+
+  MOCK_METHOD2(FrameReady, void(AudioDecoder::Status,
+                                const scoped_refptr<Buffer>&));
 
   MessageLoop message_loop_;
-  scoped_refptr<StrictMock<DecryptingVideoDecoder> > decoder_;
+  scoped_refptr<StrictMock<DecryptingAudioDecoder> > decoder_;
   scoped_ptr<StrictMock<MockDecryptor> > decryptor_;
   scoped_refptr<StrictMock<MockDemuxerStream> > demuxer_;
   MockStatisticsCB statistics_cb_;
-  VideoDecoderConfig config_;
+  AudioDecoderConfig config_;
 
   DemuxerStream::ReadCB pending_demuxer_read_cb_;
   Decryptor::DecoderInitCB pending_init_cb_;
   Decryptor::KeyAddedCB key_added_cb_;
-  Decryptor::VideoDecodeCB pending_video_decode_cb_;
+  Decryptor::AudioDecodeCB pending_audio_decode_cb_;
 
   // Constant buffer/frames to be returned by the |demuxer_| and |decryptor_|.
   scoped_refptr<DecoderBuffer> encrypted_buffer_;
-  scoped_refptr<VideoFrame> decoded_video_frame_;
-  scoped_refptr<VideoFrame> null_video_frame_;
-  scoped_refptr<VideoFrame> end_of_stream_video_frame_;
+  scoped_refptr<Buffer> default_audio_frame_;
+  scoped_refptr<Buffer> end_of_stream_frame_;
+  Decryptor::AudioBuffers decoded_frames_;
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(DecryptingVideoDecoderTest);
+  DISALLOW_COPY_AND_ASSIGN(DecryptingAudioDecoderTest);
 };
 
-TEST_F(DecryptingVideoDecoderTest, Initialize_Normal) {
-  Initialize();
-}
-
-// Ensure that DecryptingVideoDecoder only accepts encrypted video.
-TEST_F(DecryptingVideoDecoderTest, Initialize_UnencryptedVideoConfig) {
-  VideoDecoderConfig config(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
-                            kVideoFormat,
-                            kCodedSize, kVisibleRect, kNaturalSize,
+TEST_F(DecryptingAudioDecoderTest, Initialize_Normal) {
+  Initialize();
+}
+
+// Ensure that DecryptingAudioDecoder only accepts encrypted audio.
+TEST_F(DecryptingAudioDecoderTest, Initialize_UnencryptedAudioConfig) {
+  AudioDecoderConfig config(kCodecVorbis, 16, CHANNEL_LAYOUT_STEREO, 44100,
                             NULL, 0, false);
 
   InitializeAndExpectStatus(config, DECODER_ERROR_NOT_SUPPORTED);
 }
 
-// Ensure decoder handles invalid video configs without crashing.
-TEST_F(DecryptingVideoDecoderTest, Initialize_InvalidVideoConfig) {
-  VideoDecoderConfig config(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
-                            VideoFrame::INVALID,
-                            kCodedSize, kVisibleRect, kNaturalSize,
+// Ensure decoder handles invalid audio configs without crashing.
+TEST_F(DecryptingAudioDecoderTest, Initialize_InvalidAudioConfig) {
+  AudioDecoderConfig config(kUnknownAudioCodec, 0, CHANNEL_LAYOUT_STEREO, 0,
                             NULL, 0, true);
 
   InitializeAndExpectStatus(config, PIPELINE_ERROR_DECODE);
 }
 
-// Ensure decoder handles unsupported video configs without crashing.
-TEST_F(DecryptingVideoDecoderTest, Initialize_UnsupportedVideoConfig) {
-  EXPECT_CALL(*decryptor_, InitializeVideoDecoderMock(_, _, _))
+// Ensure decoder handles unsupported audio configs without crashing.
+TEST_F(DecryptingAudioDecoderTest, Initialize_UnsupportedAudioConfig) {
+  EXPECT_CALL(*decryptor_, InitializeAudioDecoderMock(_, _, _))
       .WillOnce(RunCallback1(false));
 
-  VideoDecoderConfig config(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
-                            kVideoFormat,
-                            kCodedSize, kVisibleRect, kNaturalSize,
+  AudioDecoderConfig config(kCodecVorbis, 16, CHANNEL_LAYOUT_STEREO, 44100,
                             NULL, 0, true);
-
   InitializeAndExpectStatus(config, DECODER_ERROR_NOT_SUPPORTED);
 }
 
 // Test normal decrypt and decode case.
-TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_Normal) {
+TEST_F(DecryptingAudioDecoderTest, DecryptAndDecode_Normal) {
   Initialize();
   EnterNormalDecodingState();
 }
 
 // Test the case where the decryptor returns error when doing decrypt and
 // decode.
-TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_DecodeError) {
+TEST_F(DecryptingAudioDecoderTest, DecryptAndDecode_DecodeError) {
   Initialize();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
-  EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
+  EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
       .WillRepeatedly(RunCallback2(Decryptor::kError,
-                                   scoped_refptr<VideoFrame>(NULL)));
-
-  ReadAndExpectFrameReadyWith(VideoDecoder::kDecodeError, null_video_frame_);
+                                   Decryptor::AudioBuffers()));
+
+  ReadAndExpectFrameReadyWith(AudioDecoder::kDecodeError, NULL);
 }
 
 // Test the case where the decryptor returns kNeedMoreData to ask for more
 // buffers before it can produce a frame.
-TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_NeedMoreData) {
+TEST_F(DecryptingAudioDecoderTest, DecryptAndDecode_NeedMoreData) {
   Initialize();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .Times(2)
       .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
-  EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
+  EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
       .WillOnce(RunCallback2(Decryptor::kNeedMoreData,
-                             scoped_refptr<VideoFrame>()))
-      .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_video_frame_));
+                             Decryptor::AudioBuffers()))
+      .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_frames_));
   EXPECT_CALL(statistics_cb_, OnStatistics(_))
       .Times(2);
 
-  ReadAndExpectFrameReadyWith(VideoDecoder::kOk, decoded_video_frame_);
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, default_audio_frame_);
+}
+
+// Test the case where the decryptor returns multiple decoded frames.
+TEST_F(DecryptingAudioDecoderTest, DecryptAndDecode_MultipleFrames) {
+  Initialize();
+
+  scoped_refptr<Buffer> audio_frame_a(new DataBuffer(kFakeAudioFrameSize));
+  scoped_refptr<Buffer> audio_frame_b(new DataBuffer(kFakeAudioFrameSize));
+  decoded_frames_.push_back(audio_frame_a);
+  decoded_frames_.push_back(audio_frame_b);
+
+  EXPECT_CALL(*demuxer_, Read(_))
+      .WillOnce(ReturnBuffer(encrypted_buffer_));
+  EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
+      .WillOnce(RunCallback2(Decryptor::kSuccess, decoded_frames_));
+  EXPECT_CALL(statistics_cb_, OnStatistics(_));
+
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, default_audio_frame_);
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, audio_frame_a);
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, audio_frame_b);
 }
 
 // Test the case where the decryptor receives end-of-stream buffer.
-TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_EndOfStream) {
+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> audio_frame_a(new DataBuffer(kFakeAudioFrameSize));
+  scoped_refptr<Buffer> audio_frame_b(new DataBuffer(kFakeAudioFrameSize));
+  Decryptor::AudioBuffers decoded_frames_a;
+  decoded_frames_a.push_back(audio_frame_a);
+  decoded_frames_a.push_back(audio_frame_b);
+  decoded_frames_a.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_frames_))
+      .WillOnce(RunCallback2(Decryptor::kSuccess, decoded_frames_a));
+  // Expect only one OnStatistics() here because EOS input buffer doesn't
+  // trigger statistics reporting.
+  EXPECT_CALL(statistics_cb_, OnStatistics(_));
+
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, default_audio_frame_);
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, audio_frame_a);
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, audio_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(DecryptingVideoDecoderTest, KeyAdded_DuringWaitingForKey) {
+TEST_F(DecryptingAudioDecoderTest, KeyAdded_DuringWaitingForKey) {
   Initialize();
   EnterWaitingForKeyState();
 
-  EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-      .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_video_frame_));
-  EXPECT_CALL(statistics_cb_, OnStatistics(_));
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, decoded_video_frame_));
+  EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
+      .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_frames_));
+  EXPECT_CALL(statistics_cb_, OnStatistics(_));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, default_audio_frame_));
   key_added_cb_.Run();
   message_loop_.RunAllPending();
 }
 
 // Test the case where the a key is added when the decryptor is in
 // kPendingDecode state.
-TEST_F(DecryptingVideoDecoderTest, KeyAdded_DruingPendingDecode) {
+TEST_F(DecryptingAudioDecoderTest, KeyAdded_DruingPendingDecode) {
   Initialize();
   EnterPendingDecodeState();
 
-  EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-      .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_video_frame_));
-  EXPECT_CALL(statistics_cb_, OnStatistics(_));
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, decoded_video_frame_));
-  // The video decode callback is returned after the correct decryption key is
+  EXPECT_CALL(*decryptor_, DecryptAndDecodeAudio(_, _))
+      .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_frames_));
+  EXPECT_CALL(statistics_cb_, OnStatistics(_));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, default_audio_frame_));
+  // The audio decode callback is returned after the correct decryption key is
   // added.
   key_added_cb_.Run();
-  base::ResetAndReturn(&pending_video_decode_cb_).Run(Decryptor::kNoKey,
-                                                      null_video_frame_);
+  base::ResetAndReturn(&pending_audio_decode_cb_)
+      .Run(Decryptor::kNoKey, Decryptor::AudioBuffers());
   message_loop_.RunAllPending();
 }
 
 // Test resetting when the decoder is in kIdle state but has not decoded any
 // frame.
-TEST_F(DecryptingVideoDecoderTest, Reset_DuringIdleAfterInitialization) {
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringIdleAfterInitialization) {
   Initialize();
   Reset();
 }
 
 // Test resetting when the decoder is in kIdle state after it has decoded one
 // frame.
-TEST_F(DecryptingVideoDecoderTest, Reset_DuringIdleAfterDecodedOneFrame) {
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringIdleAfterDecodedOneFrame) {
   Initialize();
   EnterNormalDecodingState();
   Reset();
 }
 
 // Test resetting when the decoder is in kPendingDemuxerRead state.
-TEST_F(DecryptingVideoDecoderTest, Reset_DuringPendingDemuxerRead) {
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringPendingDemuxerRead) {
   Initialize();
   EnterPendingReadState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, IsNull()));
 
   Reset();
   base::ResetAndReturn(&pending_demuxer_read_cb_).Run(DemuxerStream::kOk,
                                                       encrypted_buffer_);
   message_loop_.RunAllPending();
 }
 
 // Test resetting when the decoder is in kPendingDecode state.
-TEST_F(DecryptingVideoDecoderTest, Reset_DuringPendingDecode) {
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringPendingDecode) {
   Initialize();
   EnterPendingDecodeState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, IsNull()));
 
   Reset();
 }
 
 // Test resetting when the decoder is in kWaitingForKey state.
-TEST_F(DecryptingVideoDecoderTest, Reset_DuringWaitingForKey) {
+TEST_F(DecryptingAudioDecoderTest, Reset_DuringWaitingForKey) {
   Initialize();
   EnterWaitingForKeyState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, IsNull()));
 
   Reset();
 }
 
 // Test resetting when the decoder has hit end of stream and is in
 // kDecodeFinished state.
-TEST_F(DecryptingVideoDecoderTest, Reset_AfterDecodeFinished) {
+TEST_F(DecryptingAudioDecoderTest, Reset_AfterDecodeFinished) {
   Initialize();
   EnterNormalDecodingState();
   EnterEndOfStreamState();
   Reset();
 }
 
 // Test resetting after the decoder has been reset.
-TEST_F(DecryptingVideoDecoderTest, Reset_AfterReset) {
+TEST_F(DecryptingAudioDecoderTest, Reset_AfterReset) {
   Initialize();
   EnterNormalDecodingState();
   Reset();
   Reset();
 }
 
 // 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,
+TEST_F(DecryptingAudioDecoderTest, Stop_DuringDecryptorRequested) {
+  config_.Initialize(kCodecVorbis, 16, CHANNEL_LAYOUT_STEREO, 44100,
                      NULL, 0, true, true);
-  EXPECT_CALL(*demuxer_, video_decoder_config())
+  EXPECT_CALL(*demuxer_, audio_decoder_config())
       .WillRepeatedly(ReturnRef(config_));
-  DecryptingVideoDecoder::DecryptorNotificationCB decryptor_notification_cb;
+  DecryptingAudioDecoder::DecryptorNotificationCB decryptor_notification_cb;
   EXPECT_CALL(*this, RequestDecryptorNotification(_))
       .WillOnce(SaveArg<0>(&decryptor_notification_cb));
   decoder_->Initialize(demuxer_,
                        NewExpectedStatusCB(DECODER_ERROR_NOT_SUPPORTED),
                        base::Bind(&MockStatisticsCB::OnStatistics,
                                   base::Unretained(&statistics_cb_)));
   message_loop_.RunAllPending();
   // |decryptor_notification_cb| is saved but not called here.
   EXPECT_FALSE(decryptor_notification_cb.is_null());
 
   // During stop, RequestDecryptorNotification() should be called with a NULL
   // callback to cancel the |decryptor_notification_cb|.
   EXPECT_CALL(*this, RequestDecryptorNotification(IsNullCallback()))
       .WillOnce(ResetAndRunCallback(&decryptor_notification_cb,
                                     reinterpret_cast<Decryptor*>(NULL)));
   Stop();
 }
 
 // Test stopping when the decoder is in kPendingDecoderInit state.
-TEST_F(DecryptingVideoDecoderTest, Stop_DuringPendingDecoderInit) {
-  EXPECT_CALL(*decryptor_, InitializeVideoDecoderMock(_, _, _))
+TEST_F(DecryptingAudioDecoderTest, Stop_DuringPendingDecoderInit) {
+  EXPECT_CALL(*decryptor_, InitializeAudioDecoderMock(_, _, _))
       .WillOnce(SaveArg<1>(&pending_init_cb_));
 
-  config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
-                     kCodedSize, kVisibleRect, kNaturalSize, NULL, 0, true,
-                     true);
+  config_.Initialize(kCodecVorbis, 16, CHANNEL_LAYOUT_STEREO, 44100,
+                     NULL, 0, true, true);
   InitializeAndExpectStatus(config_, DECODER_ERROR_NOT_SUPPORTED);
   EXPECT_FALSE(pending_init_cb_.is_null());
 
   Stop();
 }
 
 // Test stopping when the decoder is in kIdle state but has not decoded any
 // frame.
-TEST_F(DecryptingVideoDecoderTest, Stop_DuringIdleAfterInitialization) {
+TEST_F(DecryptingAudioDecoderTest, Stop_DuringIdleAfterInitialization) {
   Initialize();
   Stop();
 }
 
 // Test stopping when the decoder is in kIdle state after it has decoded one
 // frame.
-TEST_F(DecryptingVideoDecoderTest, Stop_DuringIdleAfterDecodedOneFrame) {
+TEST_F(DecryptingAudioDecoderTest, Stop_DuringIdleAfterDecodedOneFrame) {
   Initialize();
   EnterNormalDecodingState();
   Stop();
 }
 
 // Test stopping when the decoder is in kPendingDemuxerRead state.
-TEST_F(DecryptingVideoDecoderTest, Stop_DuringPendingDemuxerRead) {
+TEST_F(DecryptingAudioDecoderTest, Stop_DuringPendingDemuxerRead) {
   Initialize();
   EnterPendingReadState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, IsNull()));
 
   Stop();
   base::ResetAndReturn(&pending_demuxer_read_cb_).Run(DemuxerStream::kOk,
                                                       encrypted_buffer_);
   message_loop_.RunAllPending();
 }
 
 // Test stopping when the decoder is in kPendingDecode state.
-TEST_F(DecryptingVideoDecoderTest, Stop_DuringPendingDecode) {
+TEST_F(DecryptingAudioDecoderTest, Stop_DuringPendingDecode) {
   Initialize();
   EnterPendingDecodeState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, IsNull()));
 
   Stop();
 }
 
 // Test stopping when the decoder is in kWaitingForKey state.
-TEST_F(DecryptingVideoDecoderTest, Stop_DuringWaitingForKey) {
+TEST_F(DecryptingAudioDecoderTest, Stop_DuringWaitingForKey) {
   Initialize();
   EnterWaitingForKeyState();
 
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, IsNull()));
 
   Stop();
 }
 
 // Test stopping when the decoder has hit end of stream and is in
 // kDecodeFinished state.
-TEST_F(DecryptingVideoDecoderTest, Stop_AfterDecodeFinished) {
+TEST_F(DecryptingAudioDecoderTest, Stop_AfterDecodeFinished) {
   Initialize();
   EnterNormalDecodingState();
   EnterEndOfStreamState();
   Stop();
 }
 
 // Test stopping when there is a pending reset on the decoder.
-// Reset is pending because it cannot complete when the video decode callback
+// Reset is pending because it cannot complete when the audio decode callback
 // is pending.
-TEST_F(DecryptingVideoDecoderTest, Stop_DuringPendingReset) {
+TEST_F(DecryptingAudioDecoderTest, Stop_DuringPendingReset) {
   Initialize();
   EnterPendingDecodeState();
 
-  EXPECT_CALL(*decryptor_, ResetDecoder(Decryptor::kVideo));
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
+  EXPECT_CALL(*decryptor_, ResetDecoder(Decryptor::kAudio));
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, IsNull()));
 
   decoder_->Reset(NewExpectedClosure());
   Stop();
 }
 
 // Test stopping after the decoder has been reset.
-TEST_F(DecryptingVideoDecoderTest, Stop_AfterReset) {
+TEST_F(DecryptingAudioDecoderTest, Stop_AfterReset) {
   Initialize();
   EnterNormalDecodingState();
   Reset();
   Stop();
 }
 
 // Test stopping after the decoder has been stopped.
-TEST_F(DecryptingVideoDecoderTest, Stop_AfterStop) {
+TEST_F(DecryptingAudioDecoderTest, Stop_AfterStop) {
   Initialize();
   EnterNormalDecodingState();
   Stop();
   Stop();
 }
 
 // Test aborted read on the demuxer stream.
-TEST_F(DecryptingVideoDecoderTest, DemuxerRead_Aborted) {
+TEST_F(DecryptingAudioDecoderTest, DemuxerRead_Aborted) {
   Initialize();
 
   // ReturnBuffer() with NULL triggers aborted demuxer read.
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(ReturnBuffer(scoped_refptr<DecoderBuffer>()));
 
-  ReadAndExpectFrameReadyWith(VideoDecoder::kOk, null_video_frame_);
+  ReadAndExpectFrameReadyWith(AudioDecoder::kOk, NULL);
 }
 
 // Test aborted read on the demuxer stream when the decoder is being reset.
-TEST_F(DecryptingVideoDecoderTest, DemuxerRead_AbortedDuringReset) {
+TEST_F(DecryptingAudioDecoderTest, DemuxerRead_AbortedDuringReset) {
   Initialize();
   EnterPendingReadState();
 
-  // Make sure we get a NULL video frame returned.
-  EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
+  // Make sure we get a NULL audio frame returned.
+  EXPECT_CALL(*this, FrameReady(AudioDecoder::kOk, IsNull()));
 
   Reset();
   base::ResetAndReturn(&pending_demuxer_read_cb_).Run(DemuxerStream::kAborted,
                                                       NULL);
   message_loop_.RunAllPending();
 }
 
 // Test config change on the demuxer stream.
-TEST_F(DecryptingVideoDecoderTest, DemuxerRead_ConfigChanged) {
+TEST_F(DecryptingAudioDecoderTest, DemuxerRead_ConfigChanged) {
   Initialize();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillOnce(ReturnConfigChanged());
 
   // TODO(xhwang): Update this test when kConfigChanged is supported in
-  // DecryptingVideoDecoder.
-  ReadAndExpectFrameReadyWith(VideoDecoder::kDecodeError, null_video_frame_);
+  // DecryptingAudioDecoder.
+  ReadAndExpectFrameReadyWith(AudioDecoder::kDecodeError, NULL);
 }
 
 }  // namespace media