Revert of Rename AudioRenderer::Play/Pause() to Start/StopRendering(). (https://codereview.chromium.org/277123002/)

Reason for revert:
This seems to have broken NewFrameProcessor/PipelineIntegrationTest.ChunkDemuxerAbortRead_AudioOnly/0 Linux Tests (dbg)(2) and Win7 Tests (dbg)(1).
Will provide links and stdio on the new CL. This is speculative, if the issue won't go away, the revert will be reverted.

Original issue's description:
> 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
> 
> Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=270017

TBR=dalecurtis@chromium.org,xhwang@google.com,scherkus@chromium.org
NOTREECHECKS=true
NOTRY=true
BUG=370634

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

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

7 files changed, 109 insertions, 182 deletions

diff --git a/media/base/audio_renderer.h b/media/base/audio_renderer.h
index 2d7d3e1..36890f6 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 StartRendering() = 0;
+  virtual void Play() = 0;
 
   // Signal audio playback to stop until further notice. It is expected that
   // |time_cb| will no longer be run.
-  virtual void StopRendering() = 0;
+  virtual void Pause() = 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 c8548b5..31dec4e 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(StartRendering, void());
-  MOCK_METHOD0(StopRendering, void());
+  MOCK_METHOD0(Play, void());
+  MOCK_METHOD0(Pause, 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 9a74880..90ce799 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(1) << GetStateString(state_) << " -> " << GetStateString(next_state);
+  DVLOG(2) << GetStateString(state_) << " -> " << GetStateString(next_state);
 
   state_ = next_state;
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(next_state));
@@ -483,6 +483,10 @@ 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())));
@@ -753,9 +757,6 @@ 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();
@@ -927,31 +928,29 @@ bool Pipeline::WaitingForEnoughData() const {
 }
 
 void Pipeline::StartWaitingForEnoughData() {
-  DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(state_, kPlaying);
   DCHECK(WaitingForEnoughData());
 
   if (audio_renderer_)
-    audio_renderer_->StopRendering();
+    audio_renderer_->Pause();
 
   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 ec8428f..81575e3 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_, StartRendering());
+        EXPECT_CALL(*audio_renderer_, Play());
       }
       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_, StopRendering());
+      EXPECT_CALL(*audio_renderer_, Pause());
       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_, StartRendering());
+      EXPECT_CALL(*audio_renderer_, Play());
     }
 
     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_, StopRendering());
+  EXPECT_CALL(*audio_renderer_, Pause());
   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_, StopRendering());
+  EXPECT_CALL(*audio_renderer_, Pause());
   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_, StopRendering());
+  EXPECT_CALL(*audio_renderer_, Pause());
   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_, StartRendering());
+  EXPECT_CALL(*audio_renderer_, Play());
 
   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_, StartRendering());
+    EXPECT_CALL(*audio_renderer_, Play());
     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_, StopRendering())
+        EXPECT_CALL(*audio_renderer_, Pause())
             .WillOnce(Stop(pipeline_.get(), stop_cb));
       } else {
         status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*audio_renderer_, StopRendering())
+        EXPECT_CALL(*audio_renderer_, Pause())
             .WillOnce(SetError(pipeline_.get(), status));
       }
 
       return status;
     }
 
-    EXPECT_CALL(*audio_renderer_, StopRendering());
+    EXPECT_CALL(*audio_renderer_, Pause());
 
     if (state == kFlushing) {
       if (stop_or_error == kStop) {
diff --git a/media/filters/audio_renderer_impl.cc b/media/filters/audio_renderer_impl.cc
index 48da818..e189c61 100644
--- a/media/filters/audio_renderer_impl.cc
+++ b/media/filters/audio_renderer_impl.cc
@@ -54,7 +54,6 @@ AudioRendererImpl::AudioRendererImpl(
       hardware_config_(hardware_config),
       now_cb_(base::Bind(&base::TimeTicks::Now)),
       state_(kUninitialized),
-      rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
@@ -74,72 +73,65 @@ AudioRendererImpl::~AudioRendererImpl() {
   DCHECK(!algorithm_.get());
 }
 
-void AudioRendererImpl::StartRendering() {
-  DVLOG(1) << __FUNCTION__;
+void AudioRendererImpl::Play() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(!rendering_);
-  rendering_ = true;
 
   base::AutoLock auto_lock(lock_);
-  // Wait for an eventual call to SetPlaybackRate() to start rendering.
-  if (algorithm_->playback_rate() == 0) {
-    DCHECK(!sink_playing_);
-    return;
-  }
+  DCHECK_EQ(state_, kPaused);
+  ChangeState_Locked(kPlaying);
+  earliest_end_time_ = now_cb_.Run();
 
-  StartRendering_Locked();
+  if (algorithm_->playback_rate() != 0)
+    DoPlay_Locked();
+  else
+    DCHECK(!sink_playing_);
 }
 
-void AudioRendererImpl::StartRendering_Locked() {
-  DVLOG(1) << __FUNCTION__;
+void AudioRendererImpl::DoPlay_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow)
-      << "state_=" << state_;
-  DCHECK(!sink_playing_);
-  DCHECK_NE(algorithm_->playback_rate(), 0);
   lock_.AssertAcquired();
-
   earliest_end_time_ = now_cb_.Run();
-  sink_playing_ = true;
 
-  base::AutoUnlock auto_unlock(lock_);
-  sink_->Play();
+  if ((state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow) &&
+      !sink_playing_) {
+    {
+      base::AutoUnlock auto_unlock(lock_);
+      sink_->Play();
+    }
+
+    sink_playing_ = true;
+  }
 }
 
-void AudioRendererImpl::StopRendering() {
-  DVLOG(1) << __FUNCTION__;
+void AudioRendererImpl::Pause() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(rendering_);
-  rendering_ = false;
 
   base::AutoLock auto_lock(lock_);
-  // Rendering should have already been stopped with a zero playback rate.
-  if (algorithm_->playback_rate() == 0) {
-    DCHECK(!sink_playing_);
-    return;
-  }
+  DCHECK(state_ == kPlaying || state_ == kUnderflow ||
+         state_ == kRebuffering) << "state_ == " << state_;
+  ChangeState_Locked(kPaused);
 
-  StopRendering_Locked();
+  DoPause_Locked();
 }
 
-void AudioRendererImpl::StopRendering_Locked() {
+void AudioRendererImpl::DoPause_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  DCHECK(state_ == kPlaying || state_ == kRebuffering || state_ == kUnderflow)
-      << "state_=" << state_;
-  DCHECK(sink_playing_);
   lock_.AssertAcquired();
 
-  sink_playing_ = false;
-
-  base::AutoUnlock auto_unlock(lock_);
-  sink_->Pause();
+  if (sink_playing_) {
+    {
+      base::AutoUnlock auto_unlock(lock_);
+      sink_->Pause();
+    }
+    sink_playing_ = false;
+  }
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
-  DCHECK_EQ(state_, kPlaying);
+  DCHECK_EQ(state_, kPaused);
   DCHECK(flush_cb_.is_null());
 
   flush_cb_ = callback;
@@ -149,7 +141,6 @@ void AudioRendererImpl::Flush(const base::Closure& callback) {
     return;
   }
 
-  ChangeState_Locked(kFlushed);
   DoFlush_Locked();
 }
 
@@ -158,7 +149,7 @@ void AudioRendererImpl::DoFlush_Locked() {
   lock_.AssertAcquired();
 
   DCHECK(!pending_read_);
-  DCHECK_EQ(state_, kFlushed);
+  DCHECK_EQ(state_, kPaused);
 
   audio_buffer_stream_.Reset(base::Bind(&AudioRendererImpl::ResetDecoderDone,
                                         weak_factory_.GetWeakPtr()));
@@ -171,7 +162,7 @@ void AudioRendererImpl::ResetDecoderDone() {
     if (state_ == kStopped)
       return;
 
-    DCHECK_EQ(state_, kFlushed);
+    DCHECK_EQ(state_, kPaused);
     DCHECK(!flush_cb_.is_null());
 
     audio_clock_.reset(new AudioClock(audio_parameters_.sample_rate()));
@@ -224,7 +215,7 @@ void AudioRendererImpl::Preroll(base::TimeDelta time,
 
   base::AutoLock auto_lock(lock_);
   DCHECK(!sink_playing_);
-  DCHECK_EQ(state_, kFlushed);
+  DCHECK_EQ(state_, kPaused);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
   DCHECK(preroll_cb_.is_null());
 
@@ -330,7 +321,7 @@ void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) {
   algorithm_.reset(new AudioRendererAlgorithm());
   algorithm_->Initialize(0, audio_parameters_);
 
-  ChangeState_Locked(kFlushed);
+  ChangeState_Locked(kPaused);
 
   HistogramRendererEvent(INITIALIZED);
 
@@ -374,7 +365,7 @@ void AudioRendererImpl::SetVolume(float volume) {
 void AudioRendererImpl::DecodedAudioReady(
     AudioBufferStream::Status status,
     const scoped_refptr<AudioBuffer>& buffer) {
-  DVLOG(2) << __FUNCTION__ << "(" << status << ")";
+  DVLOG(1) << __FUNCTION__ << "(" << status << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
@@ -398,7 +389,7 @@ void AudioRendererImpl::DecodedAudioReady(
   DCHECK(buffer.get());
 
   if (state_ == kFlushing) {
-    ChangeState_Locked(kFlushed);
+    ChangeState_Locked(kPaused);
     DoFlush_Locked();
     return;
   }
@@ -472,14 +463,14 @@ bool AudioRendererImpl::HandleSplicerBuffer(
       NOTREACHED();
       return false;
 
-    case kFlushed:
+    case kPaused:
       DCHECK(!pending_read_);
       return false;
 
     case kPrerolling:
       if (!buffer->end_of_stream() && !algorithm_->IsQueueFull())
         return true;
-      ChangeState_Locked(kPlaying);
+      ChangeState_Locked(kPaused);
       base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
       return false;
 
@@ -522,7 +513,7 @@ bool AudioRendererImpl::CanRead_Locked() {
   switch (state_) {
     case kUninitialized:
     case kInitializing:
-    case kFlushed:
+    case kPaused:
     case kFlushing:
     case kStopped:
       return false;
@@ -550,20 +541,12 @@ void AudioRendererImpl::SetPlaybackRate(float playback_rate) {
   // Play: current_playback_rate == 0 && playback_rate != 0
   // Pause: current_playback_rate != 0 && playback_rate == 0
   float current_playback_rate = algorithm_->playback_rate();
-  algorithm_->SetPlaybackRate(playback_rate);
-
-  if (!rendering_)
-    return;
-
-  if (current_playback_rate == 0 && playback_rate != 0) {
-    StartRendering_Locked();
-    return;
-  }
+  if (current_playback_rate == 0 && playback_rate != 0)
+    DoPlay_Locked();
+  else if (current_playback_rate != 0 && playback_rate == 0)
+    DoPause_Locked();
 
-  if (current_playback_rate != 0 && playback_rate == 0) {
-    StopRendering_Locked();
-    return;
-  }
+  algorithm_->SetPlaybackRate(playback_rate);
 }
 
 bool AudioRendererImpl::IsBeforePrerollTime(
@@ -714,8 +697,12 @@ void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) {
     case kInitializing:
       NOTREACHED();
       return;
+    case kPaused:
+      if (status != PIPELINE_OK)
+        error_cb_.Run(status);
+      return;
     case kFlushing:
-      ChangeState_Locked(kFlushed);
+      ChangeState_Locked(kPaused);
 
       if (status == PIPELINE_OK) {
         DoFlush_Locked();
@@ -728,10 +715,9 @@ void AudioRendererImpl::HandleAbortedReadOrDecodeError(bool is_decode_error) {
     case kPrerolling:
       // This is a signal for abort if it's not an error.
       preroll_aborted_ = !is_decode_error;
-      ChangeState_Locked(kPlaying);
+      ChangeState_Locked(kPaused);
       base::ResetAndReturn(&preroll_cb_).Run(status);
       return;
-    case kFlushed:
     case kPlaying:
     case kUnderflow:
     case kRebuffering:
diff --git a/media/filters/audio_renderer_impl.h b/media/filters/audio_renderer_impl.h
index c98ead8..0748f0f 100644
--- a/media/filters/audio_renderer_impl.h
+++ b/media/filters/audio_renderer_impl.h
@@ -72,8 +72,8 @@ class MEDIA_EXPORT AudioRendererImpl
                           const TimeCB& time_cb,
                           const base::Closure& ended_cb,
                           const PipelineStatusCB& error_cb) OVERRIDE;
-  virtual void StartRendering() OVERRIDE;
-  virtual void StopRendering() OVERRIDE;
+  virtual void Play() OVERRIDE;
+  virtual void Pause() OVERRIDE;
   virtual void Flush(const base::Closure& callback) OVERRIDE;
   virtual void Stop(const base::Closure& callback) OVERRIDE;
   virtual void SetPlaybackRate(float rate) OVERRIDE;
@@ -97,33 +97,12 @@ class MEDIA_EXPORT AudioRendererImpl
  private:
   friend class AudioRendererImplTest;
 
-  // Important detail: being in kPlaying doesn't imply that audio is being
-  // rendered. Rather, it means that the renderer is ready to go. The actual
-  // rendering of audio is controlled via Start/StopRendering().
-  //
-  //   kUninitialized
-  //         | Initialize()
-  //         |
-  //         V
-  //    kInitializing
-  //         | Decoders initialized
-  //         |
-  //         V            Decoders reset
-  //      kFlushed <------------------ kFlushing
-  //         | Preroll()                  ^
-  //         |                            |
-  //         V                            | Flush()
-  //     kPrerolling ----------------> kPlaying ---------.
-  //           Enough data buffered       ^              | Not enough data
-  //                                      |              | buffered
-  //                 Enough data buffered |              V
-  //                                 kRebuffering <--- kUnderflow
-  //                                      ResumeAfterUnderflow()
+  // TODO(acolwell): Add a state machine graph.
   enum State {
     kUninitialized,
     kInitializing,
+    kPaused,
     kFlushing,
-    kFlushed,
     kPrerolling,
     kPlaying,
     kStopped,
@@ -148,8 +127,8 @@ class MEDIA_EXPORT AudioRendererImpl
                                     const base::TimeDelta& playback_delay,
                                     const base::TimeTicks& time_now);
 
-  void StartRendering_Locked();
-  void StopRendering_Locked();
+  void DoPlay_Locked();
+  void DoPause_Locked();
 
   // AudioRendererSink::RenderCallback implementation.
   //
@@ -256,9 +235,7 @@ class MEDIA_EXPORT AudioRendererImpl
   // Simple state tracking variable.
   State state_;
 
-  // Keep track of whether or not the sink is playing and whether we should be
-  // rendering.
-  bool rendering_;
+  // Keep track of whether or not the sink is playing.
   bool sink_playing_;
 
   // Keep track of our outstanding read to |decoder_|.
diff --git a/media/filters/audio_renderer_impl_unittest.cc b/media/filters/audio_renderer_impl_unittest.cc
index f472ae9..5937870 100644
--- a/media/filters/audio_renderer_impl_unittest.cc
+++ b/media/filters/audio_renderer_impl_unittest.cc
@@ -228,17 +228,17 @@ class AudioRendererImplTest : public ::testing::Test {
     EXPECT_TRUE(decode_cb_.is_null());
   }
 
-  void StartRendering() {
-    renderer_->StartRendering();
+  void Play() {
+    renderer_->Play();
     renderer_->SetPlaybackRate(1.0f);
   }
 
-  void StopRendering() {
-    renderer_->StopRendering();
+  void Pause() {
+    renderer_->Pause();
   }
 
   void Seek() {
-    StopRendering();
+    Pause();
     Flush();
     Preroll();
   }
@@ -375,7 +375,7 @@ class AudioRendererImplTest : public ::testing::Test {
   void EndOfStreamTest(float playback_rate) {
     Initialize();
     Preroll();
-    StartRendering();
+    Play();
     renderer_->SetPlaybackRate(playback_rate);
 
     // Drain internal buffer, we should have a pending read.
@@ -516,10 +516,10 @@ TEST_F(AudioRendererImplTest, Preroll) {
   Preroll();
 }
 
-TEST_F(AudioRendererImplTest, StartRendering) {
+TEST_F(AudioRendererImplTest, Play) {
   Initialize();
   Preroll();
-  StartRendering();
+  Play();
 
   // Drain internal buffer, we should have a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
@@ -544,7 +544,7 @@ TEST_F(AudioRendererImplTest, Underflow) {
 
   int initial_capacity = buffer_capacity();
 
-  StartRendering();
+  Play();
 
   // Drain internal buffer, we should have a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
@@ -578,7 +578,7 @@ TEST_F(AudioRendererImplTest, Underflow_FollowedByFlush) {
 
   int initial_capacity = buffer_capacity();
 
-  StartRendering();
+  Play();
 
   // Drain internal buffer, we should have a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
@@ -606,7 +606,7 @@ TEST_F(AudioRendererImplTest, Underflow_FollowedByFlush) {
 TEST_F(AudioRendererImplTest, Underflow_EndOfStream) {
   Initialize();
   Preroll();
-  StartRendering();
+  Play();
 
   // Figure out how long until the ended event should fire.  Since
   // ConsumeBufferedData() doesn't provide audio delay information, the time
@@ -652,7 +652,7 @@ TEST_F(AudioRendererImplTest, Underflow_EndOfStream) {
 TEST_F(AudioRendererImplTest, Underflow_ResumeFromCallback) {
   Initialize();
   Preroll();
-  StartRendering();
+  Play();
 
   // Drain internal buffer, we should have a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
@@ -679,7 +679,7 @@ TEST_F(AudioRendererImplTest, Underflow_ResumeFromCallback) {
 TEST_F(AudioRendererImplTest, Underflow_SetPlaybackRate) {
   Initialize();
   Preroll();
-  StartRendering();
+  Play();
 
   // Drain internal buffer, we should have a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
@@ -715,7 +715,7 @@ TEST_F(AudioRendererImplTest, Underflow_SetPlaybackRate) {
 TEST_F(AudioRendererImplTest, Underflow_PausePlay) {
   Initialize();
   Preroll();
-  StartRendering();
+  Play();
 
   // Drain internal buffer, we should have a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
@@ -765,13 +765,13 @@ TEST_F(AudioRendererImplTest, AbortPendingRead_Flush) {
   Initialize();
 
   Preroll();
-  StartRendering();
+  Play();
 
   // Partially drain internal buffer so we get a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered() / 2, NULL));
   WaitForPendingRead();
 
-  StopRendering();
+  Pause();
 
   EXPECT_TRUE(IsReadPending());
 
@@ -793,13 +793,13 @@ TEST_F(AudioRendererImplTest, PendingRead_Flush) {
   Initialize();
 
   Preroll();
-  StartRendering();
+  Play();
 
   // Partially drain internal buffer so we get a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered() / 2, NULL));
   WaitForPendingRead();
 
-  StopRendering();
+  Pause();
 
   EXPECT_TRUE(IsReadPending());
 
@@ -821,13 +821,13 @@ TEST_F(AudioRendererImplTest, PendingRead_Stop) {
   Initialize();
 
   Preroll();
-  StartRendering();
+  Play();
 
   // Partially drain internal buffer so we get a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered() / 2, NULL));
   WaitForPendingRead();
 
-  StopRendering();
+  Pause();
 
   EXPECT_TRUE(IsReadPending());
 
@@ -846,13 +846,13 @@ TEST_F(AudioRendererImplTest, PendingFlush_Stop) {
   Initialize();
 
   Preroll();
-  StartRendering();
+  Play();
 
   // Partially drain internal buffer so we get a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered() / 2, NULL));
   WaitForPendingRead();
 
-  StopRendering();
+  Pause();
 
   EXPECT_TRUE(IsReadPending());
 
@@ -879,7 +879,7 @@ TEST_F(AudioRendererImplTest, InitializeThenStopDuringDecoderInit) {
 TEST_F(AudioRendererImplTest, ConfigChangeDrainsConverter) {
   Initialize();
   Preroll();
-  StartRendering();
+  Play();
 
   // Drain internal buffer, we should have a pending read.
   EXPECT_TRUE(ConsumeBufferedData(frames_buffered(), NULL));
@@ -901,7 +901,7 @@ TEST_F(AudioRendererImplTest, ConfigChangeDrainsConverter) {
 TEST_F(AudioRendererImplTest, TimeUpdatesOnFirstBuffer) {
   Initialize();
   Preroll();
-  StartRendering();
+  Play();
 
   AudioTimestampHelper timestamp_helper(kOutputSamplesPerSecond);
   EXPECT_EQ(kNoTimestamp(), last_time_update());
@@ -933,7 +933,7 @@ TEST_F(AudioRendererImplTest, ImmediateEndOfStream) {
     DeliverEndOfStream();
     event.RunAndWaitForStatus(PIPELINE_OK);
   }
-  StartRendering();
+  Play();
 
   // Read a single frame. We shouldn't be able to satisfy it.
   EXPECT_FALSE(ConsumeBufferedData(1, NULL));
@@ -943,45 +943,10 @@ TEST_F(AudioRendererImplTest, ImmediateEndOfStream) {
 TEST_F(AudioRendererImplTest, OnRenderErrorCausesDecodeError) {
   Initialize();
   Preroll();
-  StartRendering();
+  Play();
 
   EXPECT_CALL(*this, OnError(PIPELINE_ERROR_DECODE));
   sink_->OnRenderError();
 }
 
-// Test for AudioRendererImpl calling Pause()/Play() on the sink when the
-// playback rate is set to zero and non-zero.
-TEST_F(AudioRendererImplTest, SetPlaybackRate) {
-  Initialize();
-  Preroll();
-
-  // Rendering hasn't started. Sink should always be paused.
-  EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
-  renderer_->SetPlaybackRate(0.0f);
-  EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
-  renderer_->SetPlaybackRate(1.0f);
-  EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
-
-  // Rendering has started with non-zero rate. Rate changes will affect sink
-  // state.
-  renderer_->StartRendering();
-  EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
-  renderer_->SetPlaybackRate(0.0f);
-  EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
-  renderer_->SetPlaybackRate(1.0f);
-  EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
-
-  // Rendering has stopped. Sink should be paused.
-  renderer_->StopRendering();
-  EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
-
-  // Start rendering with zero playback rate. Sink should be paused until
-  // non-zero rate is set.
-  renderer_->SetPlaybackRate(0.0f);
-  renderer_->StartRendering();
-  EXPECT_EQ(FakeAudioRendererSink::kPaused, sink_->state());
-  renderer_->SetPlaybackRate(1.0f);
-  EXPECT_EQ(FakeAudioRendererSink::kPlaying, sink_->state());
-}
-
 }  // namespace media