decrypting_demuxer_stream_unittest.cc 22 KB

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