Rename VideoRenderer::OnTimeStateChanged to OnTime{Progressing,Stopped}

media/renderers/video_renderer_impl.cc

 // Copyright 2013 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/renderers/video_renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 219 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kInitializing);
 
   if (!success) {
     state_ = kUninitialized;
     base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
-  // We're all good!  Consider ourselves flushed. (ThreadMain() should never
-  // see us in the kUninitialized state).
-  // Since we had an initial Preroll(), we consider ourself flushed, because we
-  // have not populated any buffers yet.
+  // We're all good! Consider ourselves flushed because we have not read any
+  // frames yet.
   state_ = kFlushed;
 
   algorithm_.reset(new VideoRendererAlgorithm(wall_clock_time_cb_));
   if (!drop_frames_)
     algorithm_->disable_frame_dropping();
 
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 void VideoRendererImpl::OnPlaybackError(PipelineStatus error) {
@@ skipping 24 matching lines @@
 void VideoRendererImpl::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   tick_clock_.swap(tick_clock);
 }
 
 void VideoRendererImpl::SetGpuMemoryBufferVideoForTesting(
     std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool) {
   gpu_memory_buffer_pool_.swap(gpu_memory_buffer_pool);
 }
 
-void VideoRendererImpl::OnTimeStateChanged(bool time_progressing) {
+void VideoRendererImpl::TimeStartedProgressing() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  time_progressing_ = time_progressing;
+  time_progressing_ = true;
 
-  // WARNING: Do not attempt to use |lock_| here as this may be a reentrant call
-  // in response to callbacks firing above.
-
-  if (sink_started_ == time_progressing_)
+  if (sink_started_)
     return;
 
-  if (time_progressing_) {
-    // If only an EOS frame came in after a seek, the renderer may not have
-    // received the ended event yet though we've posted it.
-    if (rendered_end_of_stream_)
-      return;
+  // If only an EOS frame came in after a seek, the renderer may not have
+  // received the ended event yet though we've posted it.
+  if (rendered_end_of_stream_)
+    return;
 
-    // If we have no frames queued, there is a pending buffering state change in
-    // flight and we should ignore the start attempt.
-    if (!algorithm_->frames_queued()) {
-      DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
-      return;
-    }
+  // If we have no frames queued, there is a pending buffering state change in
+  // flight and we should ignore the start attempt.
+  if (!algorithm_->frames_queued()) {
+    DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
+    return;
+  }
 
-    StartSink();
-  } else {
-    StopSink();
+  StartSink();
+}
 
-    // Make sure we expire everything we can if we can't read anymore currently,
-    // otherwise playback may hang indefinitely.  Note: There are no effective
-    // frames queued at this point, otherwise FrameReady() would have canceled
-    // the underflow state before reaching this point.
-    if (buffering_state_ == BUFFERING_HAVE_NOTHING) {
-      base::AutoLock al(lock_);
-      RemoveFramesForUnderflowOrBackgroundRendering();
-    }
+void VideoRendererImpl::TimeStoppedProgressing() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  time_progressing_ = false;
+
+  if (!sink_started_)
+    return;
+
+  StopSink();
+
+  // Make sure we expire everything we can if we can't read any more currently,
+  // otherwise playback may hang indefinitely.  Note: There are no effective
+  // frames queued at this point, otherwise FrameReady() would have canceled
+  // the underflow state before reaching this point.
+  if (buffering_state_ == BUFFERING_HAVE_NOTHING) {
+    base::AutoLock al(lock_);
+    RemoveFramesForUnderflowOrBackgroundRendering();
   }
 }
 
 void VideoRendererImpl::FrameReadyForCopyingToGpuMemoryBuffers(
     VideoFrameStream::Status status,
     const scoped_refptr<VideoFrame>& frame) {
   if (status != VideoFrameStream::OK || IsBeforeStartTime(frame->timestamp())) {
     VideoRendererImpl::FrameReady(status, frame);
     return;
   }
@@ skipping 75 matching lines @@
       scoped_refptr<VideoFrame> frame = algorithm_->first_frame();
       CheckForMetadataChanges(frame->format(), frame->natural_size());
       sink_->PaintSingleFrame(frame);
     }
   }
 
   // Signal buffering state if we've met our conditions.
   if (buffering_state_ == BUFFERING_HAVE_NOTHING && HaveEnoughData_Locked())
     TransitionToHaveEnough_Locked();
 
-  // Always request more decoded video if we have capacity. This serves two
-  // purposes:
-  //   1) Prerolling while paused
-  //   2) Keeps decoding going if video rendering thread starts falling behind
+  // Always request more decoded video if we have capacity.
   AttemptRead_Locked();
 }
 
 bool VideoRendererImpl::HaveEnoughData_Locked() {
   DCHECK_EQ(state_, kPlaying);
   lock_.AssertAcquired();
 
   if (received_end_of_stream_)
     return true;
 
@@ skipping 266 matching lines @@
 
 void VideoRendererImpl::AttemptReadAndCheckForMetadataChanges(
     VideoPixelFormat pixel_format,
     const gfx::Size& natural_size) {
   base::AutoLock auto_lock(lock_);
   CheckForMetadataChanges(pixel_format, natural_size);
   AttemptRead_Locked();
 }
 
 }  // namespace media