media: Prefer decrypting pipeline when CDM is attached

media/filters/audio_decoder_selector_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 <stddef.h>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 151 matching lines @@
   StrictMock<MockAudioDecoder>* decoder_2_;
   ScopedVector<AudioDecoder> all_decoders_;
   std::unique_ptr<AudioDecoder> selected_decoder_;
 
   base::MessageLoop message_loop_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioDecoderSelectorTest);
 };
 
-// TODO(xhwang): Add kNoCdm tests for clear stream.
+// Tests for clear streams.
 
-// The stream is not encrypted but we have no clear decoder. No decoder can be
-// selected.
 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 0);
 
   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 
   SelectDecoder();
 }
 
-// The stream is not encrypted and we have one clear decoder. The decoder
-// will be selected.
-TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
+TEST_F(AudioDecoderSelectorTest, ClearStream_NoCdm_OneClearDecoder) {
   UseClearStream();
-  InitializeDecoderSelector(kNoDecryptor, 1);
+  InitializeDecoderSelector(kNoCdm, 1);
 
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
       .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
 
   SelectDecoder();
 }
 
+TEST_F(AudioDecoderSelectorTest, Destroy_ClearStream_NoCdm_OneClearDecoder) {
+  UseClearStream();
+  InitializeDecoderSelector(kNoCdm, 1);
+
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
+
+  SelectDecoderAndDestroy();
+}
+
+TEST_F(AudioDecoderSelectorTest, ClearStream_NoCdm_MultipleClearDecoder) {
+  UseClearStream();
+  InitializeDecoderSelector(kNoCdm, 2);
+
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(true));
+  EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
+
+  SelectDecoder();
+}
+
+TEST_F(AudioDecoderSelectorTest,
+       Destroy_ClearStream_NoCdm_MultipleClearDecoder) {
+  UseClearStream();
+  InitializeDecoderSelector(kNoCdm, 2);
+
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _));
+
+  SelectDecoderAndDestroy();
+}
+
+TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
+  UseClearStream();
+  InitializeDecoderSelector(kNoDecryptor, 1);
+
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(false));
+  EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
+
+  SelectDecoder();
+}
+
 TEST_F(AudioDecoderSelectorTest,
        Destroy_ClearStream_NoDecryptor_OneClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
 
-// The stream is not encrypted and we have multiple clear decoders. The first
-// decoder that can decode the input stream will be selected.
 TEST_F(AudioDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
       .WillOnce(RunCallback<2>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _))
+  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _))
       .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
 
   SelectDecoder();
 }
 
 TEST_F(AudioDecoderSelectorTest,
        Destroy_ClearStream_NoDecryptor_MultipleClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
       .WillOnce(RunCallback<2>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _));
+  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
 
-// There is a decryptor but the stream is not encrypted. The decoder will be
-// selected.
-TEST_F(AudioDecoderSelectorTest, ClearStream_HasDecryptor) {
+TEST_F(AudioDecoderSelectorTest, ClearStream_DecryptOnly) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
       .WillOnce(RunCallback<2>(true));
-  EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
+  EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull()));
 
   SelectDecoder();
 }
 
-TEST_F(AudioDecoderSelectorTest, Destroy_ClearStream_HasDecryptor) {
+TEST_F(AudioDecoderSelectorTest, Destroy_ClearStream_DecryptOnly) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
 
-// The stream is encrypted and there's no decryptor. The decoder only supports
-// clear streams so no decoder can be selected.
+TEST_F(AudioDecoderSelectorTest, ClearStream_DecryptAndDecode) {
+  UseClearStream();
+  InitializeDecoderSelector(kDecryptAndDecode, 1);
+
+#if !defined(OS_ANDROID)
+  // A DecryptingVideoDecoder will be created and selected. The clear decoder
+  // should not be touched at all. No DecryptingDemuxerStream should be
+  // created.
+  EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull()));
+#else
+  // A DecryptingDemuxerStream will be created. The clear decoder will be
+  // initialized and returned.
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
+      .WillOnce(RunCallback<2>(true));
+  EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull()));
+#endif
+
+  SelectDecoder();
+}
+
+// Tests for encrypted streams.
+
 TEST_F(AudioDecoderSelectorTest, EncryptedStream_NoDecryptor_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
   EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
       .WillOnce(RunCallback<2>(false));
   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 
   SelectDecoder();
 }
 
 TEST_F(AudioDecoderSelectorTest,
        Destroy_EncryptedStream_NoDecryptor_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
 
   EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
 
-// The stream is encrypted and there's no decryptor. There are multiple decoders
-// and the first one that supports encrypted streams is selected.
 TEST_F(AudioDecoderSelectorTest, EncryptedStream_NoDecryptor_MultipleDecoders) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
   EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
       .WillOnce(RunCallback<2>(false));
   EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _))
       .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
 
   SelectDecoder();
 }
 
 TEST_F(AudioDecoderSelectorTest,
        Destroy_EncryptedStream_NoDecryptor_MultipleDecoders) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
   EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _))
       .WillOnce(RunCallback<2>(false));
   EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
 
-// Decryptor can only do decryption and there's no decoder available. No decoder
-// can be selected.
 TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptOnly_NoClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 0);
 
   EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
 
   SelectDecoder();
 }
 
-// Decryptor can do decryption-only and there's a decoder available. The decoder
-// will be selected and a DecryptingDemuxerStream will be created.
 TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
       .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull()));
 
   SelectDecoder();
 }
 
 TEST_F(AudioDecoderSelectorTest,
        Destroy_EncryptedStream_DecryptOnly_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
 
-// Decryptor can only do decryption and there are multiple decoders available.
-// The first decoder that can decode the input stream will be selected and
-// a DecryptingDemuxerStream will be created.
 TEST_F(AudioDecoderSelectorTest,
        EncryptedStream_DecryptOnly_MultipleClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 2);
 
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
       .WillOnce(RunCallback<2>(false));
   EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _))
       .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, NotNull()));
 
   SelectDecoder();
 }
 
 TEST_F(AudioDecoderSelectorTest,
        Destroy_EncryptedStream_DecryptOnly_MultipleClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 2);
 
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
       .WillOnce(RunCallback<2>(false));
   EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _));
 
   SelectDecoderAndDestroy();
 }
 
-// Decryptor can do decryption and decoding.
 TEST_F(AudioDecoderSelectorTest, EncryptedStream_DecryptAndDecode) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptAndDecode, 1);
 
 #if !defined(OS_ANDROID)
   // A DecryptingVideoDecoder will be created and selected. The clear decoder
   // should not be touched at all. No DecryptingDemuxerStream should to be
   // created.
   EXPECT_CALL(*this, OnDecoderSelected(NotNull(), IsNull()));
 #else
   // A DecryptingDemuxerStream will be created. The clear decoder will be
   // initialized and returned.
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _))
       .WillOnce(RunCallback<2>(true));
   EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull()));
 #endif
 
   SelectDecoder();
 }
 
 }  // namespace media