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/functional/bind.h"
  13 #include "base/functional/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::Return;
  34 using ::testing::SaveArg;
  35 using ::testing::StrictMock;
  36 using ::testing::WithArg;
  37
  38 namespace media {
  39
  40 static const int kFakeBufferSize = 16;
  41 static const uint8_t kFakeKeyId[] = {0x4b, 0x65, 0x79, 0x20, 0x49, 0x44};
  42 static const uint8_t kFakeIv[DecryptConfig::kDecryptionKeySize] = {0};
  43
  44 // Create a fake non-empty buffer in an encrypted stream. When |is_clear| is
  45 // true, the buffer is not encrypted (signaled by an empty IV).
  46 static scoped_refptr<DecoderBuffer> CreateFakeEncryptedStreamBuffer(
  47     bool is_clear) {
  48   auto buffer = base::MakeRefCounted<DecoderBuffer>(kFakeBufferSize);
  49   std::string iv = is_clear
  50                        ? std::string()
  51                        : std::string(reinterpret_cast<const char*>(kFakeIv),
  52                                      std::size(kFakeIv));
  53   if (!is_clear) {
  54     buffer->set_decrypt_config(DecryptConfig::CreateCencConfig(
  55         std::string(reinterpret_cast<const char*>(kFakeKeyId),
  56                     std::size(kFakeKeyId)),
  57         iv, {}));
  58   }
  59   return buffer;
  60 }
  61
  62 // Use anonymous namespace here to prevent the actions to be defined multiple
  63 // times across multiple test files. Sadly we can't use static for them.
  64 namespace {
  65
  66 ACTION_P(ReturnBuffer, buffer) {
  67   std::move(arg0).Run(
  68       buffer.get() ? DemuxerStream::kOk : DemuxerStream::kAborted, {buffer});
  69 }
  70
  71 }  // namespace
  72
  73 class DecryptingDemuxerStreamTest : public testing::Test {
  74  public:
  75   DecryptingDemuxerStreamTest()
  76       : demuxer_stream_(std::make_unique<DecryptingDemuxerStream>(
  77             task_environment_.GetMainThreadTaskRunner(),
  78             &media_log_,
  79             base::BindRepeating(&DecryptingDemuxerStreamTest::OnWaiting,
  80                                 base::Unretained(this)))),
  81         cdm_context_(std::make_unique<StrictMock<MockCdmContext>>()),
  82         decryptor_(std::make_unique<StrictMock<MockDecryptor>>()),
  83         is_initialized_(false),
  84         input_audio_stream_(std::make_unique<StrictMock<MockDemuxerStream>>(
  85             DemuxerStream::AUDIO)),
  86         input_video_stream_(std::make_unique<StrictMock<MockDemuxerStream>>(
  87             DemuxerStream::VIDEO)),
  88         clear_buffer_(base::MakeRefCounted<DecoderBuffer>(kFakeBufferSize)),
  89         clear_encrypted_stream_buffer_(CreateFakeEncryptedStreamBuffer(true)),
  90         encrypted_buffer_(CreateFakeEncryptedStreamBuffer(false)),
  91         decrypted_buffer_(
  92             base::MakeRefCounted<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.bytes_per_channel(),
 165               output_config.bytes_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, IsEmpty()));
 177     else if (decrypted_buffer->end_of_stream())
 178       EXPECT_CALL(*this, BufferReady(status, ReadOneAndIsEndOfStream()));
 179     else {
 180       DemuxerStream::DecoderBufferVector buffers;
 181       buffers.emplace_back(decrypted_buffer_);
 182       EXPECT_CALL(*this, BufferReady(status, buffers));
 183     }
 184
 185     demuxer_stream_->Read(
 186         1, base::BindOnce(&DecryptingDemuxerStreamTest::BufferReady,
 187                           base::Unretained(this)));
 188     base::RunLoop().RunUntilIdle();
 189   }
 190
 191   void EnterClearReadingState(bool is_stream_encrypted) {
 192     // Unencrypted streams never have a DecryptConfig.
 193     EXPECT_FALSE(clear_encrypted_stream_buffer_->decrypt_config());
 194     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 195         .WillOnce(ReturnBuffer(is_stream_encrypted
 196                                    ? clear_encrypted_stream_buffer_
 197                                    : clear_buffer_));
 198
 199     // For clearbuffer, decryptor->Decrypt() will not be called.
 200     DemuxerStream::DecoderBufferVector buffers;
 201     EXPECT_CALL(*this, BufferReady(DemuxerStream::kOk, _))
 202         .WillOnce(SaveArg<1>(&buffers));
 203     demuxer_stream_->Read(
 204         1, base::BindOnce(&DecryptingDemuxerStreamTest::BufferReady,
 205                           base::Unretained(this)));
 206     base::RunLoop().RunUntilIdle();
 207     DCHECK_EQ(buffers.size(), 1u);
 208     EXPECT_FALSE(buffers[0]->decrypt_config());
 209   }
 210
 211   // Sets up expectations and actions to put DecryptingDemuxerStream in an
 212   // active normal reading state.
 213   void EnterNormalReadingState() {
 214     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 215         .WillOnce(ReturnBuffer(encrypted_buffer_));
 216     EXPECT_CALL(*decryptor_, Decrypt(_, _, _))
 217         .WillOnce(RunOnceCallback<2>(Decryptor::kSuccess, decrypted_buffer_));
 218
 219     ReadAndExpectBufferReadyWith(DemuxerStream::kOk, decrypted_buffer_);
 220   }
 221
 222   // Make the read callback pending by saving and not firing it.
 223   void EnterPendingReadState() {
 224     EXPECT_TRUE(!pending_demuxer_read_cb_);
 225     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 226         .WillOnce(MoveArg<0>(&pending_demuxer_read_cb_));
 227     demuxer_stream_->Read(
 228         1, base::BindOnce(&DecryptingDemuxerStreamTest::BufferReady,
 229                           base::Unretained(this)));
 230     base::RunLoop().RunUntilIdle();
 231     // Make sure the Read() triggers a Read() on the input demuxer stream.
 232     EXPECT_FALSE(!pending_demuxer_read_cb_);
 233   }
 234
 235   // Make the decrypt callback pending by intercepting the call and not firing
 236   // the callback.
 237   void EnterPendingDecryptState() {
 238     EXPECT_TRUE(!pending_decrypt_cb_);
 239     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 240         .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
 241     EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 242         .WillOnce(WithArg<2>(Invoke([&](Decryptor::DecryptCB callback) {
 243           pending_decrypt_cb_ = std::move(callback);
 244         })));
 245
 246     demuxer_stream_->Read(
 247         1, base::BindOnce(&DecryptingDemuxerStreamTest::BufferReady,
 248                           base::Unretained(this)));
 249     base::RunLoop().RunUntilIdle();
 250     // Make sure Read() triggers a Decrypt() on the decryptor.
 251     EXPECT_FALSE(!pending_decrypt_cb_);
 252   }
 253
 254   void EnterWaitingForKeyState() {
 255     InSequence s;
 256     EXPECT_CALL(*input_audio_stream_, OnRead(_))
 257         .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
 258     EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 259         .WillRepeatedly(RunOnceCallback<2>(Decryptor::kNoKey,
 260                                            scoped_refptr<DecoderBuffer>()));
 261     EXPECT_MEDIA_LOG(HasSubstr("DecryptingDemuxerStream: no key for key ID"));
 262     EXPECT_CALL(*this, OnWaiting(WaitingReason::kNoDecryptionKey));
 263     demuxer_stream_->Read(
 264         1, base::BindOnce(&DecryptingDemuxerStreamTest::BufferReady,
 265                           base::Unretained(this)));
 266     base::RunLoop().RunUntilIdle();
 267   }
 268
 269   void AbortPendingDecryptCB() {
 270     if (pending_decrypt_cb_) {
 271       std::move(pending_decrypt_cb_).Run(Decryptor::kSuccess, nullptr);
 272     }
 273   }
 274
 275   void SatisfyPendingDemuxerReadCB(DemuxerStream::Status status) {
 276     scoped_refptr<DecoderBuffer> buffer =
 277         (status == DemuxerStream::kOk) ? encrypted_buffer_ : nullptr;
 278     std::move(pending_demuxer_read_cb_).Run(status, {buffer});
 279   }
 280
 281   void Reset() {
 282     EXPECT_CALL(*decryptor_, CancelDecrypt(Decryptor::kAudio))
 283         .WillRepeatedly(InvokeWithoutArgs(
 284             this, &DecryptingDemuxerStreamTest::AbortPendingDecryptCB));
 285
 286     demuxer_stream_->Reset(NewExpectedClosure());
 287     base::RunLoop().RunUntilIdle();
 288   }
 289
 290   MOCK_METHOD2(BufferReady,
 291                void(DemuxerStream::Status, DemuxerStream::DecoderBufferVector));
 292   MOCK_METHOD1(OnWaiting, void(WaitingReason));
 293
 294   base::test::SingleThreadTaskEnvironment task_environment_;
 295   StrictMock<MockMediaLog> media_log_;
 296   std::unique_ptr<DecryptingDemuxerStream> demuxer_stream_;
 297   std::unique_ptr<StrictMock<MockCdmContext>> cdm_context_;
 298   std::unique_ptr<StrictMock<MockDecryptor>> decryptor_;
 299   // Whether the |demuxer_stream_| is successfully initialized.
 300   bool is_initialized_;
 301   std::unique_ptr<StrictMock<MockDemuxerStream>> input_audio_stream_;
 302   std::unique_ptr<StrictMock<MockDemuxerStream>> input_video_stream_;
 303
 304   DemuxerStream::ReadCB pending_demuxer_read_cb_;
 305   CdmContext::EventCB event_cb_;
 306   Decryptor::DecryptCB pending_decrypt_cb_;
 307
 308   // Constant buffers to be returned by the input demuxer streams and the
 309   // |decryptor_|.
 310   scoped_refptr<DecoderBuffer> clear_buffer_;
 311   scoped_refptr<DecoderBuffer> clear_encrypted_stream_buffer_;
 312   scoped_refptr<DecoderBuffer> encrypted_buffer_;
 313   scoped_refptr<DecoderBuffer> decrypted_buffer_;
 314 };
 315
 316 TEST_F(DecryptingDemuxerStreamTest, Initialize_NormalAudio) {
 317   Initialize();
 318 }
 319
 320 TEST_F(DecryptingDemuxerStreamTest, Initialize_NormalVideo) {
 321   SetCdmType(CDM_WITH_DECRYPTOR);
 322   EXPECT_CALL(*cdm_context_, RegisterEventCB(_)).WillOnce([&](auto cb) {
 323     event_cb_ = cb;
 324     return std::make_unique<CallbackRegistration>();
 325   });
 326
 327   VideoDecoderConfig input_config = TestVideoConfig::NormalEncrypted();
 328   EXPECT_MEDIA_LOG(HasSubstr("kAudioTracks"));
 329   EXPECT_MEDIA_LOG(HasSubstr("kVideoTracks"));
 330   InitializeVideoAndExpectStatus(input_config, PIPELINE_OK);
 331
 332   const VideoDecoderConfig& output_config =
 333       demuxer_stream_->video_decoder_config();
 334   EXPECT_EQ(DemuxerStream::VIDEO, demuxer_stream_->type());
 335   EXPECT_FALSE(output_config.is_encrypted());
 336   EXPECT_EQ(input_config.codec(), output_config.codec());
 337   EXPECT_EQ(input_config.alpha_mode(), output_config.alpha_mode());
 338   EXPECT_EQ(input_config.profile(), output_config.profile());
 339   EXPECT_EQ(input_config.coded_size(), output_config.coded_size());
 340   EXPECT_EQ(input_config.visible_rect(), output_config.visible_rect());
 341   EXPECT_EQ(input_config.natural_size(), output_config.natural_size());
 342   ASSERT_EQ(input_config.extra_data(), output_config.extra_data());
 343 }
 344
 345 TEST_F(DecryptingDemuxerStreamTest, Initialize_CdmWithoutDecryptor) {
 346   SetCdmType(CDM_WITHOUT_DECRYPTOR);
 347   AudioDecoderConfig input_config(AudioCodec::kVorbis, kSampleFormatPlanarF32,
 348                                   CHANNEL_LAYOUT_STEREO, 44100,
 349                                   EmptyExtraData(), EncryptionScheme::kCenc);
 350   EXPECT_MEDIA_LOG(HasSubstr("kAudioTracks"));
 351   EXPECT_MEDIA_LOG(HasSubstr("kVideoTracks"));
 352   InitializeAudioAndExpectStatus(input_config, DECODER_ERROR_NOT_SUPPORTED);
 353 }
 354
 355 // Test normal read case where the buffer is encrypted.
 356 TEST_F(DecryptingDemuxerStreamTest, Read_Normal) {
 357   Initialize();
 358   EnterNormalReadingState();
 359 }
 360
 361 // Test normal read case where the buffer is clear.
 362 TEST_F(DecryptingDemuxerStreamTest, Read_ClearBufferInEncryptedStream) {
 363   Initialize();
 364   EnterClearReadingState(true);
 365 }
 366
 367 TEST_F(DecryptingDemuxerStreamTest, Read_ClearBufferInClearStream) {
 368   Initialize();
 369   EnterClearReadingState(false);
 370 }
 371
 372 // Test the case where the decryptor returns error during read.
 373 TEST_F(DecryptingDemuxerStreamTest, Read_DecryptError) {
 374   Initialize();
 375
 376   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 377       .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
 378   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 379       .WillRepeatedly(RunOnceCallback<2>(Decryptor::kError,
 380                                          scoped_refptr<DecoderBuffer>()));
 381   EXPECT_MEDIA_LOG(HasSubstr("DecryptingDemuxerStream: decrypt error"));
 382   ReadAndExpectBufferReadyWith(DemuxerStream::kError, nullptr);
 383 }
 384
 385 // Test the case where the decryptor errors for mismatched subsamples
 386 TEST_F(DecryptingDemuxerStreamTest, Read_MismatchedSubsampleError) {
 387   Initialize();
 388
 389   encrypted_buffer_ = CreateMismatchedBufferForTest();
 390
 391   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 392       .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
 393   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 394       .WillRepeatedly(RunOnceCallback<2>(Decryptor::kError,
 395                                          scoped_refptr<DecoderBuffer>()));
 396   EXPECT_MEDIA_LOG(
 397       HasSubstr("DecryptingDemuxerStream: Subsamples for Buffer do not match"));
 398   ReadAndExpectBufferReadyWith(DemuxerStream::kError, nullptr);
 399 }
 400
 401 // Test the case where the decryptor returns kNeedMoreData during read.
 402 TEST_F(DecryptingDemuxerStreamTest, Read_DecryptNeedMoreData) {
 403   Initialize();
 404
 405   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 406       .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
 407   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 408       .WillRepeatedly(RunOnceCallback<2>(Decryptor::kNeedMoreData,
 409                                          scoped_refptr<DecoderBuffer>()));
 410   EXPECT_MEDIA_LOG(HasSubstr("DecryptingDemuxerStream: decrypt error"));
 411   ReadAndExpectBufferReadyWith(DemuxerStream::kError, nullptr);
 412 }
 413
 414 // Test the case where the input is an end-of-stream buffer.
 415 TEST_F(DecryptingDemuxerStreamTest, Read_EndOfStream) {
 416   Initialize();
 417   EnterNormalReadingState();
 418
 419   // No Decryptor::Decrypt() call is expected for EOS buffer.
 420   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 421       .WillOnce(ReturnBuffer(DecoderBuffer::CreateEOSBuffer()));
 422
 423   ReadAndExpectBufferReadyWith(DemuxerStream::kOk,
 424                                DecoderBuffer::CreateEOSBuffer());
 425 }
 426
 427 // Test the case where the a key is added when the decryptor is in
 428 // kWaitingForKey state.
 429 TEST_F(DecryptingDemuxerStreamTest, KeyAdded_DuringWaitingForKey) {
 430   Initialize();
 431   EnterWaitingForKeyState();
 432
 433   EXPECT_MEDIA_LOG(
 434       HasSubstr("DecryptingDemuxerStream: key was added, resuming decrypt"));
 435   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 436       .WillRepeatedly(
 437           RunOnceCallback<2>(Decryptor::kSuccess, decrypted_buffer_));
 438   DemuxerStream::DecoderBufferVector buffers;
 439   buffers.emplace_back(decrypted_buffer_);
 440   EXPECT_CALL(*this, BufferReady(DemuxerStream::kOk, buffers));
 441   event_cb_.Run(CdmContext::Event::kHasAdditionalUsableKey);
 442   base::RunLoop().RunUntilIdle();
 443 }
 444
 445 // Test the case where the a key is added when the decryptor is in
 446 // kPendingDecrypt state.
 447 TEST_F(DecryptingDemuxerStreamTest, KeyAdded_DuringPendingDecrypt) {
 448   Initialize();
 449   EnterPendingDecryptState();
 450
 451   EXPECT_MEDIA_LOG(HasSubstr("DecryptingDemuxerStream: no key for key ID"));
 452   EXPECT_MEDIA_LOG(
 453       HasSubstr("DecryptingDemuxerStream: key was added, resuming decrypt"));
 454   EXPECT_CALL(*decryptor_, Decrypt(_, encrypted_buffer_, _))
 455       .WillRepeatedly(
 456           RunOnceCallback<2>(Decryptor::kSuccess, decrypted_buffer_));
 457   DemuxerStream::DecoderBufferVector buffers;
 458   buffers.emplace_back(decrypted_buffer_);
 459   EXPECT_CALL(*this, BufferReady(DemuxerStream::kOk, buffers));
 460   // The decrypt callback is returned after the correct decryption key is added.
 461   event_cb_.Run(CdmContext::Event::kHasAdditionalUsableKey);
 462   std::move(pending_decrypt_cb_).Run(Decryptor::kNoKey, nullptr);
 463   base::RunLoop().RunUntilIdle();
 464 }
 465
 466 // Test resetting in kIdle state but has not returned any buffer.
 467 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringIdleAfterInitialization) {
 468   Initialize();
 469   Reset();
 470 }
 471
 472 // Test resetting in kIdle state after having returned one buffer.
 473 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringIdleAfterReadOneBuffer) {
 474   Initialize();
 475   EnterNormalReadingState();
 476   Reset();
 477 }
 478
 479 // Test resetting in kPendingDemuxerRead state.
 480 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringPendingDemuxerRead) {
 481   Initialize();
 482   EnterPendingReadState();
 483
 484   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsEmpty()));
 485
 486   Reset();
 487   SatisfyPendingDemuxerReadCB(DemuxerStream::kOk);
 488   base::RunLoop().RunUntilIdle();
 489 }
 490
 491 // Test resetting in kPendingDecrypt state.
 492 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringPendingDecrypt) {
 493   Initialize();
 494   EnterPendingDecryptState();
 495
 496   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsEmpty()));
 497
 498   Reset();
 499 }
 500
 501 // Test resetting in kWaitingForKey state.
 502 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringWaitingForKey) {
 503   Initialize();
 504   EnterWaitingForKeyState();
 505
 506   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsEmpty()));
 507
 508   Reset();
 509 }
 510
 511 // Test resetting after reset.
 512 TEST_F(DecryptingDemuxerStreamTest, Reset_AfterReset) {
 513   Initialize();
 514   EnterNormalReadingState();
 515   Reset();
 516   Reset();
 517 }
 518
 519 // Test aborted read on the demuxer stream.
 520 TEST_F(DecryptingDemuxerStreamTest, DemuxerRead_Aborted) {
 521   Initialize();
 522
 523   // ReturnBuffer() with null triggers aborted demuxer read.
 524   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 525       .WillOnce(ReturnBuffer(scoped_refptr<DecoderBuffer>()));
 526
 527   ReadAndExpectBufferReadyWith(DemuxerStream::kAborted, nullptr);
 528 }
 529
 530 // Test resetting when waiting for an aborted read.
 531 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringAbortedDemuxerRead) {
 532   Initialize();
 533   EnterPendingReadState();
 534
 535   // Make sure we get a null audio frame returned.
 536   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsEmpty()));
 537
 538   Reset();
 539   SatisfyPendingDemuxerReadCB(DemuxerStream::kAborted);
 540   base::RunLoop().RunUntilIdle();
 541 }
 542
 543 // Test config change on the input demuxer stream.
 544 TEST_F(DecryptingDemuxerStreamTest, DemuxerRead_ConfigChanged) {
 545   Initialize(2, 2);
 546
 547   AudioDecoderConfig new_config(AudioCodec::kVorbis, kSampleFormatPlanarF32,
 548                                 CHANNEL_LAYOUT_STEREO, 88200, EmptyExtraData(),
 549                                 EncryptionScheme::kCenc);
 550   input_audio_stream_->set_audio_decoder_config(new_config);
 551
 552   EXPECT_CALL(*input_audio_stream_, OnRead(_))
 553       .WillOnce(RunOnceCallback<0>(DemuxerStream::kConfigChanged,
 554                                    DemuxerStream::DecoderBufferVector()));
 555
 556   ReadAndExpectBufferReadyWith(DemuxerStream::kConfigChanged, nullptr);
 557 }
 558
 559 // Test resetting when waiting for a config changed read.
 560 TEST_F(DecryptingDemuxerStreamTest, Reset_DuringConfigChangedDemuxerRead) {
 561   Initialize(2, 2);
 562   EnterPendingReadState();
 563
 564   // Make sure we get a |kConfigChanged| instead of a |kAborted|.
 565   EXPECT_CALL(*this, BufferReady(DemuxerStream::kConfigChanged, IsEmpty()));
 566
 567   Reset();
 568   SatisfyPendingDemuxerReadCB(DemuxerStream::kConfigChanged);
 569   base::RunLoop().RunUntilIdle();
 570 }
 571
 572 // The following tests test destruction in various scenarios. The destruction
 573 // happens in DecryptingDemuxerStreamTest's dtor.
 574
 575 // Test destruction in kIdle state but has not returned any buffer.
 576 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringIdleAfterInitialization) {
 577   Initialize();
 578 }
 579
 580 // Test destruction in kIdle state after having returned one buffer.
 581 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringIdleAfterReadOneBuffer) {
 582   Initialize();
 583   EnterNormalReadingState();
 584 }
 585
 586 // Test destruction in kPendingDemuxerRead state.
 587 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringPendingDemuxerRead) {
 588   Initialize();
 589   EnterPendingReadState();
 590
 591   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsEmpty()));
 592 }
 593
 594 // Test destruction in kPendingDecrypt state.
 595 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringPendingDecrypt) {
 596   Initialize();
 597   EnterPendingDecryptState();
 598
 599   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsEmpty()));
 600 }
 601
 602 // Test destruction in kWaitingForKey state.
 603 TEST_F(DecryptingDemuxerStreamTest, Destroy_DuringWaitingForKey) {
 604   Initialize();
 605   EnterWaitingForKeyState();
 606
 607   EXPECT_CALL(*this, BufferReady(DemuxerStream::kAborted, IsEmpty()));
 608 }
 609
 610 // Test destruction after reset.
 611 TEST_F(DecryptingDemuxerStreamTest, Destroy_AfterReset) {
 612   Initialize();
 613   EnterNormalReadingState();
 614   Reset();
 615 }
 616
 617 }  // namespace media