Add RunCallback to invoke a callback parameter in unittests.

media/filters/decrypting_video_decoder_unittest.cc

Index: media/filters/decrypting_video_decoder_unittest.cc
diff --git a/media/filters/decrypting_video_decoder_unittest.cc b/media/filters/decrypting_video_decoder_unittest.cc
index 2b3666b527f1087d8569d4c30d0c6a3e475cfdc4..d35facf9622a952664e8a668dc9885f35146eba8 100644
--- a/media/filters/decrypting_video_decoder_unittest.cc
+++ b/media/filters/decrypting_video_decoder_unittest.cc
@@ -10,6 +10,7 @@
 #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"
@@ -55,32 +56,16 @@ 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());
 }
 
@@ -112,7 +97,7 @@ class DecryptingVideoDecoderTest : public testing::Test {
     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,
@@ -123,7 +108,7 @@ class DecryptingVideoDecoderTest : public testing::Test {
   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_));
 
@@ -156,9 +141,9 @@ class DecryptingVideoDecoderTest : public testing::Test {
         .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_);
@@ -203,7 +188,7 @@ class DecryptingVideoDecoderTest : public testing::Test {
     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();
@@ -302,7 +287,7 @@ TEST_F(DecryptingVideoDecoderTest, Initialize_InvalidVideoConfig) {
 // 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,
@@ -326,7 +311,7 @@ TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_DecodeError) {
   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_);
@@ -341,9 +326,10 @@ TEST_F(DecryptingVideoDecoderTest, DecryptAndDecode_NeedMoreData) {
       .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);
 
@@ -364,7 +350,8 @@ TEST_F(DecryptingVideoDecoderTest, KeyAdded_DuringWaitingForKey) {
   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();
@@ -378,7 +365,8 @@ TEST_F(DecryptingVideoDecoderTest, KeyAdded_DruingPendingDecode) {
   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
@@ -611,7 +599,8 @@ 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.