Add RunCallback to invoke a callback parameter in unittests.

media/filters/decrypting_video_decoder_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
+#include "media/base/gmock_callback_support.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "media/base/video_frame.h"
 #include "media/filters/decrypting_video_decoder.h"
 #include "media/filters/ffmpeg_decoder_unittest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::AtMost;
 using ::testing::Invoke;
@@ skipping 25 matching lines @@
 }
 
 // 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_P(ReturnBuffer, buffer) {
   arg0.Run(buffer ? DemuxerStream::kOk : DemuxerStream::kAborted, buffer);
 }
 
-ACTION(ReturnConfigChanged) {
-  arg0.Run(DemuxerStream::kConfigChanged, scoped_refptr<DecoderBuffer>(NULL));
-}
-
-ACTION_P(RunCallback0, param) {
+ACTION_P(RunCallbackIfNotNull, param) {
   if (!arg0.is_null())
     arg0.Run(param);
 }
 
-ACTION_P(RunCallback1, param) {
-  arg1.Run(param);
-}
-
-ACTION_P2(RunCallback2, param1, param2) {
-  arg1.Run(param1, param2);
-}
-
 ACTION_P2(ResetAndRunCallback, callback, param) {
   base::ResetAndReturn(callback).Run(param);
 }
 
-MATCHER(IsNullCallback, "") {
-  return (arg.is_null());
-}
-
-MATCHER(IsEndOfStream, "") {
+MATCHER(IsEndOfStream, "end of stream") {
   return (arg->IsEndOfStream());
 }
 
 }  // namespace
 
 class DecryptingVideoDecoderTest : public testing::Test {
  public:
   DecryptingVideoDecoderTest()
       : decoder_(new StrictMock<DecryptingVideoDecoder>(
             base::Bind(&Identity<scoped_refptr<base::MessageLoopProxy> >,
@@ skipping 11 matching lines @@
 
   virtual ~DecryptingVideoDecoderTest() {
     Stop();
   }
 
   void InitializeAndExpectStatus(const VideoDecoderConfig& config,
                                  PipelineStatus status) {
     EXPECT_CALL(*demuxer_, video_decoder_config())
         .WillRepeatedly(ReturnRef(config));
     EXPECT_CALL(*this, RequestDecryptorNotification(_))
-        .WillOnce(RunCallback0(decryptor_.get()));
+        .WillOnce(RunCallbackIfNotNull(decryptor_.get()));
 
     decoder_->Initialize(demuxer_, NewExpectedStatusCB(status),
                          base::Bind(&MockStatisticsCB::OnStatistics,
                                     base::Unretained(&statistics_cb_)));
     message_loop_.RunAllPending();
   }
 
   void Initialize() {
     EXPECT_CALL(*decryptor_, InitializeVideoDecoderMock(_, _))
         .Times(AtMost(1))
-        .WillOnce(RunCallback1(true));
+        .WillOnce(RunCallback<1>(true));
     EXPECT_CALL(*decryptor_, RegisterKeyAddedCB(Decryptor::kVideo, _))
         .WillOnce(SaveArg<1>(&key_added_cb_));
 
     config_.Initialize(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN, kVideoFormat,
                        kCodedSize, kVisibleRect, kNaturalSize,
                        NULL, 0, true, true);
 
     InitializeAndExpectStatus(config_, PIPELINE_OK);
   }
 
@@ skipping 12 matching lines @@
     message_loop_.RunAllPending();
   }
 
   // Sets up expectations and actions to put DecryptingVideoDecoder in an
   // active normal decoding state.
   void EnterNormalDecodingState() {
     EXPECT_CALL(*demuxer_, Read(_))
         .WillOnce(ReturnBuffer(encrypted_buffer_))
         .WillRepeatedly(ReturnBuffer(DecoderBuffer::CreateEOSBuffer()));
     EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-        .WillOnce(RunCallback2(Decryptor::kSuccess, decoded_video_frame_))
-        .WillRepeatedly(RunCallback2(Decryptor::kNeedMoreData,
-                                     scoped_refptr<VideoFrame>()));
+        .WillOnce(RunCallback<1>(Decryptor::kSuccess, decoded_video_frame_))
+        .WillRepeatedly(RunCallback<1>(Decryptor::kNeedMoreData,
+                                       scoped_refptr<VideoFrame>()));
     EXPECT_CALL(statistics_cb_, OnStatistics(_));
 
     ReadAndExpectFrameReadyWith(VideoDecoder::kOk, decoded_video_frame_);
   }
 
   // Sets up expectations and actions to put DecryptingVideoDecoder in an end
   // of stream state. This function must be called after
   // EnterNormalDecodingState() to work.
   void EnterEndOfStreamState() {
     ReadAndExpectFrameReadyWith(VideoDecoder::kOk, end_of_stream_video_frame_);
@@ skipping 24 matching lines @@
     message_loop_.RunAllPending();
     // Make sure the Read() on the decoder triggers a DecryptAndDecode() on the
     // decryptor.
     EXPECT_FALSE(pending_video_decode_cb_.is_null());
   }
 
   void EnterWaitingForKeyState() {
     EXPECT_CALL(*demuxer_, Read(_))
         .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
     EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-        .WillRepeatedly(RunCallback2(Decryptor::kNoKey, null_video_frame_));
+        .WillRepeatedly(RunCallback<1>(Decryptor::kNoKey, null_video_frame_));
     decoder_->Read(base::Bind(&DecryptingVideoDecoderTest::FrameReady,
                               base::Unretained(this)));
     message_loop_.RunAllPending();
   }
 
   void AbortPendingVideoDecodeCB() {
     if (!pending_video_decode_cb_.is_null()) {
       base::ResetAndReturn(&pending_video_decode_cb_).Run(
           Decryptor::kSuccess, scoped_refptr<VideoFrame>(NULL));
     }
@@ skipping 78 matching lines @@
                             VideoFrame::INVALID,
                             kCodedSize, kVisibleRect, kNaturalSize,
                             NULL, 0, true);
 
   InitializeAndExpectStatus(config, PIPELINE_ERROR_DECODE);
 }
 
 // Ensure decoder handles unsupported video configs without crashing.
 TEST_F(DecryptingVideoDecoderTest, Initialize_UnsupportedVideoConfig) {
   EXPECT_CALL(*decryptor_, InitializeVideoDecoderMock(_, _))
-      .WillOnce(RunCallback1(false));
+      .WillOnce(RunCallback<1>(false));
 
   VideoDecoderConfig config(kCodecVP8, VIDEO_CODEC_PROFILE_UNKNOWN,
                             kVideoFormat,
                             kCodedSize, kVisibleRect, kNaturalSize,
                             NULL, 0, true);
 
   InitializeAndExpectStatus(config, DECODER_ERROR_NOT_SUPPORTED);
 }
 
 // Test normal decrypt and decode case.
 TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_Normal) {
   Initialize();
   EnterNormalDecodingState();
 }
 
 // Test the case where the decryptor returns error when doing decrypt and
 // decode.
 TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_DecodeError) {
   Initialize();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-      .WillRepeatedly(RunCallback2(Decryptor::kError,
+      .WillRepeatedly(RunCallback<1>(Decryptor::kError,
                                    scoped_refptr<VideoFrame>(NULL)));
 
   ReadAndExpectFrameReadyWith(VideoDecoder::kDecodeError, null_video_frame_);
 }
 
 // Test the case where the decryptor returns kNeedMoreData to ask for more
 // buffers before it can produce a frame.
 TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_NeedMoreData) {
   Initialize();
 
   EXPECT_CALL(*demuxer_, Read(_))
       .Times(2)
       .WillRepeatedly(ReturnBuffer(encrypted_buffer_));
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-      .WillOnce(RunCallback2(Decryptor::kNeedMoreData,
+      .WillOnce(RunCallback<1>(Decryptor::kNeedMoreData,
                              scoped_refptr<VideoFrame>()))
-      .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_video_frame_));
+      .WillRepeatedly(RunCallback<1>(Decryptor::kSuccess,
+                                     decoded_video_frame_));
   EXPECT_CALL(statistics_cb_, OnStatistics(_))
       .Times(2);
 
   ReadAndExpectFrameReadyWith(VideoDecoder::kOk, decoded_video_frame_);
 }
 
 // Test the case where the decryptor receives end-of-stream buffer.
 TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_EndOfStream) {
   Initialize();
   EnterNormalDecodingState();
   EnterEndOfStreamState();
 }
 
 // Test the case where the a key is added when the decryptor is in
 // kWaitingForKey state.
 TEST_F(DecryptingVideoDecoderTest, KeyAdded_DuringWaitingForKey) {
   Initialize();
   EnterWaitingForKeyState();
 
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-      .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_video_frame_));
+      .WillRepeatedly(RunCallback<1>(Decryptor::kSuccess,
+                                     decoded_video_frame_));
   EXPECT_CALL(statistics_cb_, OnStatistics(_));
   EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, decoded_video_frame_));
   key_added_cb_.Run();
   message_loop_.RunAllPending();
 }
 
 // Test the case where the a key is added when the decryptor is in
 // kPendingDecode state.
 TEST_F(DecryptingVideoDecoderTest, KeyAdded_DruingPendingDecode) {
   Initialize();
   EnterPendingDecodeState();
 
   EXPECT_CALL(*decryptor_, DecryptAndDecodeVideo(_, _))
-      .WillRepeatedly(RunCallback2(Decryptor::kSuccess, decoded_video_frame_));
+      .WillRepeatedly(RunCallback<1>(Decryptor::kSuccess,
+                                     decoded_video_frame_));
   EXPECT_CALL(statistics_cb_, OnStatistics(_));
   EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, decoded_video_frame_));
   // The video decode callback is returned after the correct decryption key is
   // added.
   key_added_cb_.Run();
   base::ResetAndReturn(&pending_video_decode_cb_).Run(Decryptor::kNoKey,
                                                       null_video_frame_);
   message_loop_.RunAllPending();
 }
 
@@ skipping 212 matching lines @@
   base::ResetAndReturn(&pending_demuxer_read_cb_).Run(DemuxerStream::kAborted,
                                                       NULL);
   message_loop_.RunAllPending();
 }
 
 // Test config change on the demuxer stream.
 TEST_F(DecryptingVideoDecoderTest, DemuxerRead_ConfigChanged) {
   Initialize();
 
   EXPECT_CALL(*demuxer_, Read(_))
-      .WillOnce(ReturnConfigChanged());
+      .WillOnce(RunCallback<0>(DemuxerStream::kConfigChanged,
+                               scoped_refptr<DecoderBuffer>()));
 
   // TODO(xhwang): Update this test when kConfigChanged is supported in
   // DecryptingVideoDecoder.
   ReadAndExpectFrameReadyWith(VideoDecoder::kDecodeError, null_video_frame_);
 }
 
 }  // namespace media