media: Remove SetCdmReadyCB and CdmReadyCB (part 1).

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 d0d84059bf114502adc0b5f4b3c5580c0a74a694..16043cd6ad66e6fb6af975ed183a515e3def6ac5 100644
--- a/media/filters/video_decoder_selector_unittest.cc
+++ b/media/filters/video_decoder_selector_unittest.cc
@@ -28,16 +28,6 @@ using ::testing::StrictMock;
 // times across multiple test files. Sadly we can't use static for them.
 namespace {
 
-ACTION_P3(ExecuteCallbackWithVerifier, cdm_context, done_cb, verifier) {
-  // verifier must be called first since |done_cb| call will invoke it as well.
-  verifier->RecordACalled();
-  arg0.Run(cdm_context, done_cb);
-}
-
-ACTION_P(ReportCallback, verifier) {
-  verifier->RecordBCalled();
-}
-
 MATCHER(EncryptedConfig, "") {
   return arg.is_encrypted();
 }
@@ -52,11 +42,8 @@ namespace media {
 class VideoDecoderSelectorTest : public ::testing::Test {
  public:
   enum DecryptorCapability {
-    kNoDecryptor,
-    // Used to test destruction during DecryptingVideoDecoder::Initialize() and
-    // DecryptingDemuxerStream::Initialize(). We don't need this for normal
-    // VideoDecoders since we use MockVideoDecoder.
-    kHoldSetDecryptor,
+    kNoCdm,        // No CDM. Only possible for clear stream.
+    kNoDecryptor,  // CDM is available but Decryptor is not supported.
     kDecryptOnly,
     kDecryptAndDecode
   };
@@ -64,25 +51,20 @@ class VideoDecoderSelectorTest : public ::testing::Test {
   VideoDecoderSelectorTest()
       : demuxer_stream_(
             new StrictMock<MockDemuxerStream>(DemuxerStream::VIDEO)),
-        cdm_context_(new StrictMock<MockCdmContext>()),
-        decryptor_(new NiceMock<MockDecryptor>()),
         decoder_1_(new StrictMock<MockVideoDecoder>()),
         decoder_2_(new StrictMock<MockVideoDecoder>()) {
     all_decoders_.push_back(decoder_1_);
     all_decoders_.push_back(decoder_2_);
-
-    EXPECT_CALL(*cdm_context_, GetDecryptor())
-        .WillRepeatedly(Return(decryptor_.get()));
+    // |cdm_context_| and |decryptor_| are conditionally created in
+    // InitializeDecoderSelector().
   }
 
   ~VideoDecoderSelectorTest() {
     message_loop_.RunUntilIdle();
   }
 
-  MOCK_METHOD1(SetCdmReadyCallback, void(const media::CdmReadyCB&));
   MOCK_METHOD2(OnDecoderSelected,
                void(VideoDecoder*, DecryptingDemuxerStream*));
-  MOCK_METHOD1(CdmSet, void(bool));
 
   void MockOnDecoderSelected(
       scoped_ptr<VideoDecoder> decoder,
@@ -102,30 +84,20 @@ class VideoDecoderSelectorTest : public ::testing::Test {
 
   void InitializeDecoderSelector(DecryptorCapability decryptor_capability,
                                  int num_decoders) {
-    if (decryptor_capability == kDecryptOnly ||
-        decryptor_capability == kDecryptAndDecode) {
-      EXPECT_CALL(*this, SetCdmReadyCallback(_))
-          .WillRepeatedly(ExecuteCallbackWithVerifier(
-              cdm_context_.get(), base::Bind(&VideoDecoderSelectorTest::CdmSet,
-                                             base::Unretained(this)),
-              &verifier_));
-      EXPECT_CALL(*this, CdmSet(true))
-          .WillRepeatedly(ReportCallback(&verifier_));
-
-      if (decryptor_capability == kDecryptOnly) {
-        EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
-            .WillRepeatedly(RunCallback<1>(false));
+    if (decryptor_capability != kNoCdm) {
+      cdm_context_.reset(new StrictMock<MockCdmContext>());
+
+      if (decryptor_capability == kNoDecryptor) {
+        EXPECT_CALL(*cdm_context_, GetDecryptor())
+            .WillRepeatedly(Return(nullptr));
       } else {
+        decryptor_.reset(new NiceMock<MockDecryptor>());
+        EXPECT_CALL(*cdm_context_, GetDecryptor())
+            .WillRepeatedly(Return(decryptor_.get()));
         EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
-            .WillRepeatedly(RunCallback<1>(true));
+            .WillRepeatedly(
+                RunCallback<1>(decryptor_capability == kDecryptAndDecode));
       }
-    } else if (decryptor_capability == kHoldSetDecryptor) {
-      // Set and cancel CdmReadyCB but the callback is never fired.
-      EXPECT_CALL(*this, SetCdmReadyCallback(_)).Times(2);
-    } else if (decryptor_capability == kNoDecryptor) {
-      EXPECT_CALL(*this, SetCdmReadyCallback(_))
-          .WillRepeatedly(
-              RunCallback<0>(nullptr, base::Bind(&IgnoreCdmAttached)));
     }
 
     DCHECK_GE(all_decoders_.size(), static_cast<size_t>(num_decoders));
@@ -138,9 +110,7 @@ class VideoDecoderSelectorTest : public ::testing::Test {
 
   void SelectDecoder() {
     decoder_selector_->SelectDecoder(
-        demuxer_stream_.get(),
-        base::Bind(&VideoDecoderSelectorTest::SetCdmReadyCallback,
-                   base::Unretained(this)),
+        demuxer_stream_.get(), cdm_context_.get(),
         base::Bind(&VideoDecoderSelectorTest::MockOnDecoderSelected,
                    base::Unretained(this)),
         base::Bind(&VideoDecoderSelectorTest::FrameReady,
@@ -185,12 +155,12 @@ class VideoDecoderSelectorTest : public ::testing::Test {
 
   base::MessageLoop message_loop_;
 
-  CallbackPairChecker verifier_;
-
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoDecoderSelectorTest);
 };
 
+// TODO(xhwang): Add kNoCdm tests for clear stream.
+
 // The stream is not encrypted but we have no clear decoder. No decoder can be
 // selected.
 TEST_F(VideoDecoderSelectorTest, ClearStream_NoDecryptor_NoClearDecoder) {
@@ -335,14 +305,6 @@ TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptOnly_NoDecoder) {
   SelectDecoder();
 }
 
-TEST_F(VideoDecoderSelectorTest,
-       Destroy_EncryptedStream_DecryptOnly_NoDecoder) {
-  UseEncryptedStream();
-  InitializeDecoderSelector(kHoldSetDecryptor, 0);
-
-  SelectDecoderAndDestroy();
-}
-
 // 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) {
@@ -418,11 +380,4 @@ TEST_F(VideoDecoderSelectorTest, EncryptedStream_DecryptAndDecode) {
   SelectDecoder();
 }
 
-TEST_F(VideoDecoderSelectorTest, Destroy_EncryptedStream_DecryptAndDecode) {
-  UseEncryptedStream();
-  InitializeDecoderSelector(kHoldSetDecryptor, 1);
-
-  SelectDecoderAndDestroy();
-}
-
 }  // namespace media