src/media/filters/audio_decoder_selector_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "media/base/gmock_callback_support.h"
  10 #include "media/base/mock_filters.h"
  11 #include "media/filters/audio_decoder_selector.h"
  12 #include "media/filters/decrypting_demuxer_stream.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using ::testing::_;
  16 using ::testing::IsNull;
  17 using ::testing::NiceMock;
  18 using ::testing::NotNull;
  19 using ::testing::Return;
  20 using ::testing::StrictMock;
  21
  22 namespace media {
  23
  24 class AudioDecoderSelectorTest : public ::testing::Test {
  25  public:
  26   enum DecryptorCapability {
  27     kNoDecryptor,
  28     // Used to test Abort() during DecryptingAudioDecoder::Initialize() and
  29     // DecryptingDemuxerStream::Initialize(). We don't need this for normal
  30     // AudioDecoders since we use MockAudioDecoder.
  31     kHoldSetDecryptor,
  32     kDecryptOnly,
  33     kDecryptAndDecode
  34   };
  35
  36   AudioDecoderSelectorTest()
  37       : demuxer_stream_(
  38             new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)),
  39         decryptor_(new NiceMock<MockDecryptor>()),
  40         decoder_1_(new StrictMock<MockAudioDecoder>()),
  41         decoder_2_(new StrictMock<MockAudioDecoder>()) {
  42     all_decoders_.push_back(decoder_1_);
  43     all_decoders_.push_back(decoder_2_);
  44   }
  45
  46   MOCK_METHOD1(OnStatistics, void(const PipelineStatistics&));
  47   MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&));
  48   MOCK_METHOD2(OnDecoderSelected,
  49                void(AudioDecoder*, DecryptingDemuxerStream*));
  50
  51   void MockOnDecoderSelected(
  52       scoped_ptr<AudioDecoder> decoder,
  53       scoped_ptr<DecryptingDemuxerStream> stream) {
  54     OnDecoderSelected(decoder.get(), stream.get());
  55   }
  56
  57   void UseClearStream() {
  58     AudioDecoderConfig clear_audio_config(
  59         kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
  60         NULL, 0, false);
  61     demuxer_stream_->set_audio_decoder_config(clear_audio_config);
  62   }
  63
  64   void UseEncryptedStream() {
  65     AudioDecoderConfig encrypted_audio_config(
  66         kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
  67         NULL, 0, true);
  68     demuxer_stream_->set_audio_decoder_config(encrypted_audio_config);
  69   }
  70
  71   void InitializeDecoderSelector(DecryptorCapability decryptor_capability,
  72                                  int num_decoders) {
  73     SetDecryptorReadyCB set_decryptor_ready_cb;
  74     if (decryptor_capability != kNoDecryptor) {
  75       set_decryptor_ready_cb =
  76           base::Bind(&AudioDecoderSelectorTest::SetDecryptorReadyCallback,
  77                      base::Unretained(this));
  78     }
  79
  80     if (decryptor_capability == kDecryptOnly ||
  81         decryptor_capability == kDecryptAndDecode) {
  82
  83       EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
  84           .WillRepeatedly(RunCallback<0>(decryptor_.get()));
  85
  86       if (decryptor_capability == kDecryptOnly) {
  87         EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _))
  88             .WillRepeatedly(RunCallback<1>(false));
  89       } else {
  90         EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _))
  91             .WillRepeatedly(RunCallback<1>(true));
  92       }
  93     } else if (decryptor_capability == kHoldSetDecryptor) {
  94       // Set DecryptorReadyCB but the callback is never fired.
  95       EXPECT_CALL(*this, SetDecryptorReadyCallback(_));
  96     }
  97
  98     DCHECK_GE(all_decoders_.size(), static_cast<size_t>(num_decoders));
  99     all_decoders_.erase(
 100         all_decoders_.begin() + num_decoders, all_decoders_.end());
 101
 102     decoder_selector_.reset(new AudioDecoderSelector(
 103         message_loop_.message_loop_proxy(),
 104         all_decoders_.Pass(),
 105         set_decryptor_ready_cb));
 106   }
 107
 108   void SelectDecoder() {
 109     decoder_selector_->SelectAudioDecoder(
 110         demuxer_stream_.get(),
 111         base::Bind(&AudioDecoderSelectorTest::OnStatistics,
 112                    base::Unretained(this)),
 113         base::Bind(&AudioDecoderSelectorTest::MockOnDecoderSelected,
 114                    base::Unretained(this)));
 115     message_loop_.RunUntilIdle();
 116   }
 117
 118   void SelectDecoderAndAbort() {
 119     SelectDecoder();
 120
 121     EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 122     decoder_selector_->Abort();
 123     message_loop_.RunUntilIdle();
 124   }
 125
 126   // Fixture members.
 127   scoped_ptr<AudioDecoderSelector> decoder_selector_;
 128   scoped_ptr<StrictMock<MockDemuxerStream> > demuxer_stream_;
 129   // Use NiceMock since we don't care about most of calls on the decryptor, e.g.
 130   // RegisterNewKeyCB().
 131   scoped_ptr<NiceMock<MockDecryptor> > decryptor_;
 132   StrictMock<MockAudioDecoder>* decoder_1_;
 133   StrictMock<MockAudioDecoder>* decoder_2_;
 134   ScopedVector<AudioDecoder> all_decoders_;
 135   base::MessageLoop message_loop_;
 136
 137  private:
 138   DISALLOW_COPY_AND_ASSIGN(AudioDecoderSelectorTest);
 139 };
 140
 141 // The stream is not encrypted but we have no clear decoder. No decoder can be
 142 // selected.
 143 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) {
 144   UseClearStream();
 145   InitializeDecoderSelector(kNoDecryptor, 0);
 146
 147   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 148
 149   SelectDecoder();
 150 }
 151
 152 // The stream is not encrypted and we have one clear decoder. The decoder
 153 // will be selected.
 154 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
 155   UseClearStream();
 156   InitializeDecoderSelector(kNoDecryptor, 1);
 157
 158   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 159       .WillOnce(RunCallback<1>(PIPELINE_OK));
 160   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
 161
 162   SelectDecoder();
 163 }
 164
 165 TEST_F(AudioDecoderSelectorTest,
 166        Abort_ClearStream_NoDecryptor_OneClearDecoder) {
 167   UseClearStream();
 168   InitializeDecoderSelector(kNoDecryptor, 1);
 169
 170   EXPECT_CALL(*decoder_1_, Initialize(_, _, _));
 171
 172   SelectDecoderAndAbort();
 173 }
 174
 175 // The stream is not encrypted and we have multiple clear decoders. The first
 176 // decoder that can decode the input stream will be selected.
 177 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) {
 178   UseClearStream();
 179   InitializeDecoderSelector(kNoDecryptor, 2);
 180
 181   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 182       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
 183   EXPECT_CALL(*decoder_2_, Initialize(_, _, _))
 184       .WillOnce(RunCallback<1>(PIPELINE_OK));
 185   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
 186
 187   SelectDecoder();
 188 }
 189
 190 TEST_F(AudioDecoderSelectorTest,
 191        Abort_ClearStream_NoDecryptor_MultipleClearDecoder) {
 192   UseClearStream();
 193   InitializeDecoderSelector(kNoDecryptor, 2);
 194
 195   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 196       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
 197   EXPECT_CALL(*decoder_2_, Initialize(_, _, _));
 198
 199   SelectDecoderAndAbort();
 200 }
 201
 202 // There is a decryptor but the stream is not encrypted. The decoder will be
 203 // selected.
 204 TEST_F(AudioDecoderSelectorTest, ClearStream_HasDecryptor) {
 205   UseClearStream();
 206   InitializeDecoderSelector(kDecryptOnly, 1);
 207
 208   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 209       .WillOnce(RunCallback<1>(PIPELINE_OK));
 210   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
 211
 212   SelectDecoder();
 213 }
 214
 215 TEST_F(AudioDecoderSelectorTest, Abort_ClearStream_HasDecryptor) {
 216   UseClearStream();
 217   InitializeDecoderSelector(kDecryptOnly, 1);
 218
 219   EXPECT_CALL(*decoder_1_, Initialize(_, _, _));
 220
 221   SelectDecoderAndAbort();
 222 }
 223
 224 // The stream is encrypted and there's no decryptor. No decoder can be selected.
 225 TEST_F(AudioDecoderSelectorTest, EncryptedStream_NoDecryptor) {
 226   UseEncryptedStream();
 227   InitializeDecoderSelector(kNoDecryptor, 1);
 228
 229   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 230
 231   SelectDecoder();
 232 }
 233
 234 // Decryptor can only do decryption and there's no decoder available. No decoder
 235 // can be selected.
 236 TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptOnly_NoClearDecoder) {
 237   UseEncryptedStream();
 238   InitializeDecoderSelector(kDecryptOnly, 0);
 239
 240   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 241
 242   SelectDecoder();
 243 }
 244
 245 TEST_F(AudioDecoderSelectorTest,
 246        Abort_EncryptedStream_DecryptOnly_NoClearDecoder) {
 247   UseEncryptedStream();
 248   InitializeDecoderSelector(kHoldSetDecryptor, 0);
 249
 250   SelectDecoderAndAbort();
 251 }
 252
 253 // Decryptor can do decryption-only and there's a decoder available. The decoder
 254 // will be selected and a DecryptingDemuxerStream will be created.
 255 TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) {
 256   UseEncryptedStream();
 257   InitializeDecoderSelector(kDecryptOnly, 1);
 258
 259   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 260       .WillOnce(RunCallback<1>(PIPELINE_OK));
 261   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull()));
 262
 263   SelectDecoder();
 264 }
 265
 266 TEST_F(AudioDecoderSelectorTest,
 267        Abort_EncryptedStream_DecryptOnly_OneClearDecoder) {
 268   UseEncryptedStream();
 269   InitializeDecoderSelector(kDecryptOnly, 1);
 270
 271   EXPECT_CALL(*decoder_1_, Initialize(_, _, _));
 272
 273   SelectDecoderAndAbort();
 274 }
 275
 276 // Decryptor can only do decryption and there are multiple decoders available.
 277 // The first decoder that can decode the input stream will be selected and
 278 // a DecryptingDemuxerStream will be created.
 279 TEST_F(AudioDecoderSelectorTest,
 280        EncryptedStream_DecryptOnly_MultipleClearDecoder) {
 281   UseEncryptedStream();
 282   InitializeDecoderSelector(kDecryptOnly, 2);
 283
 284   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 285       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
 286   EXPECT_CALL(*decoder_2_, Initialize(_, _, _))
 287       .WillOnce(RunCallback<1>(PIPELINE_OK));
 288   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull()));
 289
 290   SelectDecoder();
 291 }
 292
 293 TEST_F(AudioDecoderSelectorTest,
 294        Abort_EncryptedStream_DecryptOnly_MultipleClearDecoder) {
 295   UseEncryptedStream();
 296   InitializeDecoderSelector(kDecryptOnly, 2);
 297
 298   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 299       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
 300   EXPECT_CALL(*decoder_2_, Initialize(_, _, _));
 301
 302   SelectDecoderAndAbort();
 303 }
 304
 305 // Decryptor can do decryption and decoding. A DecryptingAudioDecoder will be
 306 // created and selected. The clear decoders should not be touched at all.
 307 // No DecryptingDemuxerStream should to be created.
 308 TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptAndDecode) {
 309   UseEncryptedStream();
 310   InitializeDecoderSelector(kDecryptAndDecode, 1);
 311
 312   EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull()));
 313
 314   SelectDecoder();
 315 }
 316
 317 TEST_F(AudioDecoderSelectorTest, Abort_EncryptedStream_DecryptAndDecode) {
 318   UseEncryptedStream();
 319   InitializeDecoderSelector(kHoldSetDecryptor, 1);
 320
 321   SelectDecoderAndAbort();
 322 }
 323
 324 }  // namespace media