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

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 "base/bind.h"
 #include "base/callback_helpers.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_stream.h"
 #include "media/filters/fake_demuxer_stream.h"
 #include "media/filters/fake_video_decoder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::Assign;
 using ::testing::Invoke;
+using ::testing::InvokeWithoutArgs;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 static const int kNumConfigs = 3;
 static const int kNumBuffersInOneConfig = 5;
 
+// 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 {
 
 struct VideoFrameStreamTestParams {
   VideoFrameStreamTestParams(bool is_encrypted,
                              int decoding_delay,
                              int parallel_decoding)
       : is_encrypted(is_encrypted),
         decoding_delay(decoding_delay),
         parallel_decoding(parallel_decoding) {}
 
@@ skipping 49 matching lines @@
     message_loop_.RunUntilIdle();
 
     DCHECK(!pending_initialize_);
     DCHECK(!pending_read_);
     DCHECK(!pending_reset_);
     DCHECK(!pending_stop_);
   }
 
   MOCK_METHOD1(OnNewSpliceBuffer, void(base::TimeDelta));
   MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&));
+  MOCK_METHOD1(DecryptorSet, void(bool));
 
   void OnStatistics(const PipelineStatistics& statistics) {
     total_bytes_decoded_ += statistics.video_bytes_decoded;
   }
 
   void OnInitialized(bool success) {
     DCHECK(!pending_read_);
     DCHECK(!pending_reset_);
     DCHECK(pending_initialize_);
     pending_initialize_ = false;
@@ skipping 84 matching lines @@
     DEMUXER_READ_NORMAL,
     DEMUXER_READ_CONFIG_CHANGE,
     SET_DECRYPTOR,
     DECRYPTOR_NO_KEY,
     DECODER_INIT,
     DECODER_REINIT,
     DECODER_DECODE,
     DECODER_RESET
   };
 
+  void ExpectDecryptorNotification() {
+    EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
+        .WillRepeatedly(ExecuteCallbackWithVerifier(
+            decryptor_.get(),
+            base::Bind(&VideoFrameStreamTest::DecryptorSet,
+                       base::Unretained(this)),
+            &verifier_));
+    EXPECT_CALL(*this, DecryptorSet(true))
+        .WillRepeatedly(ReportCallback(&verifier_));
+  }
+
   void EnterPendingState(PendingState state) {
     DCHECK_NE(state, NOT_PENDING);
     switch (state) {
       case DEMUXER_READ_NORMAL:
         demuxer_stream_->HoldNextRead();
         ReadUntilPending();
         break;
 
       case DEMUXER_READ_CONFIG_CHANGE:
         demuxer_stream_->HoldNextConfigChangeRead();
         ReadUntilPending();
         break;
 
       case SET_DECRYPTOR:
         // Hold DecryptorReadyCB.
         EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
             .Times(2);
         // Initialize will fail because no decryptor is available.
         InitializeVideoFrameStream();
         break;
 
       case DECRYPTOR_NO_KEY:
-        EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
-            .WillRepeatedly(RunCallback<0>(decryptor_.get()));
+        ExpectDecryptorNotification();
         has_no_key_ = true;
         ReadOneFrame();
         break;
 
       case DECODER_INIT:
-        EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
-            .WillRepeatedly(RunCallback<0>(decryptor_.get()));
+        ExpectDecryptorNotification();
         decoder_->HoldNextInit();
         InitializeVideoFrameStream();
         break;
 
       case DECODER_REINIT:
         decoder_->HoldNextInit();
         ReadUntilPending();
         break;
 
       case DECODER_DECODE:
@@ skipping 84 matching lines @@
   bool pending_read_;
   bool pending_reset_;
   bool pending_stop_;
   int total_bytes_decoded_;
   scoped_refptr<VideoFrame> frame_read_;
   VideoFrameStream::Status last_read_status_;
 
   // Decryptor has no key to decrypt a frame.
   bool has_no_key_;
 
+  CallbackPairChecker verifier_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoFrameStreamTest);
 };
 
 INSTANTIATE_TEST_CASE_P(
     Clear,
     VideoFrameStreamTest,
     ::testing::Values(
         VideoFrameStreamTestParams(false, 0, 1),
         VideoFrameStreamTestParams(false, 3, 1),
@@ skipping 340 matching lines @@
   // The error must surface from Read() as DECODE_ERROR.
   while (last_read_status_ == VideoFrameStream::OK) {
     ReadOneFrame();
     message_loop_.RunUntilIdle();
     EXPECT_FALSE(pending_read_);
   }
   EXPECT_EQ(VideoFrameStream::DECODE_ERROR, last_read_status_);
 }
 
 }  // namespace media