Add RunCallback to invoke a callback parameter in unittests.

media/base/pipeline_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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/simple_thread.h"
 #include "media/base/clock.h"
+#include "media/base/gmock_callback_support.h"
 #include "media/base/media_log.h"
-#include "media/base/pipeline.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
+#include "media/base/pipeline.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 // TODO(scherkus): Remove InSequence after refactoring Pipeline.
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
@@ skipping 17 matching lines @@
 }
 
 ACTION_P2(Stop, pipeline, stop_cb) {
   pipeline->Stop(stop_cb);
 }
 
 ACTION_P2(SetError, pipeline, status) {
   pipeline->SetErrorForTesting(status);
 }
 
-ACTION(RunPipelineStatusCB) {
-  arg1.Run(PIPELINE_OK);
-}
-
-ACTION(RunPipelineStatusCB2) {
-  arg2.Run(PIPELINE_OK);
-}
-
-ACTION_P(RunPipelineStatusCBWithStatus, status) {
-  arg1.Run(status);
-}
-
-ACTION_P(RunPipelineStatusCB2WithStatus, status) {
-  arg2.Run(status);
-}
-
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
  public:
   CallbackHelper() {}
   virtual ~CallbackHelper() {}
 
   MOCK_METHOD1(OnStart, void(PipelineStatus));
   MOCK_METHOD1(OnSeek, void(PipelineStatus));
   MOCK_METHOD0(OnStop, void());
@@ skipping 25 matching lines @@
         .WillRepeatedly(Return(null_pointer));
 
     EXPECT_CALL(*mocks_->demuxer(), GetStartTime())
         .WillRepeatedly(Return(base::TimeDelta()));
   }
 
   virtual ~PipelineTest() {
     // Shutdown sequence.
     if (pipeline_->IsRunning()) {
       EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-          .WillOnce(RunClosure());
+          .WillOnce(RunClosure<0>());
 
       if (audio_stream_)
-        EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+        EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
+            .WillOnce(RunClosure<0>());
 
       if (video_stream_)
-        EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
+        EXPECT_CALL(*mocks_->video_renderer(), Stop(_))
+            .WillOnce(RunClosure<0>());
     }
 
     // Expect a stop callback if we were started.
     EXPECT_CALL(callbacks_, OnStop());
     pipeline_->Stop(base::Bind(&CallbackHelper::OnStop,
                                base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
 
     pipeline_ = NULL;
     mocks_.reset();
   }
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams,
                          const base::TimeDelta& duration) {
     EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
         .WillOnce(DoAll(SetDemuxerProperties(duration),
-                        RunPipelineStatusCB()));
+                        RunCallback<1>(PIPELINE_OK)));
 
     // Configure the demuxer to return the streams.
     for (size_t i = 0; i < streams->size(); ++i) {
       scoped_refptr<DemuxerStream> stream((*streams)[i]);
       EXPECT_CALL(*mocks_->demuxer(), GetStream(stream->type()))
           .WillRepeatedly(Return(stream));
     }
   }
 
   void InitializeDemuxer(MockDemuxerStreamVector* streams) {
     // Initialize with a default non-zero duration.
     InitializeDemuxer(streams, base::TimeDelta::FromSeconds(10));
   }
 
   StrictMock<MockDemuxerStream>* CreateStream(DemuxerStream::Type type) {
     StrictMock<MockDemuxerStream>* stream =
         new StrictMock<MockDemuxerStream>();
     EXPECT_CALL(*stream, type())
         .WillRepeatedly(Return(type));
     return stream;
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void InitializeVideoRenderer(const scoped_refptr<DemuxerStream>& stream) {
     EXPECT_CALL(*mocks_->video_renderer(),
                 Initialize(stream, _, _, _, _, _, _, _, _, _))
-        .WillOnce(RunPipelineStatusCB2());
+        .WillOnce(RunCallback<2>(PIPELINE_OK));
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
 
     // Startup sequence.
     EXPECT_CALL(*mocks_->video_renderer(),
                 Preroll(mocks_->demuxer()->GetStartTime(), _))
-        .WillOnce(RunPipelineStatusCB());
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*mocks_->video_renderer(), Play(_))
-        .WillOnce(RunClosure());
+        .WillOnce(RunClosure<0>());
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
   void InitializeAudioRenderer(const scoped_refptr<DemuxerStream>& stream,
                                bool disable_after_init_cb) {
     if (disable_after_init_cb) {
       EXPECT_CALL(*mocks_->audio_renderer(),
                   Initialize(stream, _, _, _, _, _, _, _, _))
-          .WillOnce(DoAll(RunPipelineStatusCB2(),
-                          WithArg<7>(RunClosure())));  // |disabled_cb|.
+          .WillOnce(DoAll(RunCallback<2>(PIPELINE_OK),
+                          WithArg<7>(RunClosure<0>())));  // |disabled_cb|.
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(),
                   Initialize(stream, _, _, _, _, _, _, _, _))
           .WillOnce(DoAll(SaveArg<5>(&audio_time_cb_),
-                          RunPipelineStatusCB2()));
+                          RunCallback<2>(PIPELINE_OK)));
     }
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   void InitializePipeline(PipelineStatus start_status) {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     if (start_status == PIPELINE_OK) {
       EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kHaveMetadata));
       EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
 
       if (audio_stream_) {
         EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
         EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
 
         // Startup sequence.
         EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
-            .WillOnce(RunPipelineStatusCB());
+            .WillOnce(RunCallback<1>(PIPELINE_OK));
         EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-            .WillOnce(RunClosure());
+            .WillOnce(RunClosure<0>());
       }
       EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
     }
 
     pipeline_->Start(
         mocks_->Create().Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnBufferingState,
@@ skipping 15 matching lines @@
     return audio_stream_;
   }
 
   MockDemuxerStream* video_stream() {
     return video_stream_;
   }
 
   void ExpectSeek(const base::TimeDelta& seek_time) {
     // Every filter should receive a call to Seek().
     EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-        .WillOnce(RunPipelineStatusCB());
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(_));
 
     if (audio_stream_) {
       EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-          .WillOnce(RunClosure());
+          .WillOnce(RunClosure<0>());
       EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-          .WillOnce(RunClosure());
+          .WillOnce(RunClosure<0>());
       EXPECT_CALL(*mocks_->audio_renderer(), Preroll(seek_time, _))
-          .WillOnce(RunPipelineStatusCB());
+          .WillOnce(RunCallback<1>(PIPELINE_OK));
       EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(_));
       EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(_));
       EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-          .WillOnce(RunClosure());
+          .WillOnce(RunClosure<0>());
     }
 
     if (video_stream_) {
       EXPECT_CALL(*mocks_->video_renderer(), Pause(_))
-          .WillOnce(RunClosure());
+          .WillOnce(RunClosure<0>());
       EXPECT_CALL(*mocks_->video_renderer(), Flush(_))
-          .WillOnce(RunClosure());
+          .WillOnce(RunClosure<0>());
       EXPECT_CALL(*mocks_->video_renderer(), Preroll(seek_time, _))
-          .WillOnce(RunPipelineStatusCB());
+          .WillOnce(RunCallback<1>(PIPELINE_OK));
       EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(_));
       EXPECT_CALL(*mocks_->video_renderer(), Play(_))
-          .WillOnce(RunClosure());
+          .WillOnce(RunClosure<0>());
     }
 
     EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
 
     // We expect a successful seek callback.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time,
@@ skipping 75 matching lines @@
 
   // Because our callback will get executed when the test tears down, we'll
   // verify that nothing has been called, then set our expectation for the call
   // made during tear down.
   Mock::VerifyAndClear(&callbacks_);
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 }
 
 TEST_F(PipelineTest, URLNotFound) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
-      .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_URL_NOT_FOUND));
+      .WillOnce(RunCallback<1>(PIPELINE_ERROR_URL_NOT_FOUND));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
 
   InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
 }
 
 TEST_F(PipelineTest, NoStreams) {
   EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
-      .WillOnce(RunPipelineStatusCB());
+      .WillOnce(RunCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
 
   InitializePipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
 }
 
 TEST_F(PipelineTest, AudioStream) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams);
@@ skipping 273 matching lines @@
   float playback_rate = 1.0f;
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Preroll() isn't called as the demuxer errors out first.
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
   EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
 
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-      .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_READ));
+      .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
 
   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                         base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
 // Invoked function OnError. This asserts that the pipeline does not enqueue
 // non-teardown related tasks while tearing down.
 static void TestNoCallsAfterError(
@@ skipping 25 matching lines @@
   // Trigger additional requests on the pipeline during tear down from error.
   base::Callback<void(PipelineStatus)> cb = base::Bind(
       &TestNoCallsAfterError, pipeline_, &message_loop_);
   ON_CALL(callbacks_, OnError(_))
       .WillByDefault(Invoke(&cb, &base::Callback<void(PipelineStatus)>::Run));
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Seek() isn't called as the demuxer errors out first.
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
   EXPECT_CALL(*mocks_->audio_renderer(), Stop(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
 
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
-      .WillOnce(RunPipelineStatusCBWithStatus(PIPELINE_ERROR_READ));
+      .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
   EXPECT_CALL(*mocks_->demuxer(), Stop(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
 
   pipeline_->Seek(seek_time, base::Bind(&CallbackHelper::OnSeek,
                                         base::Unretained(&callbacks_)));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
 TEST_F(PipelineTest, StartTimeIsZero) {
   CreateVideoStream();
   MockDemuxerStreamVector streams;
@@ skipping 59 matching lines @@
                      base::TimeDelta::FromMilliseconds(500));
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Arrange to trigger a time update while the demuxer is in the middle of
   // seeking. This update should be ignored by the pipeline and the clock should
   // not get updated.
   base::Closure closure = base::Bind(&RunTimeCB, audio_time_cb_, 300, 700);
   EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&closure, &base::Closure::Run),
-                      RunPipelineStatusCB()));
+                      RunCallback<1>(PIPELINE_OK)));
 
   EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
   EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
   EXPECT_CALL(*mocks_->audio_renderer(), Preroll(seek_time, _))
-      .WillOnce(RunPipelineStatusCB());
+      .WillOnce(RunCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(_));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(_));
   EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(_));
   EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-      .WillOnce(RunClosure());
+      .WillOnce(RunClosure<0>());
 
   EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   DoSeek(seek_time);
 
   EXPECT_EQ(pipeline_->GetMediaTime(), seek_time);
 
   // Now that the seek is complete, verify that time updates advance the current
   // time.
   base::TimeDelta new_time = seek_time + base::TimeDelta::FromMilliseconds(100);
@@ skipping 122 matching lines @@
 
   PipelineStatus SetInitializeExpectations(TeardownState state,
                                            StopOrError stop_or_error) {
     PipelineStatus status = PIPELINE_OK;
     base::Closure stop_cb = base::Bind(
         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
 
     if (state == kInitDemuxer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+                            RunCallback<1>(PIPELINE_OK)));
         EXPECT_CALL(callbacks_, OnStop());
       } else {
         status = DEMUXER_ERROR_COULD_NOT_OPEN;
         EXPECT_CALL(*mocks_->demuxer(), Initialize(_, _))
-            .WillOnce(RunPipelineStatusCBWithStatus(status));
+            .WillOnce(RunCallback<1>(status));
       }
 
-      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
+      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
     CreateAudioStream();
     CreateVideoStream();
     MockDemuxerStreamVector streams;
     streams.push_back(audio_stream());
     streams.push_back(video_stream());
     InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(3000));
 
     if (state == kInitAudioRenderer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*mocks_->audio_renderer(),
                     Initialize(_, _, _, _, _, _, _, _, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB2()));
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+                            RunCallback<2>(PIPELINE_OK)));
         EXPECT_CALL(callbacks_, OnStop());
       } else {
         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
         EXPECT_CALL(*mocks_->audio_renderer(),
                     Initialize(_, _, _, _, _, _, _, _, _))
-            .WillOnce(RunPipelineStatusCB2WithStatus(status));
+            .WillOnce(RunCallback<2>(status));
       }
 
-      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
-      EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
+      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure<0>());
+      EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
     EXPECT_CALL(*mocks_->audio_renderer(),
                 Initialize(_, _, _, _, _, _, _, _, _))
-        .WillOnce(RunPipelineStatusCB2());
+        .WillOnce(RunCallback<2>(PIPELINE_OK));
 
     if (state == kInitVideoRenderer) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*mocks_->video_renderer(),
                     Initialize(_, _, _, _, _, _, _, _, _, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB2()));
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+                            RunCallback<2>(PIPELINE_OK)));
         EXPECT_CALL(callbacks_, OnStop());
       } else {
         status = PIPELINE_ERROR_INITIALIZATION_FAILED;
         EXPECT_CALL(*mocks_->video_renderer(),
                     Initialize(_, _, _, _, _, _, _, _, _, _))
-            .WillOnce(RunPipelineStatusCB2WithStatus(status));
+            .WillOnce(RunCallback<2>(status));
       }
 
-      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
-      EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
-      EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
+      EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure<0>());
+      EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure<0>());
+      EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
     EXPECT_CALL(*mocks_->video_renderer(),
                 Initialize(_, _, _, _, _, _, _, _, _, _))
-        .WillOnce(RunPipelineStatusCB2());
+        .WillOnce(RunCallback<2>(PIPELINE_OK));
 
     EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kHaveMetadata));
 
     // If we get here it's a successful initialization.
     EXPECT_CALL(*mocks_->audio_renderer(), Preroll(base::TimeDelta(), _))
-        .WillOnce(RunPipelineStatusCB());
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*mocks_->video_renderer(), Preroll(base::TimeDelta(), _))
-        .WillOnce(RunPipelineStatusCB());
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
 
     EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-        .WillOnce(RunClosure());
+        .WillOnce(RunClosure<0>());
     EXPECT_CALL(*mocks_->video_renderer(), Play(_))
-        .WillOnce(RunClosure());
+        .WillOnce(RunClosure<0>());
 
     if (status == PIPELINE_OK)
       EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
 
     return status;
   }
 
   void DoSeek(TeardownState state, StopOrError stop_or_error) {
     InSequence s;
     PipelineStatus status = SetSeekExpectations(state, stop_or_error);
 
-    EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
-    EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
-    EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure<0>());
+    EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure<0>());
+    EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure<0>());
     EXPECT_CALL(callbacks_, OnSeek(status));
 
     if (status == PIPELINE_OK) {
       EXPECT_CALL(callbacks_, OnStop());
     }
 
     pipeline_->Seek(base::TimeDelta::FromSeconds(10), base::Bind(
         &CallbackHelper::OnSeek, base::Unretained(&callbacks_)));
     message_loop_.RunAllPending();
   }
 
   PipelineStatus SetSeekExpectations(TeardownState state,
                                      StopOrError stop_or_error) {
     PipelineStatus status = PIPELINE_OK;
     base::Closure stop_cb = base::Bind(
         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
 
     if (state == kPausing) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure<0>()));
       } else {
         status = PIPELINE_ERROR_READ;
         EXPECT_CALL(*mocks_->audio_renderer(), Pause(_))
-            .WillOnce(DoAll(SetError(pipeline_, status), RunClosure()));
+            .WillOnce(DoAll(SetError(pipeline_, status), RunClosure<0>()));
       }
 
       return status;
     }
 
-    EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure());
-    EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->audio_renderer(), Pause(_)).WillOnce(RunClosure<0>());
+    EXPECT_CALL(*mocks_->video_renderer(), Pause(_)).WillOnce(RunClosure<0>());
 
     if (state == kFlushing) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure<0>()));
       } else {
         status = PIPELINE_ERROR_READ;
         EXPECT_CALL(*mocks_->audio_renderer(), Flush(_))
-            .WillOnce(DoAll(SetError(pipeline_, status), RunClosure()));
+            .WillOnce(DoAll(SetError(pipeline_, status), RunClosure<0>()));
       }
 
       return status;
     }
 
-    EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure());
-    EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->audio_renderer(), Flush(_)).WillOnce(RunClosure<0>());
+    EXPECT_CALL(*mocks_->video_renderer(), Flush(_)).WillOnce(RunClosure<0>());
 
     if (state == kSeeking) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+                            RunCallback<1>(PIPELINE_OK)));
       } else {
         status = PIPELINE_ERROR_READ;
         EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
-            .WillOnce(RunPipelineStatusCBWithStatus(status));
+            .WillOnce(RunCallback<1>(status));
       }
 
       return status;
     }
 
     EXPECT_CALL(*mocks_->demuxer(), Seek(_, _))
-        .WillOnce(RunPipelineStatusCB());
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     if (state == kPrerolling) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunPipelineStatusCB()));
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb),
+                            RunCallback<1>(PIPELINE_OK)));
       } else {
         status = PIPELINE_ERROR_READ;
         EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
-            .WillOnce(RunPipelineStatusCBWithStatus(status));
+            .WillOnce(RunCallback<1>(status));
       }
 
       return status;
     }
 
     EXPECT_CALL(*mocks_->audio_renderer(), Preroll(_, _))
-        .WillOnce(RunPipelineStatusCB());
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*mocks_->video_renderer(), Preroll(_, _))
-        .WillOnce(RunPipelineStatusCB());
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     // Playback rate and volume are updated prior to starting.
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
 
     if (state == kStarting) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure()));
+            .WillOnce(DoAll(Stop(pipeline_, stop_cb), RunClosure<0>()));
       } else {
         status = PIPELINE_ERROR_READ;
         EXPECT_CALL(*mocks_->audio_renderer(), Play(_))
-            .WillOnce(DoAll(SetError(pipeline_, status), RunClosure()));
+            .WillOnce(DoAll(SetError(pipeline_, status), RunClosure<0>()));
       }
       return status;
     }
 
     NOTREACHED() << "State not supported: " << state;
     return status;
   }
 
   void DoStopOrError(StopOrError stop_or_error) {
     InSequence s;
 
-    EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure());
-    EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure());
-    EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure());
+    EXPECT_CALL(*mocks_->demuxer(), Stop(_)).WillOnce(RunClosure<0>());
+    EXPECT_CALL(*mocks_->audio_renderer(), Stop(_)).WillOnce(RunClosure<0>());
+    EXPECT_CALL(*mocks_->video_renderer(), Stop(_)).WillOnce(RunClosure<0>());
 
     if (stop_or_error == kStop) {
       EXPECT_CALL(callbacks_, OnStop());
       pipeline_->Stop(base::Bind(
           &CallbackHelper::OnStop, base::Unretained(&callbacks_)));
     } else {
       EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
       pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
     }
 
@@ skipping 22 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, InitAudioRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, InitVideoRenderer);
 INSTANTIATE_TEARDOWN_TEST(Error, Pausing);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Error, Starting);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 }  // namespace media