Encrypted Media: Support Audio Decrypt-Only.

media/filters/audio_renderer_impl_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 "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/gtest_prod_util.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/data_buffer.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/mock_audio_renderer_sink.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/filters/audio_renderer_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Invoke;
 using ::testing::Return;
+using ::testing::ReturnRef;
 using ::testing::NiceMock;
 using ::testing::StrictMock;
 
 namespace media {
 
 // Constants for distinguishing between muted audio and playing audio when using
 // ConsumeBufferedData().
 static uint8 kMutedAudio = 0x00;
 static uint8 kPlayingAudio = 0x99;
 
 class AudioRendererImplTest : public ::testing::Test {
  public:
   // Give the decoder some non-garbage media properties.
   AudioRendererImplTest()
-      : renderer_(new AudioRendererImpl(new NiceMock<MockAudioRendererSink>())),
+      : renderer_(new AudioRendererImpl(new NiceMock<MockAudioRendererSink>(),
+                                        SetDecryptorReadyCB())),
         demuxer_stream_(new MockDemuxerStream()),
-        decoder_(new MockAudioDecoder()) {
+        decoder_(new MockAudioDecoder()),
+        audio_config_(kCodecVorbis, 16, 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_));
 
     // Queue all reads from the decoder by default.
     ON_CALL(*decoder_, Read(_))
         .WillByDefault(Invoke(this, &AudioRendererImplTest::SaveReadCallback));
 
     // Set up audio properties.
     SetSupportedAudioDecoderProperties();
     EXPECT_CALL(*decoder_, bits_per_channel())
         .Times(AnyNumber());
     EXPECT_CALL(*decoder_, channel_layout())
@@ skipping 177 matching lines @@
     renderer_->ResumeAfterUnderflow(false);
   }
 
   // Fixture members.
   scoped_refptr<AudioRendererImpl> renderer_;
   scoped_refptr<MockDemuxerStream> demuxer_stream_;
   scoped_refptr<MockAudioDecoder> decoder_;
   AudioRendererImpl::AudioDecoderList decoders_;
   AudioDecoder::ReadCB read_cb_;
   scoped_ptr<AudioTimestampHelper> next_timestamp_;
+  AudioDecoderConfig audio_config_;
   MessageLoop message_loop_;
 
  private:
   void SaveReadCallback(const AudioDecoder::ReadCB& callback) {
     CHECK(read_cb_.is_null()) << "Overlapping reads are not permitted";
     read_cb_ = callback;
   }
 
   DISALLOW_COPY_AND_ASSIGN(AudioRendererImplTest);
 };
@@ skipping 11 matching lines @@
 
 TEST_F(AudioRendererImplTest, Initialize_Successful) {
   Initialize();
 
   // We should have no reads.
   EXPECT_TRUE(read_cb_.is_null());
 }
 
 TEST_F(AudioRendererImplTest, Initialize_DecoderInitFailure) {
   EXPECT_CALL(*decoder_, Initialize(_, _, _))
-      .WillOnce(RunCallback<1>(PIPELINE_ERROR_DECODE));
-  InitializeWithStatus(PIPELINE_ERROR_DECODE);
+      .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
+  InitializeWithStatus(DECODER_ERROR_NOT_SUPPORTED);
 
   // We should have no reads.
   EXPECT_TRUE(read_cb_.is_null());
 }
 
 TEST_F(AudioRendererImplTest, Initialize_MultipleDecoders) {
   scoped_refptr<MockAudioDecoder> decoder1 = new MockAudioDecoder();
   // Insert |decoder1| as the first decoder in the list.
   decoders_.push_front(decoder1);
   EXPECT_CALL(*decoder1, Initialize(_, _, _))
@@ skipping 193 matching lines @@
   EXPECT_TRUE(ConsumeBufferedData(bytes_buffered() / 2, NULL));
 
   renderer_->Pause(NewExpectedClosure());
 
   AbortPendingRead();
 
   Preroll(base::TimeDelta::FromSeconds(1));
 }
 
 }  // namespace media