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/base/test_helpers.h"
  12 #include "media/filters/decoder_selector.h"
  13 #include "media/filters/decrypting_demuxer_stream.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 using ::testing::_;
  17 using ::testing::InvokeWithoutArgs;
  18 using ::testing::IsNull;
  19 using ::testing::NiceMock;
  20 using ::testing::NotNull;
  21 using ::testing::Return;
  22 using ::testing::StrictMock;
  23
  24 // Use anonymous namespace here to prevent the actions to be defined multiple
  25 // times across multiple test files. Sadly we can't use static for them.
  26 namespace {
  27
  28 ACTION_P3(ExecuteCallbackWithVerifier, decryptor, done_cb, verifier) {
  29   // verifier must be called first since |done_cb| call will invoke it as well.
  30   verifier->RecordACalled();
  31   arg0.Run(decryptor, done_cb);
  32 }
  33
  34 ACTION_P(ReportCallback, verifier) {
  35   verifier->RecordBCalled();
  36 }
  37
  38 }  // namespace
  39
  40 namespace media {
  41
  42 class AudioDecoderSelectorTest : public ::testing::Test {
  43  public:
  44   enum DecryptorCapability {
  45     kNoDecryptor,
  46     // Used to test destruction during DecryptingAudioDecoder::Initialize() and
  47     // DecryptingDemuxerStream::Initialize(). We don't need this for normal
  48     // AudioDecoders since we use MockAudioDecoder.
  49     kHoldSetDecryptor,
  50     kDecryptOnly,
  51     kDecryptAndDecode
  52   };
  53
  54   AudioDecoderSelectorTest()
  55       : demuxer_stream_(
  56             new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)),
  57         decryptor_(new NiceMock<MockDecryptor>()),
  58         decoder_1_(new StrictMock<MockAudioDecoder>()),
  59         decoder_2_(new StrictMock<MockAudioDecoder>()) {
  60     all_decoders_.push_back(decoder_1_);
  61     all_decoders_.push_back(decoder_2_);
  62   }
  63
  64   ~AudioDecoderSelectorTest() {
  65     message_loop_.RunUntilIdle();
  66   }
  67
  68   MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&));
  69   MOCK_METHOD2(OnDecoderSelected,
  70                void(AudioDecoder*, DecryptingDemuxerStream*));
  71   MOCK_METHOD1(DecryptorSet, void(bool));
  72
  73   void MockOnDecoderSelected(scoped_ptr<AudioDecoder> decoder,
  74                              scoped_ptr<DecryptingDemuxerStream> stream) {
  75     OnDecoderSelected(decoder.get(), stream.get());
  76     selected_decoder_ = decoder.Pass();
  77   }
  78
  79   void UseClearStream() {
  80     AudioDecoderConfig clear_audio_config(
  81         kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
  82         NULL, 0, false);
  83     demuxer_stream_->set_audio_decoder_config(clear_audio_config);
  84   }
  85
  86   void UseEncryptedStream() {
  87     AudioDecoderConfig encrypted_audio_config(
  88         kCodecVorbis, kSampleFormatPlanarF32, CHANNEL_LAYOUT_STEREO, 44100,
  89         NULL, 0, true);
  90     demuxer_stream_->set_audio_decoder_config(encrypted_audio_config);
  91   }
  92
  93   void InitializeDecoderSelector(DecryptorCapability decryptor_capability,
  94                                  int num_decoders) {
  95     SetDecryptorReadyCB set_decryptor_ready_cb;
  96     if (decryptor_capability != kNoDecryptor) {
  97       set_decryptor_ready_cb =
  98           base::Bind(&AudioDecoderSelectorTest::SetDecryptorReadyCallback,
  99                      base::Unretained(this));
 100     }
 101
 102     if (decryptor_capability == kDecryptOnly ||
 103         decryptor_capability == kDecryptAndDecode) {
 104       EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
 105           .WillRepeatedly(ExecuteCallbackWithVerifier(
 106               decryptor_.get(),
 107               base::Bind(&AudioDecoderSelectorTest::DecryptorSet,
 108                          base::Unretained(this)),
 109               &verifier_));
 110       EXPECT_CALL(*this, DecryptorSet(true))
 111           .WillRepeatedly(ReportCallback(&verifier_));
 112
 113       if (decryptor_capability == kDecryptOnly) {
 114         EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _))
 115             .WillRepeatedly(RunCallback<1>(false));
 116       } else {
 117         EXPECT_CALL(*decryptor_, InitializeAudioDecoder(_, _))
 118             .WillRepeatedly(RunCallback<1>(true));
 119       }
 120     } else if (decryptor_capability == kHoldSetDecryptor) {
 121       // Set and cancel DecryptorReadyCB but the callback is never fired.
 122       EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
 123           .Times(2);
 124     }
 125
 126     DCHECK_GE(all_decoders_.size(), static_cast<size_t>(num_decoders));
 127     all_decoders_.erase(
 128         all_decoders_.begin() + num_decoders, all_decoders_.end());
 129
 130     decoder_selector_.reset(new AudioDecoderSelector(
 131         message_loop_.message_loop_proxy(),
 132         all_decoders_.Pass(),
 133         set_decryptor_ready_cb));
 134   }
 135
 136   void SelectDecoder() {
 137     decoder_selector_->SelectDecoder(
 138         demuxer_stream_.get(),
 139         false,
 140         base::Bind(&AudioDecoderSelectorTest::MockOnDecoderSelected,
 141                    base::Unretained(this)),
 142         base::Bind(&AudioDecoderSelectorTest::OnDecoderOutput));
 143     message_loop_.RunUntilIdle();
 144   }
 145
 146   void SelectDecoderAndDestroy() {
 147     SelectDecoder();
 148
 149     EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 150     decoder_selector_.reset();
 151     message_loop_.RunUntilIdle();
 152   }
 153
 154   static void OnDecoderOutput(const scoped_refptr<AudioBuffer>& output) {
 155     NOTREACHED();
 156   }
 157
 158   // Declare |decoder_selector_| after |demuxer_stream_| and |decryptor_| since
 159   // |demuxer_stream_| and |decryptor_| should outlive |decoder_selector_|.
 160   scoped_ptr<StrictMock<MockDemuxerStream> > demuxer_stream_;
 161
 162   // Use NiceMock since we don't care about most of calls on the decryptor, e.g.
 163   // RegisterNewKeyCB().
 164   scoped_ptr<NiceMock<MockDecryptor> > decryptor_;
 165
 166   scoped_ptr<AudioDecoderSelector> decoder_selector_;
 167
 168   StrictMock<MockAudioDecoder>* decoder_1_;
 169   StrictMock<MockAudioDecoder>* decoder_2_;
 170   ScopedVector<AudioDecoder> all_decoders_;
 171   scoped_ptr<AudioDecoder> selected_decoder_;
 172
 173   base::MessageLoop message_loop_;
 174
 175   CallbackPairChecker verifier_;
 176
 177  private:
 178   DISALLOW_COPY_AND_ASSIGN(AudioDecoderSelectorTest);
 179 };
 180
 181 // The stream is not encrypted but we have no clear decoder. No decoder can be
 182 // selected.
 183 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) {
 184   UseClearStream();
 185   InitializeDecoderSelector(kNoDecryptor, 0);
 186
 187   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 188
 189   SelectDecoder();
 190 }
 191
 192 // The stream is not encrypted and we have one clear decoder. The decoder
 193 // will be selected.
 194 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
 195   UseClearStream();
 196   InitializeDecoderSelector(kNoDecryptor, 1);
 197
 198   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 199       .WillOnce(RunCallback<1>(PIPELINE_OK));
 200   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
 201
 202   SelectDecoder();
 203 }
 204
 205 TEST_F(AudioDecoderSelectorTest,
 206        Destroy_ClearStream_NoDecryptor_OneClearDecoder) {
 207   UseClearStream();
 208   InitializeDecoderSelector(kNoDecryptor, 1);
 209
 210   EXPECT_CALL(*decoder_1_, Initialize(_, _, _));
 211
 212   SelectDecoderAndDestroy();
 213 }
 214
 215 // The stream is not encrypted and we have multiple clear decoders. The first
 216 // decoder that can decode the input stream will be selected.
 217 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) {
 218   UseClearStream();
 219   InitializeDecoderSelector(kNoDecryptor, 2);
 220
 221   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 222       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
 223   EXPECT_CALL(*decoder_2_, Initialize(_, _, _))
 224       .WillOnce(RunCallback<1>(PIPELINE_OK));
 225   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
 226
 227   SelectDecoder();
 228 }
 229
 230 TEST_F(AudioDecoderSelectorTest,
 231        Destroy_ClearStream_NoDecryptor_MultipleClearDecoder) {
 232   UseClearStream();
 233   InitializeDecoderSelector(kNoDecryptor, 2);
 234
 235   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 236       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
 237   EXPECT_CALL(*decoder_2_, Initialize(_, _, _));
 238
 239   SelectDecoderAndDestroy();
 240 }
 241
 242 // There is a decryptor but the stream is not encrypted. The decoder will be
 243 // selected.
 244 TEST_F(AudioDecoderSelectorTest, ClearStream_HasDecryptor) {
 245   UseClearStream();
 246   InitializeDecoderSelector(kDecryptOnly, 1);
 247
 248   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 249       .WillOnce(RunCallback<1>(PIPELINE_OK));
 250   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
 251
 252   SelectDecoder();
 253 }
 254
 255 TEST_F(AudioDecoderSelectorTest, Destroy_ClearStream_HasDecryptor) {
 256   UseClearStream();
 257   InitializeDecoderSelector(kDecryptOnly, 1);
 258
 259   EXPECT_CALL(*decoder_1_, Initialize(_, _, _));
 260
 261   SelectDecoderAndDestroy();
 262 }
 263
 264 // The stream is encrypted and there's no decryptor. No decoder can be selected.
 265 TEST_F(AudioDecoderSelectorTest, EncryptedStream_NoDecryptor) {
 266   UseEncryptedStream();
 267   InitializeDecoderSelector(kNoDecryptor, 1);
 268
 269   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 270
 271   SelectDecoder();
 272 }
 273
 274 // Decryptor can only do decryption and there's no decoder available. No decoder
 275 // can be selected.
 276 TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptOnly_NoClearDecoder) {
 277   UseEncryptedStream();
 278   InitializeDecoderSelector(kDecryptOnly, 0);
 279
 280   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 281
 282   SelectDecoder();
 283 }
 284
 285 TEST_F(AudioDecoderSelectorTest,
 286        Destroy_EncryptedStream_DecryptOnly_NoClearDecoder) {
 287   UseEncryptedStream();
 288   InitializeDecoderSelector(kHoldSetDecryptor, 0);
 289
 290   SelectDecoderAndDestroy();
 291 }
 292
 293 // Decryptor can do decryption-only and there's a decoder available. The decoder
 294 // will be selected and a DecryptingDemuxerStream will be created.
 295 TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) {
 296   UseEncryptedStream();
 297   InitializeDecoderSelector(kDecryptOnly, 1);
 298
 299   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 300       .WillOnce(RunCallback<1>(PIPELINE_OK));
 301   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull()));
 302
 303   SelectDecoder();
 304 }
 305
 306 TEST_F(AudioDecoderSelectorTest,
 307        Destroy_EncryptedStream_DecryptOnly_OneClearDecoder) {
 308   UseEncryptedStream();
 309   InitializeDecoderSelector(kDecryptOnly, 1);
 310
 311   EXPECT_CALL(*decoder_1_, Initialize(_, _, _));
 312
 313   SelectDecoderAndDestroy();
 314 }
 315
 316 // Decryptor can only do decryption and there are multiple decoders available.
 317 // The first decoder that can decode the input stream will be selected and
 318 // a DecryptingDemuxerStream will be created.
 319 TEST_F(AudioDecoderSelectorTest,
 320        EncryptedStream_DecryptOnly_MultipleClearDecoder) {
 321   UseEncryptedStream();
 322   InitializeDecoderSelector(kDecryptOnly, 2);
 323
 324   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 325       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
 326   EXPECT_CALL(*decoder_2_, Initialize(_, _, _))
 327       .WillOnce(RunCallback<1>(PIPELINE_OK));
 328   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull()));
 329
 330   SelectDecoder();
 331 }
 332
 333 TEST_F(AudioDecoderSelectorTest,
 334        Destroy_EncryptedStream_DecryptOnly_MultipleClearDecoder) {
 335   UseEncryptedStream();
 336   InitializeDecoderSelector(kDecryptOnly, 2);
 337
 338   EXPECT_CALL(*decoder_1_, Initialize(_, _, _))
 339       .WillOnce(RunCallback<1>(DECODER_ERROR_NOT_SUPPORTED));
 340   EXPECT_CALL(*decoder_2_, Initialize(_, _, _));
 341
 342   SelectDecoderAndDestroy();
 343 }
 344
 345 // Decryptor can do decryption and decoding. A DecryptingAudioDecoder will be
 346 // created and selected. The clear decoders should not be touched at all.
 347 // No DecryptingDemuxerStream should to be created.
 348 TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptAndDecode) {
 349   UseEncryptedStream();
 350   InitializeDecoderSelector(kDecryptAndDecode, 1);
 351
 352   EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull()));
 353
 354   SelectDecoder();
 355 }
 356
 357 TEST_F(AudioDecoderSelectorTest, Destroy_EncryptedStream_DecryptAndDecode) {
 358   UseEncryptedStream();
 359   InitializeDecoderSelector(kHoldSetDecryptor, 1);
 360
 361   SelectDecoderAndDestroy();
 362 }
 363
 364 }  // namespace media