media: Prefer decrypting pipeline when CDM is attached

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 39 matching lines @@
 };
 
 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>()),
         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
+    // supports encrypted streams. Currently this is hard to test because 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) {
+    if (GetParam().is_encrypted && 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()));
+    if (GetParam().is_encrypted) {
+      cdm_context_.reset(new StrictMock<MockCdmContext>());
+
+      EXPECT_CALL(*cdm_context_, GetDecryptor())
+          .WillRepeatedly(Return(decryptor_.get()));
+    }
   }
 
   ~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 997 matching lines @@
 
 TEST_P(VideoFrameStreamTest, Destroy_DuringFallbackDecoderSelection) {
   Initialize();
   decoder1_->SimulateFailureToInit();
   EnterPendingState(DECODER_REINIT);
   decoder2_->HoldNextInit();
   SatisfyPendingCallback(DECODER_REINIT);
 }
 
 }  // namespace media