media: Prefer decrypting pipeline when CDM is attached

media/filters/video_decoder_selector_unittest.cc

Index: media/filters/video_decoder_selector_unittest.cc
diff --git a/media/filters/video_decoder_selector_unittest.cc b/media/filters/video_decoder_selector_unittest.cc
index 78becb1c978252cc22e452b486d5e7905e812a24..c7563242eda259621111e8174236a883dc381910 100644
--- a/media/filters/video_decoder_selector_unittest.cc
+++ b/media/filters/video_decoder_selector_unittest.cc
@@ -164,10 +164,8 @@ class VideoDecoderSelectorTest : public ::testing::Test {
   DISALLOW_COPY_AND_ASSIGN(VideoDecoderSelectorTest);
 };
 
-// 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(VideoDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 0);
@@ -177,11 +175,9 @@ TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) {
   SelectDecoder();
 }
 
-// The stream is not encrypted and we have one clear decoder. The decoder
-// will be selected.
-TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
+TEST_F(VideoDecoderSelectorTest, ClearStream_NoCdm_OneClearDecoder) {
   UseClearStream();
-  InitializeDecoderSelector(kNoDecryptor, 1);
+  InitializeDecoderSelector(kNoCdm, 1);
 
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
       .WillOnce(RunCallback<3>(true));
@@ -190,25 +186,68 @@ TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
   SelectDecoder();
 }
 
+TEST_F(VideoDecoderSelectorTest, Destroy_ClearStream_NoCdm_OneClearDecoder) {
+  UseClearStream();
+  InitializeDecoderSelector(kNoCdm, 1);
+
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _));
+
+  SelectDecoderAndDestroy();
+}
+
+TEST_F(VideoDecoderSelectorTest, ClearStream_NoCdm_MultipleClearDecoder) {
+  UseClearStream();
+  InitializeDecoderSelector(kNoCdm, 2);
+
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(true));
+  EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
+
+  SelectDecoder();
+}
+
+TEST_F(VideoDecoderSelectorTest,
+       Destroy_ClearStream_NoCdm_MultipleClearDecoder) {
+  UseClearStream();
+  InitializeDecoderSelector(kNoCdm, 2);
+
+  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
+  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _, _));
+
+  SelectDecoderAndDestroy();
+}
+
+TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_OneClearDecoder) {
+  UseClearStream();
+  InitializeDecoderSelector(kNoDecryptor, 1);
+
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _, _))
+      .WillOnce(RunCallback<3>(false));
+  EXPECT_CALL(*this, OnDecoderSelected(IsNull(), IsNull()));
+
+  SelectDecoder();
+}
+
 TEST_F(VideoDecoderSelectorTest,
        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(VideoDecoderSelectorTest, ClearStream_NoDecryptor_MultipleClearDecoder) {
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _, _))
       .WillOnce(RunCallback<3>(false));
-  EXPECT_CALL(*decoder_2_, Initialize(ClearConfig(), _, _, _, _))
+  EXPECT_CALL(*decoder_2_, Initialize(EncryptedConfig(), _, _, _, _))
       .WillOnce(RunCallback<3>(true));
   EXPECT_CALL(*this, OnDecoderSelected(decoder_2_, IsNull()));
 
@@ -220,27 +259,25 @@ TEST_F(VideoDecoderSelectorTest,
   UseClearStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
 
-  EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
+  EXPECT_CALL(*decoder_1_, Initialize(EncryptedConfig(), _, _, _, _))
       .WillOnce(RunCallback<3>(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(VideoDecoderSelectorTest, ClearStream_HasDecryptor) {
+TEST_F(VideoDecoderSelectorTest, ClearStream_DecryptOnly) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
   EXPECT_CALL(*decoder_1_, Initialize(ClearConfig(), _, _, _, _))
       .WillOnce(RunCallback<3>(true));
-  EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, IsNull()));
+  EXPECT_CALL(*this, OnDecoderSelected(decoder_1_, NotNull()));
 
   SelectDecoder();
 }
 
-TEST_F(VideoDecoderSelectorTest, Destroy_ClearStream_HasDecryptor) {
+TEST_F(VideoDecoderSelectorTest, Destroy_ClearStream_DecryptOnly) {
   UseClearStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
 
@@ -249,8 +286,28 @@ TEST_F(VideoDecoderSelectorTest, Destroy_ClearStream_HasDecryptor) {
   SelectDecoderAndDestroy();
 }
 
-// The stream is encrypted and there's no decryptor. The decoder only supports
-// clear streams so no decoder can be selected.
+TEST_F(VideoDecoderSelectorTest, 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<3>(true));
+  EXPECT_CALL(*this, OnDecoderSelected(NotNull(), NotNull()));
+#endif
+
+  SelectDecoder();
+}
+
+// Tests for encrypted streams.
+
 TEST_F(VideoDecoderSelectorTest, EncryptedStream_NoDecryptor_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 1);
@@ -272,8 +329,6 @@ TEST_F(VideoDecoderSelectorTest,
   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(VideoDecoderSelectorTest, EncryptedStream_NoDecryptor_MultipleDecoders) {
   UseEncryptedStream();
   InitializeDecoderSelector(kNoDecryptor, 2);
@@ -299,8 +354,6 @@ TEST_F(VideoDecoderSelectorTest,
   SelectDecoderAndDestroy();
 }
 
-// Decryptor can only do decryption and there's no decoder available. No decoder
-// can be selected.
 TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_NoDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 0);
@@ -310,8 +363,6 @@ TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_NoDecoder) {
   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(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_OneClearDecoder) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptOnly, 1);
@@ -335,9 +386,6 @@ TEST_F(VideoDecoderSelectorTest,
   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(VideoDecoderSelectorTest,
        EncryptedStream_DecryptOnly_MultipleClearDecoder) {
   UseEncryptedStream();
@@ -364,7 +412,6 @@ TEST_F(VideoDecoderSelectorTest,
   SelectDecoderAndDestroy();
 }
 
-// Decryptor can do decryption and decoding.
 TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptAndDecode) {
   UseEncryptedStream();
   InitializeDecoderSelector(kDecryptAndDecode, 1);