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

This makes a clearer separation between methods for controlling the
actual rendering of audio versus methods for controlling the state of the
renderer (i.e,. flushing and seeking).

Consequently, clean up AudioRendererImpl to reflect the separation
between rendering methods and state change methods.

BUG=370634

Review URL: https://codereview.chromium.org/277123002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@270017 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 25 insertions, 24 deletions

diff --git a/media/base/audio_renderer.h b/media/base/audio_renderer.h
index 36890f6..2d7d3e1 100644
--- a/media/base/audio_renderer.h
+++ b/media/base/audio_renderer.h
@@ -49,11 +49,11 @@ class MEDIA_EXPORT AudioRenderer {
 
   // Signal audio playback to start at the current rate. It is expected that
   // |time_cb| will eventually start being run with time updates.
-  virtual void Play() = 0;
+  virtual void StartRendering() = 0;
 
   // Signal audio playback to stop until further notice. It is expected that
   // |time_cb| will no longer be run.
-  virtual void Pause() = 0;
+  virtual void StopRendering() = 0;
 
   // Discard any audio data, executing |callback| when completed.
   virtual void Flush(const base::Closure& callback) = 0;
diff --git a/media/base/mock_filters.h b/media/base/mock_filters.h
index 31dec4e..c8548b5 100644
--- a/media/base/mock_filters.h
+++ b/media/base/mock_filters.h
@@ -145,8 +145,8 @@ class MockAudioRenderer : public AudioRenderer {
                                 const TimeCB& time_cb,
                                 const base::Closure& ended_cb,
                                 const PipelineStatusCB& error_cb));
-  MOCK_METHOD0(Play, void());
-  MOCK_METHOD0(Pause, void());
+  MOCK_METHOD0(StartRendering, void());
+  MOCK_METHOD0(StopRendering, void());
   MOCK_METHOD1(Flush, void(const base::Closure& callback));
   MOCK_METHOD1(Stop, void(const base::Closure& callback));
   MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
diff --git a/media/base/pipeline.cc b/media/base/pipeline.cc
index 90ce799..9a74880 100644
--- a/media/base/pipeline.cc
+++ b/media/base/pipeline.cc
@@ -197,7 +197,7 @@ void Pipeline::SetState(State next_state) {
     creation_time_ = base::TimeTicks();
   }
 
-  DVLOG(2) << GetStateString(state_) << " -> " << GetStateString(next_state);
+  DVLOG(1) << GetStateString(state_) << " -> " << GetStateString(next_state);
 
   state_ = next_state;
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(next_state));
@@ -483,10 +483,6 @@ void Pipeline::DoSeek(
   SerialRunner::Queue bound_fns;
 
   // Pause.
-  if (audio_renderer_) {
-    bound_fns.Push(base::Bind(
-        &AudioRenderer::Pause, base::Unretained(audio_renderer_.get())));
-  }
   if (text_renderer_) {
     bound_fns.Push(base::Bind(
         &TextRenderer::Pause, base::Unretained(text_renderer_.get())));
@@ -757,6 +753,9 @@ void Pipeline::SeekTask(TimeDelta time, const PipelineStatusCB& seek_cb) {
 
   // Kick off seeking!
   {
+    if (audio_renderer_)
+      audio_renderer_->StopRendering();
+
     base::AutoLock auto_lock(lock_);
     if (clock_->IsPlaying())
       clock_->Pause();
@@ -928,29 +927,31 @@ bool Pipeline::WaitingForEnoughData() const {
 }
 
 void Pipeline::StartWaitingForEnoughData() {
+  DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(state_, kPlaying);
   DCHECK(WaitingForEnoughData());
 
   if (audio_renderer_)
-    audio_renderer_->Pause();
+    audio_renderer_->StopRendering();
 
   base::AutoLock auto_lock(lock_);
   clock_->Pause();
 }
 
 void Pipeline::StartPlayback() {
+  DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(state_, kPlaying);
   DCHECK(!WaitingForEnoughData());
 
   if (audio_renderer_) {
-    audio_renderer_->Play();
-
-    base::AutoLock auto_lock(lock_);
     // We use audio stream to update the clock. So if there is such a
     // stream, we pause the clock until we receive a valid timestamp.
+    base::AutoLock auto_lock(lock_);
     waiting_for_clock_update_ = true;
+    audio_renderer_->StartRendering();
   } else {
     base::AutoLock auto_lock(lock_);
+    DCHECK(!waiting_for_clock_update_);
     clock_->SetMaxTime(clock_->Duration());
     clock_->Play();
   }
diff --git a/media/base/pipeline_unittest.cc b/media/base/pipeline_unittest.cc
index 81575e3..ec8428f 100644
--- a/media/base/pipeline_unittest.cc
+++ b/media/base/pipeline_unittest.cc
@@ -208,7 +208,7 @@ class PipelineTest : public ::testing::Test {
         // 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());
     }
@@ -258,14 +258,14 @@ class PipelineTest : public ::testing::Test {
         .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_) {
@@ -664,7 +664,7 @@ TEST_F(PipelineTest, ErrorDuringSeek) {
   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(_))
@@ -718,7 +718,7 @@ TEST_F(PipelineTest, NoMessageDuringTearDownFromError) {
   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(_))
@@ -808,14 +808,14 @@ TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
       .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));
@@ -999,7 +999,7 @@ class PipelineTeardownTest : public PipelineTest {
     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>());
 
@@ -1035,18 +1035,18 @@ class PipelineTeardownTest : public PipelineTest {
 
     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) {