Add RunCallback to invoke a callback parameter in unittests.

media/filters/video_renderer_base_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 <algorithm>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "media/base/data_buffer.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/video_frame.h"
 #include "media/filters/video_renderer_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::StrictMock;
 
 namespace media {
 
 static const int kFrameDuration = 10;
 static const int kVideoDuration = kFrameDuration * 100;
 static const int kEndOfStream = -1;
 static const gfx::Size kNaturalSize(16u, 16u);
 
-ACTION_P(RunPipelineStatusCB1, status) {
-  arg1.Run(status);
-}
-
 class VideoRendererBaseTest : public ::testing::Test {
  public:
   VideoRendererBaseTest()
       : decoder_(new MockVideoDecoder()),
         demuxer_stream_(new MockDemuxerStream()),
         cv_(&lock_),
         event_(false, false),
         timeout_(TestTimeouts::action_timeout()),
         prerolling_(false),
         next_frame_timestamp_(0),
         paint_cv_(&lock_),
         paint_was_called_(false),
         should_queue_read_cb_(false) {
     renderer_ = new VideoRendererBase(
         base::Bind(&VideoRendererBaseTest::Paint, base::Unretained(this)),
         base::Bind(&VideoRendererBaseTest::OnSetOpaque, base::Unretained(this)),
         true);
 
     EXPECT_CALL(*demuxer_stream_, type())
         .WillRepeatedly(Return(DemuxerStream::VIDEO));
 
     // We expect these to be called but we don't care how/when.
     EXPECT_CALL(*decoder_, Stop(_))
-        .WillRepeatedly(RunClosure());
+        .WillRepeatedly(RunClosure<0>());
     EXPECT_CALL(statistics_cb_object_, OnStatistics(_))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnTimeUpdate(_))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnSetOpaque(_))
         .Times(AnyNumber());
   }
 
   virtual ~VideoRendererBaseTest() {
     read_queue_.clear();
@@ skipping 25 matching lines @@
     // Monitor reads from the decoder.
     EXPECT_CALL(*decoder_, Read(_))
         .WillRepeatedly(Invoke(this, &VideoRendererBaseTest::FrameRequested));
 
     EXPECT_CALL(*decoder_, Reset(_))
         .WillRepeatedly(Invoke(this, &VideoRendererBaseTest::FlushRequested));
 
     InSequence s;
 
     EXPECT_CALL(*decoder_, Initialize(_, _, _))
-        .WillOnce(RunPipelineStatusCB1(PIPELINE_OK));
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     // Set playback rate before anything else happens.
     renderer_->SetPlaybackRate(1.0f);
 
     // Initialize, we shouldn't have any reads.
     InitializeRenderer(PIPELINE_OK);
 
     // We expect the video size to be set.
     EXPECT_CALL(*this, OnNaturalSizeChanged(kNaturalSize));
 
@@ skipping 566 matching lines @@
   StartPrerolling(kFrameDuration * 6, PIPELINE_OK);
   AbortRead();
   VerifyNotPrerolling();
   Shutdown();
 }
 
 TEST_F(VideoRendererBaseTest, VideoDecoder_InitFailure) {
   InSequence s;
 
   EXPECT_CALL(*decoder_, Initialize(_, _, _))
-      .WillOnce(RunPipelineStatusCB1(PIPELINE_ERROR_DECODE));
+      .WillOnce(RunCallback<1>(PIPELINE_ERROR_DECODE));
   InitializeRenderer(PIPELINE_ERROR_DECODE);
 }
 
 }  // namespace media