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

media/base/pipeline.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 "media/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 179 matching lines @@
 }
 
 void Pipeline::SetState(State next_state) {
   if (state_ != kPlaying && next_state == kPlaying &&
       !creation_time_.is_null()) {
     UMA_HISTOGRAM_TIMES("Media.TimeToPipelineStarted",
                         default_tick_clock_.NowTicks() - creation_time_);
     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));
 }
 
 #define RETURN_STRING(state) case state: return #state;
 
 const char* Pipeline::GetStateString(State state) {
   switch (state) {
     RETURN_STRING(kCreated);
@@ skipping 265 matching lines @@
 }
 
 void Pipeline::DoSeek(
     base::TimeDelta seek_timestamp,
     const PipelineStatusCB& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
   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())));
   }
 
   // Flush.
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Flush, base::Unretained(audio_renderer_.get())));
 
@@ skipping 250 matching lines @@
 
   SetState(kSeeking);
   base::TimeDelta seek_timestamp = std::max(time, demuxer_->GetStartTime());
   seek_cb_ = seek_cb;
   audio_ended_ = false;
   video_ended_ = false;
   text_ended_ = false;
 
   // Kick off seeking!
   {
+    if (audio_renderer_)
+      audio_renderer_->StopRendering();
+
     base::AutoLock auto_lock(lock_);
     if (clock_->IsPlaying())
       clock_->Pause();
     clock_->SetTime(seek_timestamp, seek_timestamp);
   }
   DoSeek(seek_timestamp, base::Bind(
       &Pipeline::OnStateTransition, base::Unretained(this)));
 }
 
 void Pipeline::DoAudioRendererEnded() {
@@ skipping 151 matching lines @@
   if (state_ != kPlaying)
     return false;
   if (audio_renderer_ && audio_buffering_state_ != BUFFERING_HAVE_ENOUGH)
     return true;
   if (video_renderer_ && video_buffering_state_ != BUFFERING_HAVE_ENOUGH)
     return true;
   return false;
 }
 
 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();
   }
 
   preroll_completed_cb_.Run();
   if (!seek_cb_.is_null())
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 }
 
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media