media: Pass CdmContext in decoder reinitialization

media/filters/video_frame_stream_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 17 matching lines @@
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 static const int kNumConfigs = 4;
 static const int kNumBuffersInOneConfig = 5;
 
 namespace media {
 
 struct VideoFrameStreamTestParams {
   VideoFrameStreamTestParams(bool is_encrypted,
+                             bool has_decryptor,
                              int decoding_delay,
                              int parallel_decoding)
       : is_encrypted(is_encrypted),
+        has_decryptor(has_decryptor),
         decoding_delay(decoding_delay),
         parallel_decoding(parallel_decoding) {}
 
   bool is_encrypted;
+  bool has_decryptor;
   int decoding_delay;
   int parallel_decoding;
 };
 
 class VideoFrameStreamTest
     : public testing::Test,
       public testing::WithParamInterface<VideoFrameStreamTestParams> {
  public:
   VideoFrameStreamTest()
       : demuxer_stream_(new FakeDemuxerStream(kNumConfigs,
                                               kNumBuffersInOneConfig,
                                               GetParam().is_encrypted)),
         cdm_context_(new StrictMock<MockCdmContext>()),
-        decryptor_(new NiceMock<MockDecryptor>()),
-        decoder1_(
-            new FakeVideoDecoder(GetParam().decoding_delay,
-                                 GetParam().parallel_decoding,
-                                 base::Bind(
-                                     &VideoFrameStreamTest::OnBytesDecoded,
-                                     base::Unretained(this)))),
-        decoder2_(
-            new FakeVideoDecoder(GetParam().decoding_delay,
-                                 GetParam().parallel_decoding,
-                                 base::Bind(
-                                     &VideoFrameStreamTest::OnBytesDecoded,
-                                     base::Unretained(this)))),
-        decoder3_(
-            new FakeVideoDecoder(GetParam().decoding_delay,
-                                 GetParam().parallel_decoding,
-                                 base::Bind(
-                                     &VideoFrameStreamTest::OnBytesDecoded,
-                                     base::Unretained(this)))),
         is_initialized_(false),
         num_decoded_frames_(0),
         pending_initialize_(false),
         pending_read_(false),
         pending_reset_(false),
         pending_stop_(false),
         num_decoded_bytes_unreported_(0),
         has_no_key_(false) {
+    int decoding_delay = GetParam().decoding_delay;
+    int parallel_decoding = GetParam().parallel_decoding;
+    BytesDecodedCB bytes_decoded_cb = base::Bind(
+        &VideoFrameStreamTest::OnBytesDecoded, base::Unretained(this));
+
+    decoder1_ = new FakeVideoDecoder(decoding_delay, parallel_decoding,
+                                     bytes_decoded_cb);
+    decoder2_ = new FakeVideoDecoder(decoding_delay, parallel_decoding,
+                                     bytes_decoded_cb);
+    decoder3_ = new FakeVideoDecoder(decoding_delay, parallel_decoding,
+                                     bytes_decoded_cb);
+
+    // TODO(xhwang): We should test the case where only certain decoder
+    // supports encrypted streams. Currently this is hard to test becasue we use
+    // parameterized tests which need to pass in all combinations.
+    if (GetParam().is_encrypted && !GetParam().has_decryptor) {
+      decoder1_->EnableEncryptedConfigSupport();
+      decoder2_->EnableEncryptedConfigSupport();
+      decoder3_->EnableEncryptedConfigSupport();
+    }
+
     ScopedVector<VideoDecoder> decoders;
     decoders.push_back(decoder1_);
     decoders.push_back(decoder2_);
     decoders.push_back(decoder3_);
 
     video_frame_stream_.reset(new VideoFrameStream(
         message_loop_.task_runner(), std::move(decoders), new MediaLog()));
 
+    if (GetParam().has_decryptor) {
+      decryptor_.reset(new NiceMock<MockDecryptor>());
+
+      // Decryptor can only decrypt (not decrypt-and-decode) so that
+      // DecryptingDemuxerStream will be used.
+      EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
+          .WillRepeatedly(RunCallback<1>(false));
+      EXPECT_CALL(*decryptor_, Decrypt(_, _, _))
+          .WillRepeatedly(Invoke(this, &VideoFrameStreamTest::Decrypt));
+    }
+
     EXPECT_CALL(*cdm_context_, GetDecryptor())
         .WillRepeatedly(Return(decryptor_.get()));
-
-    // Decryptor can only decrypt (not decrypt-and-decode) so that
-    // DecryptingDemuxerStream will be used.
-    EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
-        .WillRepeatedly(RunCallback<1>(false));
-    EXPECT_CALL(*decryptor_, Decrypt(_, _, _))
-        .WillRepeatedly(Invoke(this, &VideoFrameStreamTest::Decrypt));
   }
 
   ~VideoFrameStreamTest() {
     // Check that the pipeline statistics callback was fired correctly.
     EXPECT_EQ(num_decoded_bytes_unreported_, 0);
 
     is_initialized_ = false;
     decoder1_ = NULL;
     decoder2_ = NULL;
     decoder3_ = NULL;
@@ skipping 133 matching lines @@
         demuxer_stream_->HoldNextRead();
         ReadUntilPending();
         break;
 
       case DEMUXER_READ_CONFIG_CHANGE:
         demuxer_stream_->HoldNextConfigChangeRead();
         ReadUntilPending();
         break;
 
       case DECRYPTOR_NO_KEY:
-        if (GetParam().is_encrypted)
+        if (GetParam().is_encrypted && GetParam().has_decryptor) {
           EXPECT_CALL(*this, OnWaitingForDecryptionKey());
-        has_no_key_ = true;
+          has_no_key_ = true;
+        }
         ReadOneFrame();
         break;
 
       case DECODER_INIT:
         decoder->HoldNextInit();
         InitializeVideoFrameStream();
         break;
 
       case DECODER_REINIT:
         decoder->HoldNextInit();
@@ skipping 110 matching lines @@
   // Decryptor has no key to decrypt a frame.
   bool has_no_key_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoFrameStreamTest);
 };
 
 INSTANTIATE_TEST_CASE_P(
     Clear,
     VideoFrameStreamTest,
-    ::testing::Values(
-        VideoFrameStreamTestParams(false, 0, 1),
-        VideoFrameStreamTestParams(false, 3, 1),
-        VideoFrameStreamTestParams(false, 7, 1)));
+    ::testing::Values(VideoFrameStreamTestParams(false, false, 0, 1),
+                      VideoFrameStreamTestParams(false, false, 3, 1),
+                      VideoFrameStreamTestParams(false, false, 7, 1)));
 
 INSTANTIATE_TEST_CASE_P(
-    Encrypted,
+    EncryptedWithDecryptor,
     VideoFrameStreamTest,
-    ::testing::Values(
-        VideoFrameStreamTestParams(true, 7, 1)));
+    ::testing::Values(VideoFrameStreamTestParams(true, true, 7, 1)));
+
+INSTANTIATE_TEST_CASE_P(
+    EncryptedWithoutDecryptor,
+    VideoFrameStreamTest,
+    ::testing::Values(VideoFrameStreamTestParams(true, false, 7, 1)));
 
 INSTANTIATE_TEST_CASE_P(
     Clear_Parallel,
     VideoFrameStreamTest,
-    ::testing::Values(
-        VideoFrameStreamTestParams(false, 0, 3),
-        VideoFrameStreamTestParams(false, 2, 3)));
-
+    ::testing::Values(VideoFrameStreamTestParams(false, false, 0, 3),
+                      VideoFrameStreamTestParams(false, false, 2, 3)));
 
 TEST_P(VideoFrameStreamTest, Initialization) {
   Initialize();
+  EXPECT_TRUE(is_initialized_);
 }
 
 TEST_P(VideoFrameStreamTest, AllDecoderInitializationFails) {
   decoder1_->SimulateFailureToInit();
   decoder2_->SimulateFailureToInit();
   decoder3_->SimulateFailureToInit();
   Initialize();
   EXPECT_FALSE(is_initialized_);
 }
 
@@ skipping 687 matching lines @@
 
 TEST_P(VideoFrameStreamTest, Destroy_DuringFallbackDecoderSelection) {
   Initialize();
   decoder1_->SimulateFailureToInit();
   EnterPendingState(DECODER_REINIT);
   decoder2_->HoldNextInit();
   SatisfyPendingCallback(DECODER_REINIT);
 }
 
 }  // namespace media