Add RunCallback to invoke a callback parameter in unittests.

media/filters/ffmpeg_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 "base/memory/singleton.h"
 #include "base/string_util.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
+#include "media/base/gmock_callback_support.h"
 #include "media/base/limits.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_data_util.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_decoder_unittest.h"
 #include "media/filters/ffmpeg_glue.h"
@@ skipping 30 matching lines @@
                   DecryptConfig::kDecryptionKeySize),
       encrypted_frame_offset,
       std::vector<SubsampleEntry>())));
   return buffer;
 }
 
 ACTION_P(ReturnBuffer, buffer) {
   arg0.Run(buffer ? DemuxerStream::kOk : DemuxerStream::kAborted, buffer);
 }
 
-ACTION_P2(RunDecryptCB, status, buffer) {
-  arg2.Run(status, buffer);
-}
-
 class FFmpegVideoDecoderTest : public testing::Test {
  public:
   FFmpegVideoDecoderTest()
       : decryptor_(new MockDecryptor()),
         decoder_(NULL),
         demuxer_(new StrictMock<MockDemuxerStream>()),
         read_cb_(base::Bind(&FFmpegVideoDecoderTest::FrameReady,
                             base::Unretained(this))) {
     FFmpegGlue::InitializeFFmpeg();
 
@@ skipping 383 matching lines @@
 TEST_F(FFmpegVideoDecoderTest, DecodeFrame_SmallerHeight) {
   DecodeIFrameThenTestFile("vp8-I-frame-320x120", 320, 120);
 }
 
 TEST_F(FFmpegVideoDecoderTest, DecodeEncryptedFrame_Normal) {
   InitializeWithEncryptedConfig();
 
   // Simulate decoding a single encrypted frame.
   EXPECT_CALL(*decryptor_,
               Decrypt(Decryptor::kVideo, encrypted_i_frame_buffer_, _))
-      .WillRepeatedly(RunDecryptCB(Decryptor::kSuccess, i_frame_buffer_));
+      .WillRepeatedly(RunCallback<2>(Decryptor::kSuccess, i_frame_buffer_));
 
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   DecodeSingleFrame(encrypted_i_frame_buffer_, &status, &video_frame);
 
   EXPECT_EQ(VideoDecoder::kOk, status);
   ASSERT_TRUE(video_frame);
   EXPECT_FALSE(video_frame->IsEndOfStream());
 }
 
 // Test the case that the decryptor fails to decrypt the encrypted buffer.
 TEST_F(FFmpegVideoDecoderTest, DecodeEncryptedFrame_DecryptError) {
   InitializeWithEncryptedConfig();
 
   // Simulate decoding a single encrypted frame.
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_i_frame_buffer_));
   EXPECT_CALL(*decryptor_,
               Decrypt(Decryptor::kVideo, encrypted_i_frame_buffer_, _))
-      .WillRepeatedly(RunDecryptCB(Decryptor::kError,
-                                   scoped_refptr<media::DecoderBuffer>()));
+      .WillRepeatedly(RunCallback<2>(Decryptor::kError,
+                                     scoped_refptr<media::DecoderBuffer>()));
 
   // Our read should still get satisfied with end of stream frame during an
   // error.
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   Read(&status, &video_frame);
   EXPECT_EQ(VideoDecoder::kDecryptError, status);
   EXPECT_FALSE(video_frame);
 
   message_loop_.RunAllPending();
 }
 
 // Test the case that the decryptor has no key to decrypt the encrypted buffer.
 TEST_F(FFmpegVideoDecoderTest, DecodeEncryptedFrame_NoDecryptionKey) {
   InitializeWithEncryptedConfig();
 
   // Simulate decoding a single encrypted frame.
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_i_frame_buffer_));
   EXPECT_CALL(*decryptor_,
               Decrypt(Decryptor::kVideo, encrypted_i_frame_buffer_, _))
-      .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey,
-                                   scoped_refptr<media::DecoderBuffer>()));
+      .WillRepeatedly(RunCallback<2>(Decryptor::kNoKey,
+                                     scoped_refptr<media::DecoderBuffer>()));
 
   // Our read should still get satisfied with end of stream frame during an
   // error.
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   Read(&status, &video_frame);
   EXPECT_EQ(VideoDecoder::kDecryptError, status);
   EXPECT_FALSE(video_frame);
 
   message_loop_.RunAllPending();
 }
 
 // Test the case that the decryptor fails to decrypt the encrypted buffer but
 // cannot detect the decryption error and returns a corrupted buffer.
 TEST_F(FFmpegVideoDecoderTest, DecodeEncryptedFrame_CorruptedBufferReturned) {
   InitializeWithEncryptedConfig();
 
   // Simulate decoding a single encrypted frame.
   EXPECT_CALL(*demuxer_, Read(_))
       .WillRepeatedly(ReturnBuffer(encrypted_i_frame_buffer_));
   EXPECT_CALL(*decryptor_,
               Decrypt(Decryptor::kVideo, encrypted_i_frame_buffer_, _))
-      .WillRepeatedly(RunDecryptCB(Decryptor::kSuccess,
-                                   corrupt_i_frame_buffer_));
+      .WillRepeatedly(RunCallback<2>(Decryptor::kSuccess,
+                                     corrupt_i_frame_buffer_));
   // The decoder only detects the error at the second decoding call. So
   // |statistics_cb_| still gets called once.
   EXPECT_CALL(statistics_cb_, OnStatistics(_));
 
   // Our read should still get satisfied with end of stream frame during an
   // error.
   VideoDecoder::Status status;
   scoped_refptr<VideoFrame> video_frame;
   Read(&status, &video_frame);
   EXPECT_EQ(VideoDecoder::kDecodeError, status);
@@ skipping 165 matching lines @@
 
   // Signal an aborted demuxer read.
   read_cb.Run(DemuxerStream::kAborted, NULL);
 
   // Make sure we get a NULL video frame returned.
   EXPECT_CALL(*this, FrameReady(VideoDecoder::kOk, IsNull()));
   message_loop_.RunAllPending();
 }
 
 }  // namespace media