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