Extract media::Clock::IsPlaying() into media::Pipeline::ClockState enum.

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 24 matching lines @@
 Pipeline::Pipeline(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     MediaLog* media_log)
     : task_runner_(task_runner),
       media_log_(media_log),
       running_(false),
       did_loading_progress_(false),
       volume_(1.0f),
       playback_rate_(0.0f),
       clock_(new Clock(&default_tick_clock_)),
-      waiting_for_clock_update_(false),
+      clock_state_(CLOCK_PAUSED),
       status_(PIPELINE_OK),
       state_(kCreated),
       audio_ended_(false),
       video_ended_(false),
       text_ended_(false),
       audio_buffering_state_(BUFFERING_HAVE_NOTHING),
       video_buffering_state_(BUFFERING_HAVE_NOTHING),
       demuxer_(NULL),
       creation_time_(default_tick_clock_.NowTicks()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
@@ skipping 234 matching lines @@
       &Pipeline::ErrorChangedTask, base::Unretained(this), error));
 
   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error));
 }
 
 void Pipeline::OnAudioTimeUpdate(TimeDelta time, TimeDelta max_time) {
   DCHECK_LE(time.InMicroseconds(), max_time.InMicroseconds());
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
 
-  if (waiting_for_clock_update_ && time < clock_->Elapsed())
+  if (clock_state_ == CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE &&
+      time < clock_->Elapsed()) {
     return;
+  }
 
   // TODO(scherkus): |state_| should only be accessed on pipeline thread, see
   // http://crbug.com/137973
   if (state_ == kSeeking)
     return;
 
   clock_->SetTime(time, max_time);
   StartClockIfWaitingForTimeUpdate_Locked();
 }
 
 void Pipeline::OnVideoTimeUpdate(TimeDelta max_time) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
 
   if (audio_renderer_)
     return;
 
   // TODO(scherkus): |state_| should only be accessed on pipeline thread, see
   // http://crbug.com/137973
   if (state_ == kSeeking)
     return;
 
-  DCHECK(!waiting_for_clock_update_);
+  DCHECK_NE(clock_state_, CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE);
   clock_->SetMaxTime(max_time);
 }
 
 void Pipeline::SetDuration(TimeDelta duration) {
   DCHECK(IsRunning());
   media_log_->AddEvent(
       media_log_->CreateTimeEvent(
           MediaLogEvent::DURATION_SET, "duration", duration));
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
@@ skipping 411 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();
+    PauseClockAndStopRendering_Locked();
     clock_->SetTime(seek_timestamp, seek_timestamp);
   }
   DoSeek(seek_timestamp, base::Bind(
       &Pipeline::OnStateTransition, base::Unretained(this)));
 }
 
 void Pipeline::DoAudioRendererEnded() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ != kPlaying)
@@ skipping 43 matching lines @@
     return;
 
   if (video_renderer_ && !video_ended_)
     return;
 
   if (text_renderer_ && text_renderer_->HasTracks() && !text_ended_)
     return;
 
   {
     base::AutoLock auto_lock(lock_);
-    clock_->EndOfStream();
+    PauseClockAndStopRendering_Locked();
+    clock_->SetTime(clock_->Duration(), clock_->Duration());
   }
 
   DCHECK_EQ(status_, PIPELINE_OK);
   ended_cb_.Run();
 }
 
 void Pipeline::AddTextStreamTask(DemuxerStream* text_stream,
                                  const TextTrackConfig& config) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   // TODO(matthewjheaney): fix up text_ended_ when text stream
@@ skipping 88 matching lines @@
   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_->StopRendering();
-
   base::AutoLock auto_lock(lock_);
-  clock_->Pause();
+  PauseClockAndStopRendering_Locked();
 }
 
 void Pipeline::StartPlayback() {
   DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(state_, kPlaying);
+  DCHECK_EQ(clock_state_, CLOCK_PAUSED);
   DCHECK(!WaitingForEnoughData());
 
   if (audio_renderer_) {
     // 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;
+    clock_state_ = CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE;
     audio_renderer_->StartRendering();
   } else {
     base::AutoLock auto_lock(lock_);
-    DCHECK(!waiting_for_clock_update_);
+    clock_state_ = CLOCK_PLAYING;
     clock_->SetMaxTime(clock_->Duration());
     clock_->Play();
   }
 
   preroll_completed_cb_.Run();
   if (!seek_cb_.is_null())
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 }
 
+void Pipeline::PauseClockAndStopRendering_Locked() {
+  lock_.AssertAcquired();
+  switch (clock_state_) {
+    case CLOCK_PAUSED:
+      return;
+
+    case CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE:
+      audio_renderer_->StopRendering();
+      break;
+
+    case CLOCK_PLAYING:
+      if (audio_renderer_)
+        audio_renderer_->StopRendering();
+      clock_->Pause();
+      break;
+  }
+
+  clock_state_ = CLOCK_PAUSED;
+}
+
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
-  if (!waiting_for_clock_update_)
+  if (clock_state_ != CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE)
     return;
 
-  waiting_for_clock_update_ = false;
+  clock_state_ = CLOCK_PLAYING;
   clock_->Play();
 }
 
 }  // namespace media