media/filters/decrypting_demuxer_stream_unittest.cc

   1 // Copyright 2012 The Chromium Authors
   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 "media/filters/decrypting_demuxer_stream.h"
   6
   7 #include <stdint.h>
   8
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/callback_helpers.h"
  14 #include "base/run_loop.h"
  15 #include "base/test/gmock_callback_support.h"
  16 #include "base/test/gmock_move_support.h"
  17 #include "base/test/task_environment.h"
  18 #include "media/base/decoder_buffer.h"
  19 #include "media/base/decrypt_config.h"
  20 #include "media/base/media_util.h"
  21 #include "media/base/mock_filters.h"
  22 #include "media/base/mock_media_log.h"
  23 #include "media/base/test_helpers.h"
  24 #include "testing/gmock/include/gmock/gmock.h"
  25
  26 using ::base::test::RunCallback;
  27 using ::base::test::RunOnceCallback;
  28 using ::testing::_;
  29 using ::testing::HasSubstr;
  30 using ::testing::InSequence;
  31 using ::testing::Invoke;
  32 using ::testing::InvokeWithoutArgs;
  33 using ::testing::IsNull;
  34 using ::testing::Return;
  35 using ::testing::SaveArg;
  36 using ::testing::StrictMock;
  37 using ::testing::WithArg;
  38
  39 namespace media {
  40
  41 static const int kFakeBufferSize = 16;
  42 static const uint8_t kFakeKeyId[] = {0x4b, 0x65, 0x79, 0x20, 0x49, 0x44};
  43 static const uint8_t kFakeIv[DecryptConfig::kDecryptionKeySize] = {0};
  44
  45 // Create a fake non-empty buffer in an encrypted stream. When |is_clear| is
  46 // true, the buffer is not encrypted (signaled by an empty IV).
  47 static scoped_refptr<DecoderBuffer> CreateFakeEncryptedStreamBuffer(
  48     bool is_clear) {
  49   scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(kFakeBufferSize));
  50   std::string iv = is_clear
  51                        ? std::string()
  52                        : std::string(reinterpret_cast<const char*>(kFakeIv),
  53                                      std::size(kFakeIv));
  54   if (!is_clear) {
  55     buffer->set_decrypt_config(DecryptConfig::CreateCencConfig(
  56         std::string(reinterpret_cast<const char*>(kFakeKeyId),
  57                     std::size(kFakeKeyId)),
  58         iv, {}));
  59   }
  60   return buffer;
  61 }
  62
  63 // Use anonymous namespace here to prevent the actions to be defined multiple
  64 // times across multiple test files. Sadly we can't use static for them.
  65 namespace {
  66
  67 ACTION_P(ReturnBuffer, buffer) {
  68   std::move(arg0).Run(
  69       buffer.get() ? DemuxerStream::kOk : DemuxerStream::kAborted, buffer);
  70 }
  71
  72 }  // namespace
  73
  74 class DecryptingDemuxerStreamTest : public testing::Test {
  75  public:
  76   DecryptingDemuxerStreamTest()
  77       : demuxer_stream_(new DecryptingDemuxerStream(
  78             task_environment_.GetMainThreadTaskRunner(),
  79             &media_log_,
  80             base::BindRepeating(&DecryptingDemuxerStreamTest::OnWaiting,
  81                                 base::Unretained(this)))),
  82         cdm_context_(new StrictMock<MockCdmContext>()),
  83         decryptor_(new StrictMock<MockDecryptor>()),
  84         is_initialized_(false),
  85         input_audio_stream_(
  86             new StrictMock<MockDemuxerStream>(DemuxerStream::AUDIO)),
  87         input_video_stream_(
  88             new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
  89         clear_buffer_(new DecoderBuffer(kFakeBufferSize)),
  90         clear_encrypted_stream_buffer_(CreateFakeEncryptedStreamBuffer(true)),
  91         encrypted_buffer_(CreateFakeEncryptedStreamBuffer(false)),
  92         decrypted_buffer_(new DecoderBuffer(kFakeBufferSize)) {}
  93
  94   DecryptingDemuxerStreamTest(const DecryptingDemuxerStreamTest&) = delete;
  95   DecryptingDemuxerStreamTest& operator=(const DecryptingDemuxerStreamTest&) =
  96       delete;
  97
  98   ~DecryptingDemuxerStreamTest() override {
  99     if (is_initialized_)
 100       EXPECT_CALL(*decryptor_, CancelDecrypt(_));
 101     demuxer_stream_.reset();
 102     base::RunLoop().RunUntilIdle();
 103   }
 104
 105   void OnInitialized(PipelineStatus expected_status, PipelineStatus status) {
 106     EXPECT_EQ(expected_status, status);
 107     is_initialized_ = status == PIPELINE_OK;
 108   }
 109
 110   void InitializeAudioAndExpectStatus(const AudioDecoderConfig& config,
 111                                       PipelineStatus expected_status) {
 112     input_audio_stream_->set_audio_decoder_config(config);
 113     demuxer_stream_->Initialize(
 114         input_audio_stream_.get(), cdm_context_.get(),
 115         base::BindOnce(&DecryptingDemuxerStreamTest::OnInitialized,
 116                        base::Unretained(this), expected_status));
 117     base::RunLoop().RunUntilIdle();
 118   }
 119
 120   void InitializeVideoAndExpectStatus(const VideoDecoderConfig& config,
 121                                       PipelineStatus expected_status) {
 122     input_video_stream_->set_video_decoder_config(config);
 123     demuxer_stream_->Initialize(
 124         input_video_stream_.get(), cdm_context_.get(),
 125         base::BindOnce(&DecryptingDemuxerStreamTest::OnInitialized,
 126                        base::Unretained(this), expected_status));
 127     base::RunLoop().RunUntilIdle();
 128   }
 129
 130   enum CdmType { CDM_WITHOUT_DECRYPTOR, CDM_WITH_DECRYPTOR };
 131
 132   void SetCdmType(CdmType cdm_type) {
 133     const bool has_decryptor = cdm_type == CDM_WITH_DECRYPTOR;
 134     EXPECT_CALL(*cdm_context_, GetDecryptor())
 135         .WillRepeatedly(Return(has_decryptor ? decryptor_.get() : nullptr));
 136   }
 137
 138   // The following functions are used to test stream-type-neutral logic in
 139   // DecryptingDemuxerStream. Therefore, we don't specify audio or video in the
 140   // function names. But for testing purpose, they all use an audio input
 141   // demuxer stream.
 142
 143   void Initialize(int audio_init_times = 1, int video_init_times = 1) {
 144     SetCdmType(CDM_WITH_DECRYPTOR);
 145     EXPECT_CALL(*cdm_context_, RegisterEventCB(_)).WillOnce([&](auto cb) {
 146       event_cb_ = cb;
 147       return std::make_unique<CallbackRegistration>();
 148     });
 149
 150     AudioDecoderConfig input_config(AudioCodec::kVorbis, kSampleFormatPlanarF32,
 151                                     CHANNEL_LAYOUT_STEREO, 44100,
 152                                     EmptyExtraData(), EncryptionScheme::kCenc);
 153
 154     EXPECT_MEDIA_LOG(HasSubstr("kAudioTracks")).Times(audio_init_times);
 155     EXPECT_MEDIA_LOG(HasSubstr("kVideoTracks")).Times(video_init_times);
 156
 157     InitializeAudioAndExpectStatus(input_config, PIPELINE_OK);
 158
 159     const AudioDecoderConfig& output_config =
 160         demuxer_stream_->audio_decoder_config();
 161
 162     EXPECT_EQ(DemuxerStream::AUDIO, demuxer_stream_->type());
 163     EXPECT_FALSE(output_config.is_encrypted());
 164     EXPECT_EQ(input_config.bits_per_channel(),
 165               output_config.bits_per_channel());
 166     EXPECT_EQ(input_config.channel_layout(), output_config.channel_layout());
 167     EXPECT_EQ(input_config.sample_format(), output_config.sample_format());
 168     EXPECT_EQ(input_config.samples_per_second(),
 169               output_config.samples_per_second());
 170   }
 171
 172   void ReadAndExpectBufferReadyWith(
 173       DemuxerStream::Status status,
 174       scoped_refptr<DecoderBuffer> decrypted_buffer) {
 175     if (status != DemuxerStream::kOk)
 176       EXPECT_CALL(*this, BufferReady(status, IsNull()));
 177     else if (decrypted_buffer->end_of_stream())
 178       EXPECT_CALL(*this, BufferReady(status, IsEndOfStream()));
 179     else
 180       EXPECT_CALL(*this, BufferReady(status, decrypted_buffer));
 181
 182     demuxer_stream_->Read(base::BindOnce(
 183         &DecryptingDemuxerStreamTest::BufferReady, base::Unretained(this)));
 184     base::RunLoop().RunUntilIdle();
 185   }
 186
 187   void EnterClearReadingState(bool is_stream_encrypted) {
 188     // Unencrypted streams never have a DecryptConfig.
 189     EXPECT_FALSE(clear_encrypted_stream_buffer_->decrypt_config());
 190     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 191         .WillOnce(ReturnBuffer(is_stream_encrypted
 192                                    ? clear_encrypted_stream_buffer_
 193                                    : clear_buffer_));
 194
 195     // For clearbuffer, decryptor->Decrypt() will not be called.
 196
 197     scoped_refptr<DecoderBuffer> decrypted_buffer;
 198     EXPECT_CALL(*this, BufferReady(DemuxerStream::kOk, _))
 199         .WillOnce(SaveArg<1>(&decrypted_buffer));
 200     demuxer_stream_->Read(base::BindOnce(
 201         &DecryptingDemuxerStreamTest::BufferReady, base::Unretained(this)));
 202     base::RunLoop().RunUntilIdle();
 203
 204     EXPECT_FALSE(decrypted_buffer->decrypt_config());
 205   }
 206
 207   // Sets up expectations and actions to put DecryptingDemuxerStream in an
 208   // active normal reading state.
 209   void EnterNormalReadingState() {
 210     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 211         .WillOnce(ReturnBuffer(encrypted_buffer_));
 212     EXPECT_CALL(*decryptor_, Decrypt(_, _, _))
 213         .WillOnce(RunOnceCallback<2>(Decryptor::kSuccess, decrypted_buffer_));
 214
 215     ReadAndExpectBufferReadyWith(DemuxerStream::kOk, decrypted_buffer_);
 216   }
 217
 218   // Make the read callback pending by saving and not firing it.
 219   void EnterPendingReadState() {
 220     EXPECT_TRUE(!pending_demuxer_read_cb_);
 221     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 222         .WillOnce(MoveArg<0>(&pending_demuxer_read_cb_));
 223     demuxer_stream_->Read(base::BindOnce(
 224         &DecryptingDemuxerStreamTest::BufferReady, base::Unretained(this)));
 225     base::RunLoop().RunUntilIdle();
 226     // Make sure the Read() triggers a Read() on the input demuxer stream.
 227     EXPECT_FALSE(!pending_demuxer_read_cb_);
 228   }
 229
 230   // Make the decrypt callback pending by intercepting the call and not firing
 231   // the callback.
 232   void EnterPendingDecryptState() {
 233     EXPECT_TRUE(!pending_decrypt_cb_);
 234     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 235         .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
 236     EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 237         .WillOnce(WithArg<2>(Invoke([&](Decryptor::DecryptCB callback) {
 238           pending_decrypt_cb_ = std::move(callback);
 239         })));
 240
 241     demuxer_stream_->Read(base::BindOnce(
 242         &DecryptingDemuxerStreamTest::BufferReady, base::Unretained(this)));
 243     base::RunLoop().RunUntilIdle();
 244     // Make sure Read() triggers a Decrypt() on the decryptor.
 245     EXPECT_FALSE(!pending_decrypt_cb_);
 246   }
 247
 248   void EnterWaitingForKeyState() {
 249     InSequence s;
 250     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 251         .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
 252     EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 253         .WillRepeatedly(RunOnceCallback<2>(Decryptor::kNoKey,
 254                                            scoped_refptr<DecoderBuffer>()));
 255     EXPECT_MEDIA_LOG(HasSubstr("DecryptingDemuxerStream: no key for key ID"));
 256     EXPECT_CALL(*this, OnWaiting(WaitingReason::kNoDecryptionKey));
 257     demuxer_stream_->Read(base::BindOnce(
 258         &DecryptingDemuxerStreamTest::BufferReady, base::Unretained(this)));
 259     base::RunLoop().RunUntilIdle();
 260   }
 261
 262   void AbortPendingDecryptCB() {
 263     if (pending_decrypt_cb_) {
 264       std::move(pending_decrypt_cb_).Run(Decryptor::kSuccess, nullptr);
 265     }
 266   }
 267
 268   void SatisfyPendingDemuxerReadCB(DemuxerStream::Status status) {
 269     scoped_refptr<DecoderBuffer> buffer =
 270         (status == DemuxerStream::kOk) ? encrypted_buffer_ : nullptr;
 271     std::move(pending_demuxer_read_cb_).Run(status, buffer);
 272   }
 273
 274   void Reset() {
 275     EXPECT_CALL(*decryptor_, CancelDecrypt(Decryptor::kAudio))
 276         .WillRepeatedly(InvokeWithoutArgs(
 277             this, &DecryptingDemuxerStreamTest::AbortPendingDecryptCB));
 278
 279     demuxer_stream_->Reset(NewExpectedClosure());
 280     base::RunLoop().RunUntilIdle();
 281   }
 282
 283   MOCK_METHOD2(BufferReady,
 284                void(DemuxerStream::Status, scoped_refptr<DecoderBuffer>));
 285   MOCK_METHOD1(OnWaiting, void(WaitingReason));
 286
 287   base::test::SingleThreadTaskEnvironment task_environment_;
 288   StrictMock<MockMediaLog> media_log_;
 289   std::unique_ptr<DecryptingDemuxerStream> demuxer_stream_;
 290   std::unique_ptr<StrictMock<MockCdmContext>> cdm_context_;
 291   std::unique_ptr<StrictMock<MockDecryptor>> decryptor_;
 292   // Whether the |demuxer_stream_| is successfully initialized.
 293   bool is_initialized_;
 294   std::unique_ptr<StrictMock<MockDemuxerStream>> input_audio_stream_;
 295   std::unique_ptr<StrictMock<MockDemuxerStream>> input_video_stream_;
 296
 297   DemuxerStream::ReadCB pending_demuxer_read_cb_;
 298   CdmContext::EventCB event_cb_;
 299   Decryptor::DecryptCB pending_decrypt_cb_;
 300
 301   // Constant buffers to be returned by the input demuxer streams and the
 302   // |decryptor_|.
 303   scoped_refptr<DecoderBuffer> clear_buffer_;
 304   scoped_refptr<DecoderBuffer> clear_encrypted_stream_buffer_;
 305   scoped_refptr<DecoderBuffer> encrypted_buffer_;
 306   scoped_refptr<DecoderBuffer> decrypted_buffer_;
 307 };
 308
 309 TEST_F(DecryptingDemuxerStreamTest, Initialize_NormalAudio) {
 310   Initialize();
 311 }
 312
 313 TEST_F(DecryptingDemuxerStreamTest, Initialize_NormalVideo) {
 314   SetCdmType(CDM_WITH_DECRYPTOR);
 315   EXPECT_CALL(*cdm_context_, RegisterEventCB(_)).WillOnce([&](auto cb) {
 316     event_cb_ = cb;
 317     return std::make_unique<CallbackRegistration>();
 318   });
 319
 320   VideoDecoderConfig input_config = TestVideoConfig::NormalEncrypted();
 321   EXPECT_MEDIA_LOG(HasSubstr("kAudioTracks"));
 322   EXPECT_MEDIA_LOG(HasSubstr("kVideoTracks"));
 323   InitializeVideoAndExpectStatus(input_config, PIPELINE_OK);
 324
 325   const VideoDecoderConfig& output_config =
 326       demuxer_stream_->video_decoder_config();
 327   EXPECT_EQ(DemuxerStream::VIDEO, demuxer_stream_->type());
 328   EXPECT_FALSE(output_config.is_encrypted());
 329   EXPECT_EQ(input_config.codec(), output_config.codec());
 330   EXPECT_EQ(input_config.alpha_mode(), output_config.alpha_mode());
 331   EXPECT_EQ(input_config.profile(), output_config.profile());
 332   EXPECT_EQ(input_config.coded_size(), output_config.coded_size());
 333   EXPECT_EQ(input_config.visible_rect(), output_config.visible_rect());
 334   EXPECT_EQ(input_config.natural_size(), output_config.natural_size());
 335   ASSERT_EQ(input_config.extra_data(), output_config.extra_data());
 336 }
 337
 338 TEST_F(DecryptingDemuxerStreamTest, Initialize_CdmWithoutDecryptor) {
 339   SetCdmType(CDM_WITHOUT_DECRYPTOR);
 340   AudioDecoderConfig input_config(AudioCodec::kVorbis, kSampleFormatPlanarF32,
 341                                   CHANNEL_LAYOUT_STEREO, 44100,
 342                                   EmptyExtraData(), EncryptionScheme::kCenc);
 343   EXPECT_MEDIA_LOG(HasSubstr("kAudioTracks"));
 344   EXPECT_MEDIA_LOG(HasSubstr("kVideoTracks"));
 345   InitializeAudioAndExpectStatus(input_config, DECODER_ERROR_NOT_SUPPORTED);
 346 }
 347
 348 // Test normal read case where the buffer is encrypted.
 349 TEST_F(DecryptingDemuxerStreamTest, Read_Normal) {
 350   Initialize();
 351   EnterNormalReadingState();
 352 }
 353
 354 // Test normal read case where the buffer is clear.
 355 TEST_F(DecryptingDemuxerStreamTest, Read_ClearBufferInEncryptedStream) {
 356   Initialize();
 357   EnterClearReadingState(true);
 358 }
 359
 360 TEST_F(DecryptingDemuxerStreamTest, Read_ClearBufferInClearStream) {
 361   Initialize();
 362   EnterClearReadingState(false);
 363 }
 364
 365 // Test the case where the decryptor returns error during read.
 366 TEST_F(DecryptingDemuxerStreamTest, Read_DecryptError) {
 367   Initialize();
 368
 369   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 370       .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
 371   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 372       .WillRepeatedly(RunOnceCallback<2>(Decryptor::kError,
 373                                          scoped_refptr<DecoderBuffer>()));
 374   EXPECT_MEDIA_LOG(HasSubstr("DecryptingDemuxerStream: decrypt error"));
 375   ReadAndExpectBufferReadyWith(DemuxerStream::kError, nullptr);
 376 }
 377
 378 // Test the case where the decryptor returns kNeedMoreData during read.
 379 TEST_F(DecryptingDemuxerStreamTest, Read_DecryptNeedMoreData) {
 380   Initialize();
 381
 382   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 383       .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
 384   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 385       .WillRepeatedly(RunOnceCallback<2>(Decryptor::kNeedMoreData,
 386                                          scoped_refptr<DecoderBuffer>()));
 387   EXPECT_MEDIA_LOG(HasSubstr("DecryptingDemuxerStream: decrypt error"));
 388   ReadAndExpectBufferReadyWith(DemuxerStream::kError, nullptr);
 389 }
 390
 391 // Test the case where the input is an end-of-stream buffer.
 392 TEST_F(DecryptingDemuxerStreamTest, Read_EndOfStream) {
 393   Initialize();
 394   EnterNormalReadingState();
 395
 396   // No Decryptor::Decrypt() call is expected for EOS buffer.
 397   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 398       .WillOnce(ReturnBuffer(DecoderBuffer::CreateEOSBuffer()));
 399
 400   ReadAndExpectBufferReadyWith(DemuxerStream::kOk,
 401                                DecoderBuffer::CreateEOSBuffer());
 402 }
 403
 404 // Test the case where the a key is added when the decryptor is in
 405 // kWaitingForKey state.
 406 TEST_F(DecryptingDemuxerStreamTest, KeyAdded_DuringWaitingForKey) {
 407   Initialize();
 408   EnterWaitingForKeyState();
 409
 410   EXPECT_MEDIA_LOG(
 411       HasSubstr("DecryptingDemuxerStream: key was added, resuming decrypt"));
 412   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 413       .WillRepeatedly(
 414           RunOnceCallback<2>(Decryptor::kSuccess, decrypted_buffer_));
 415   EXPECT_CALL(*this, BufferReady(DemuxerStream::kOk, decrypted_buffer_));
 416   event_cb_.Run(CdmContext::Event::kHasAdditionalUsableKey);
 417   base::RunLoop().RunUntilIdle();
 418 }
 419
 420 // Test the case where the a key is added when the decryptor is in
 421 // kPendingDecrypt state.
 422 TEST_F(DecryptingDemuxerStreamTest, KeyAdded_DuringPendingDecrypt) {
 423   Initialize();
 424   EnterPendingDecryptState();
 425
 426   EXPECT_MEDIA_LOG(HasSubstr("DecryptingDemuxerStream: no key for key ID"));
 427   EXPECT_MEDIA_LOG(
 428       HasSubstr("DecryptingDemuxerStream: key was added, resuming decrypt"));
 429   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 430       .WillRepeatedly(
 431           RunOnceCallback<2>(Decryptor::kSuccess, decrypted_buffer_));
 432   EXPECT_CALL(*this, BufferReady(DemuxerStream::kOk, decrypted_buffer_));
 433   // The decrypt callback is returned after the correct decryption key is added.
 434   event_cb_.Run(CdmContext::Event::kHasAdditionalUsableKey);
 435   std::move(pending_decrypt_cb_).Run(Decryptor::kNoKey, nullptr);
 436   base::RunLoop().RunUntilIdle();
 437 }
 438
 439 // Test resetting in kIdle state but has not returned any buffer.
 440 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringIdleAfterInitialization) {
 441   Initialize();
 442   Reset();
 443 }
 444
 445 // Test resetting in kIdle state after having returned one buffer.
 446 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringIdleAfterReadOneBuffer) {
 447   Initialize();
 448   EnterNormalReadingState();
 449   Reset();
 450 }
 451
 452 // Test resetting in kPendingDemuxerRead state.
 453 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringPendingDemuxerRead) {
 454   Initialize();
 455   EnterPendingReadState();
 456
 457   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 458
 459   Reset();
 460   SatisfyPendingDemuxerReadCB(DemuxerStream::kOk);
 461   base::RunLoop().RunUntilIdle();
 462 }
 463
 464 // Test resetting in kPendingDecrypt state.
 465 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringPendingDecrypt) {
 466   Initialize();
 467   EnterPendingDecryptState();
 468
 469   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 470
 471   Reset();
 472 }
 473
 474 // Test resetting in kWaitingForKey state.
 475 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringWaitingForKey) {
 476   Initialize();
 477   EnterWaitingForKeyState();
 478
 479   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 480
 481   Reset();
 482 }
 483
 484 // Test resetting after reset.
 485 TEST_F(DecryptingDemuxerStreamTest, Reset_AfterReset) {
 486   Initialize();
 487   EnterNormalReadingState();
 488   Reset();
 489   Reset();
 490 }
 491
 492 // Test aborted read on the demuxer stream.
 493 TEST_F(DecryptingDemuxerStreamTest, DemuxerRead_Aborted) {
 494   Initialize();
 495
 496   // ReturnBuffer() with null triggers aborted demuxer read.
 497   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 498       .WillOnce(ReturnBuffer(scoped_refptr<DecoderBuffer>()));
 499
 500   ReadAndExpectBufferReadyWith(DemuxerStream::kAborted, nullptr);
 501 }
 502
 503 // Test resetting when waiting for an aborted read.
 504 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringAbortedDemuxerRead) {
 505   Initialize();
 506   EnterPendingReadState();
 507
 508   // Make sure we get a null audio frame returned.
 509   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 510
 511   Reset();
 512   SatisfyPendingDemuxerReadCB(DemuxerStream::kAborted);
 513   base::RunLoop().RunUntilIdle();
 514 }
 515
 516 // Test config change on the input demuxer stream.
 517 TEST_F(DecryptingDemuxerStreamTest, DemuxerRead_ConfigChanged) {
 518   Initialize(2, 2);
 519
 520   AudioDecoderConfig new_config(AudioCodec::kVorbis, kSampleFormatPlanarF32,
 521                                 CHANNEL_LAYOUT_STEREO, 88200, EmptyExtraData(),
 522                                 EncryptionScheme::kCenc);
 523   input_audio_stream_->set_audio_decoder_config(new_config);
 524
 525   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 526       .WillOnce(RunOnceCallback<0>(DemuxerStream::kConfigChanged,
 527                                    scoped_refptr<DecoderBuffer>()));
 528
 529   ReadAndExpectBufferReadyWith(DemuxerStream::kConfigChanged, nullptr);
 530 }
 531
 532 // Test resetting when waiting for a config changed read.
 533 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringConfigChangedDemuxerRead) {
 534   Initialize(2, 2);
 535   EnterPendingReadState();
 536
 537   // Make sure we get a |kConfigChanged| instead of a |kAborted|.
 538   EXPECT_CALL(*this, BufferReady(DemuxerStream::kConfigChanged, IsNull()));
 539
 540   Reset();
 541   SatisfyPendingDemuxerReadCB(DemuxerStream::kConfigChanged);
 542   base::RunLoop().RunUntilIdle();
 543 }
 544
 545 // The following tests test destruction in various scenarios. The destruction
 546 // happens in DecryptingDemuxerStreamTest's dtor.
 547
 548 // Test destruction in kIdle state but has not returned any buffer.
 549 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringIdleAfterInitialization) {
 550   Initialize();
 551 }
 552
 553 // Test destruction in kIdle state after having returned one buffer.
 554 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringIdleAfterReadOneBuffer) {
 555   Initialize();
 556   EnterNormalReadingState();
 557 }
 558
 559 // Test destruction in kPendingDemuxerRead state.
 560 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringPendingDemuxerRead) {
 561   Initialize();
 562   EnterPendingReadState();
 563
 564   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 565 }
 566
 567 // Test destruction in kPendingDecrypt state.
 568 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringPendingDecrypt) {
 569   Initialize();
 570   EnterPendingDecryptState();
 571
 572   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 573 }
 574
 575 // Test destruction in kWaitingForKey state.
 576 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringWaitingForKey) {
 577   Initialize();
 578   EnterWaitingForKeyState();
 579
 580   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsNull()));
 581 }
 582
 583 // Test destruction after reset.
 584 TEST_F(DecryptingDemuxerStreamTest, Destroy_AfterReset) {
 585   Initialize();
 586   EnterNormalReadingState();
 587   Reset();
 588 }
 589
 590 }  // namespace media