Allow setContentDecryptionModule() to get called when setting is done.

media/filters/video_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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/gmock_callback_support.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/filters/decoder_selector.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::IsNull;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::StrictMock;
 
+// Use anonymous namespace here to prevent the actions to be defined multiple
+// times across multiple test files. Sadly we can't use static for them.
+namespace {
+
+ACTION_P3(ExecuteCallbackWithVerifier, decryptor, done_cb, verifier) {
+  // verifier must be called first since |done_cb| call will invoke it as well.
+  verifier->RecordACalled();
+  arg0.Run(decryptor, done_cb);
+}
+
+ACTION_P(ReportCallback, verifier) {
+  verifier->RecordBCalled();
+}
+
+}  // namespace
+
 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,
@@ skipping 11 matching lines @@
     all_decoders_.push_back(decoder_2_);
   }
 
   ~VideoDecoderSelectorTest() {
     message_loop_.RunUntilIdle();
   }
 
   MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&));
   MOCK_METHOD2(OnDecoderSelected,
                void(VideoDecoder*, DecryptingDemuxerStream*));
+  MOCK_METHOD1(DecryptorSet, void(bool));
 
   void MockOnDecoderSelected(
       scoped_ptr<VideoDecoder> decoder,
       scoped_ptr<DecryptingDemuxerStream> stream) {
     OnDecoderSelected(decoder.get(), stream.get());
     selected_decoder_ = decoder.Pass();
   }
 
   void UseClearStream() {
     demuxer_stream_->set_video_decoder_config(TestVideoConfig::Normal());
   }
 
   void UseEncryptedStream() {
     demuxer_stream_->set_video_decoder_config(
         TestVideoConfig::NormalEncrypted());
   }
 
   void InitializeDecoderSelector(DecryptorCapability decryptor_capability,
                                  int num_decoders) {
     SetDecryptorReadyCB set_decryptor_ready_cb;
     if (decryptor_capability != kNoDecryptor) {
       set_decryptor_ready_cb =
           base::Bind(&VideoDecoderSelectorTest::SetDecryptorReadyCallback,
                      base::Unretained(this));
     }
 
     if (decryptor_capability == kDecryptOnly ||
         decryptor_capability == kDecryptAndDecode) {
       EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
-          .WillRepeatedly(RunCallback<0>(decryptor_.get()));
+          .WillRepeatedly(ExecuteCallbackWithVerifier(
+              decryptor_.get(),
+              base::Bind(&VideoDecoderSelectorTest::DecryptorSet,
+                         base::Unretained(this)),
+              &verifier_));
+      EXPECT_CALL(*this, DecryptorSet(true))
+          .WillRepeatedly(ReportCallback(&verifier_));
 
       if (decryptor_capability == kDecryptOnly) {
         EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
             .WillRepeatedly(RunCallback<1>(false));
       } else {
         EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
             .WillRepeatedly(RunCallback<1>(true));
       }
     } else if (decryptor_capability == kHoldSetDecryptor) {
       // Set and cancel DecryptorReadyCB but the callback is never fired.
@@ skipping 44 matching lines @@
 
   scoped_ptr<VideoDecoderSelector> decoder_selector_;
 
   StrictMock<MockVideoDecoder>* decoder_1_;
   StrictMock<MockVideoDecoder>* decoder_2_;
   ScopedVector<VideoDecoder> all_decoders_;
   scoped_ptr<VideoDecoder> selected_decoder_;
 
   base::MessageLoop message_loop_;
 
+  CallbackPairChecker verifier_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoDecoderSelectorTest);
 };
 
 // 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);
 
@@ skipping 168 matching lines @@
 }
 
 TEST_F(VideoDecoderSelectorTest, Destroy_EncryptedStream_DecryptAndDecode) {
   UseEncryptedStream();
   InitializeDecoderSelector(kHoldSetDecryptor, 1);
 
   SelectDecoderAndDestroy();
 }
 
 }  // namespace media