Rename AudioRenderer::Play/Pause() to Start/StopRendering().

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/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 190 matching lines @@
     if (start_status == PIPELINE_OK) {
       EXPECT_CALL(callbacks_, OnMetadata(_)).WillOnce(SaveArg<0>(&metadata_));
 
       if (audio_stream_) {
         EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
         EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
 
         // Startup sequence.
         EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _))
             .WillOnce(RunCallback<1>(PIPELINE_OK));
-        EXPECT_CALL(*audio_renderer_, Play());
+        EXPECT_CALL(*audio_renderer_, StartRendering());
       }
       EXPECT_CALL(callbacks_, OnPrerollCompleted());
     }
 
     pipeline_->Start(
         filter_collection_.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::OnMetadata, base::Unretained(&callbacks_)),
@@ skipping 29 matching lines @@
   FakeTextTrackStream* text_stream() {
     return text_stream_.get();
   }
 
   void ExpectSeek(const base::TimeDelta& seek_time) {
     // Every filter should receive a call to Seek().
     EXPECT_CALL(*demuxer_, Seek(seek_time, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     if (audio_stream_) {
-      EXPECT_CALL(*audio_renderer_, Pause());
+      EXPECT_CALL(*audio_renderer_, StopRendering());
       EXPECT_CALL(*audio_renderer_, Flush(_))
           .WillOnce(RunClosure<0>());
       EXPECT_CALL(*audio_renderer_, Preroll(seek_time, _))
           .WillOnce(RunCallback<1>(PIPELINE_OK));
       EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
       EXPECT_CALL(*audio_renderer_, SetVolume(_));
-      EXPECT_CALL(*audio_renderer_, Play());
+      EXPECT_CALL(*audio_renderer_, StartRendering());
     }
 
     if (video_stream_) {
       EXPECT_CALL(*video_renderer_, Flush(_))
           .WillOnce(RunClosure<0>());
       EXPECT_CALL(*video_renderer_, Preroll(seek_time, _))
           .WillOnce(RunCallback<1>(PIPELINE_OK));
       EXPECT_CALL(*video_renderer_, SetPlaybackRate(_));
       EXPECT_CALL(*video_renderer_, Play(_))
           .WillOnce(RunClosure<0>());
@@ skipping 378 matching lines @@
   InitializePipeline(PIPELINE_OK);
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunUntilIdle();
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
   // Preroll() isn't called as the demuxer errors out first.
-  EXPECT_CALL(*audio_renderer_, Pause());
+  EXPECT_CALL(*audio_renderer_, StopRendering());
   EXPECT_CALL(*audio_renderer_, Flush(_))
       .WillOnce(RunClosure<0>());
   EXPECT_CALL(*audio_renderer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
   EXPECT_CALL(*demuxer_, Seek(seek_time, _))
       .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
   EXPECT_CALL(*demuxer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
@@ skipping 33 matching lines @@
 
   // Trigger additional requests on the pipeline during tear down from error.
   base::Callback<void(PipelineStatus)> cb = base::Bind(
       &TestNoCallsAfterError, pipeline_.get(), &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(*audio_renderer_, Pause());
+  EXPECT_CALL(*audio_renderer_, StopRendering());
   EXPECT_CALL(*audio_renderer_, Flush(_))
       .WillOnce(RunClosure<0>());
   EXPECT_CALL(*audio_renderer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
   EXPECT_CALL(*demuxer_, Seek(seek_time, _))
       .WillOnce(RunCallback<1>(PIPELINE_ERROR_READ));
   EXPECT_CALL(*demuxer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
@@ skipping 69 matching lines @@
   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(*demuxer_, Seek(seek_time, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&closure, &base::Closure::Run),
                       RunCallback<1>(PIPELINE_OK)));
 
-  EXPECT_CALL(*audio_renderer_, Pause());
+  EXPECT_CALL(*audio_renderer_, StopRendering());
   EXPECT_CALL(*audio_renderer_, Flush(_))
       .WillOnce(RunClosure<0>());
   EXPECT_CALL(*audio_renderer_, Preroll(seek_time, _))
       .WillOnce(RunCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
   EXPECT_CALL(*audio_renderer_, SetVolume(_));
-  EXPECT_CALL(*audio_renderer_, Play());
+  EXPECT_CALL(*audio_renderer_, StartRendering());
 
   EXPECT_CALL(callbacks_, OnPrerollCompleted());
   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 165 matching lines @@
     // If we get here it's a successful initialization.
     EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, Preroll(base::TimeDelta(), _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
     EXPECT_CALL(*video_renderer_, SetPlaybackRate(0.0f));
     EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
 
-    EXPECT_CALL(*audio_renderer_, Play());
+    EXPECT_CALL(*audio_renderer_, StartRendering());
     EXPECT_CALL(*video_renderer_, Play(_))
         .WillOnce(RunClosure<0>());
 
     if (status == PIPELINE_OK)
       EXPECT_CALL(callbacks_, OnPrerollCompleted());
 
     return status;
   }
 
   void DoSeek(TeardownState state, StopOrError stop_or_error) {
@@ skipping 15 matching lines @@
   }
 
   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(*audio_renderer_, Pause())
+        EXPECT_CALL(*audio_renderer_, StopRendering())
             .WillOnce(Stop(pipeline_.get(), stop_cb));
       } else {
         status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*audio_renderer_, Pause())
+        EXPECT_CALL(*audio_renderer_, StopRendering())
             .WillOnce(SetError(pipeline_.get(), status));
       }
 
       return status;
     }
 
-    EXPECT_CALL(*audio_renderer_, Pause());
+    EXPECT_CALL(*audio_renderer_, StopRendering());
 
     if (state == kFlushing) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*audio_renderer_, Flush(_))
             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), RunClosure<0>()));
       } else {
         status = PIPELINE_ERROR_READ;
         EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(
             DoAll(SetError(pipeline_.get(), status), RunClosure<0>()));
       }
@@ skipping 40 matching lines @@
     EXPECT_CALL(*video_renderer_, Preroll(_, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     // Playback rate and volume are updated prior to starting.
     EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
     EXPECT_CALL(*video_renderer_, SetPlaybackRate(0.0f));
     EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
 
     if (state == kStarting) {
       if (stop_or_error == kStop) {
-        EXPECT_CALL(*audio_renderer_, Play())
+        EXPECT_CALL(*video_renderer_, Play(_))
             .WillOnce(Stop(pipeline_.get(), stop_cb));
       } else {
         status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*audio_renderer_, Play())
+        EXPECT_CALL(*video_renderer_, Play(_))
             .WillOnce(SetError(pipeline_.get(), status));
       }
       return status;
     }
 
     NOTREACHED() << "State not supported: " << state;
     return status;
   }
 
   void DoStopOrError(StopOrError stop_or_error) {
@@ skipping 50 matching lines @@
 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);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 
 }  // namespace media