Connect the new video rendering path to the compositor.

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
+#include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/buffers.h"
 #include "media/base/limits.h"
+#include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
+// Wait a quarter of a second for Render() callbacks before starting background
+// rendering to keep the decode pump moving.
+const int kBackgroundRenderingTimeoutMs = 250;
+
 VideoRendererImpl::VideoRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     VideoRendererSink* sink,
     ScopedVector<VideoDecoder> decoders,
     bool drop_frames,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(task_runner),
+      use_new_video_renderering_path_(
+          base::CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kEnableNewVideoRenderer)),
       sink_(sink),
+      sink_started_(false),
       video_frame_stream_(
           new VideoFrameStream(task_runner, decoders.Pass(), media_log)),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(),
       pending_read_(false),
       drop_frames_(drop_frames),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       frames_decoded_(0),
       frames_dropped_(0),
       is_shutting_down_(false),
       tick_clock_(new base::DefaultTickClock()),
+      is_background_rendering_(false),
+      should_use_background_renderering_(true),
+      time_progressing_(false),
+      render_first_frame_and_stop_(false),
+      background_rendering_timeout_(
+          base::TimeDelta::FromMilliseconds(kBackgroundRenderingTimeoutMs)),
       weak_factory_(this) {
 }
 
 VideoRendererImpl::~VideoRendererImpl() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  {
+  if (!use_new_video_renderering_path_) {
     base::AutoLock auto_lock(lock_);
     is_shutting_down_ = true;
     frame_available_.Signal();
   }
 
   if (!thread_.is_null())
     base::PlatformThread::Join(thread_);
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
+
+  if (use_new_video_renderering_path_ && sink_started_)
+    StopSink();
 }
 
 void VideoRendererImpl::Flush(const base::Closure& callback) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
+
+  if (use_new_video_renderering_path_ && sink_started_)
+    StopSink();
+
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPlaying);
   flush_cb_ = callback;
   state_ = kFlushing;
 
   // This is necessary if the |video_frame_stream_| has already seen an end of
   // stream and needs to drain it before flushing it.
   ready_frames_.clear();
   if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
     buffering_state_ = BUFFERING_HAVE_NOTHING;
     buffering_state_cb_.Run(BUFFERING_HAVE_NOTHING);
   }
   received_end_of_stream_ = false;
   rendered_end_of_stream_ = false;
 
+  if (use_new_video_renderering_path_)
+    algorithm_->Reset();
+
   video_frame_stream_->Reset(
       base::Bind(&VideoRendererImpl::OnVideoFrameStreamResetDone,
                  weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
   DVLOG(1) << __FUNCTION__ << "(" << timestamp.InMicroseconds() << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kFlushed);
@@ skipping 19 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!buffering_state_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!wall_clock_time_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
+  DCHECK(!render_first_frame_and_stop_);
+  DCHECK(!is_background_rendering_);
+  DCHECK(!time_progressing_);
 
   low_delay_ = (stream->liveness() == DemuxerStream::LIVENESS_LIVE);
 
   // Always post |init_cb_| because |this| could be destroyed if initialization
   // failed.
   init_cb_ = BindToCurrentLoop(init_cb);
 
   statistics_cb_ = statistics_cb;
   buffering_state_cb_ = buffering_state_cb;
   paint_cb_ = base::Bind(&VideoRendererSink::PaintFrameUsingOldRenderingPath,
                          base::Unretained(sink_));
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   wall_clock_time_cb_ = wall_clock_time_cb;
   state_ = kInitializing;
 
   video_frame_stream_->Initialize(
       stream, base::Bind(&VideoRendererImpl::OnVideoFrameStreamInitialized,
                          weak_factory_.GetWeakPtr()),
       set_decryptor_ready_cb, statistics_cb, waiting_for_decryption_key_cb);
 }
 
 scoped_refptr<VideoFrame> VideoRendererImpl::Render(
     base::TimeTicks deadline_min,
     base::TimeTicks deadline_max) {
-  // TODO(dalecurtis): Hook this up to the new VideoRendererAlgorithm.
-  NOTIMPLEMENTED();
-  return nullptr;
+  base::AutoLock auto_lock(lock_);
+  DCHECK(use_new_video_renderering_path_);
+  DCHECK_EQ(state_, kPlaying);
+  last_render_time_ = tick_clock_->NowTicks();
+
+  size_t frames_dropped = 0;
+  scoped_refptr<VideoFrame> result =
+      algorithm_->Render(deadline_min, deadline_max, &frames_dropped);
+
+  // Due to how the |algorithm_| holds frames, this should never be null if
+  // we've had a proper startup sequence.
+  DCHECK(result);
+
+  // See if it's time to fire the ended callback.
+  const size_t effective_frames = MaybeFireEndedCallback();
+
+  // Declare HAVE_NOTHING if we have no more effective frames.
+  if (!effective_frames && !rendered_end_of_stream_ &&
+      buffering_state_ == BUFFERING_HAVE_ENOUGH) {
+    buffering_state_ = BUFFERING_HAVE_NOTHING;
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(buffering_state_cb_, BUFFERING_HAVE_NOTHING));
+  }
+
+  // As we resume from background rendering, don't count the initial batch of
+  // dropped frames since they are likely just dropped due to being too old.
+  if (!is_background_rendering_) {
+    frames_dropped_ += frames_dropped;
+    UpdateStatsAndWait_Locked(base::TimeDelta());
+  }
+  is_background_rendering_ = false;
+
+  // After painting the first frame, if playback hasn't started, we request that
+  // the sink be stopped.  OnTimeStateChanged() will clear this flag if time
+  // starts before we get here and MaybeStopSinkAfterFirstPaint() will ignore
+  // this request if time starts before the call executes.
+  if (render_first_frame_and_stop_) {
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VideoRendererImpl::MaybeStopSinkAfterFirstPaint,
+                              weak_factory_.GetWeakPtr()));
+  }
+
+  // Always post this task, it will acquire new frames if necessary, reset the
+  // background rendering timer, and more.
+  task_runner_->PostTask(FROM_HERE, base::Bind(&VideoRendererImpl::AttemptRead,
+                                               weak_factory_.GetWeakPtr()));
+
+  return result;
 }
 
 void VideoRendererImpl::OnFrameDropped() {
-  // TODO(dalecurtis): Hook this up to the new VideoRendererAlgorithm.
-  NOTIMPLEMENTED();
+  base::AutoLock auto_lock(lock_);
+  DCHECK(use_new_video_renderering_path_);
+  algorithm_->OnLastFrameDropped();
+}
+
+void VideoRendererImpl::SetBackgroundRenderingForTesting(
+    bool enabled,
+    base::TimeDelta timeout) {
+  should_use_background_renderering_ = enabled;
+  background_rendering_timeout_ = timeout;
 }
 
 void VideoRendererImpl::CreateVideoThread() {
   // This may fail and cause a crash if there are too many threads created in
   // the current process. See http://crbug.com/443291
   CHECK(base::PlatformThread::Create(0, this, &thread_));
 
 #if defined(OS_WIN)
   // Bump up our priority so our sleeping is more accurate.
   // TODO(scherkus): find out if this is necessary, but it seems to help.
@@ skipping 11 matching lines @@
     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.
   state_ = kFlushed;
 
-  CreateVideoThread();
+  if (use_new_video_renderering_path_) {
+    algorithm_.reset(new VideoRendererAlgorithm(wall_clock_time_cb_));
+    if (!drop_frames_)
+      algorithm_->disable_frame_dropping();
+  } else {
+    CreateVideoThread();
+  }
 
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 // PlatformThread::Delegate implementation.
 void VideoRendererImpl::ThreadMain() {
+  DCHECK(!use_new_video_renderering_path_);
   base::PlatformThread::SetName("CrVideoRenderer");
 
   // The number of milliseconds to idle when we do not have anything to do.
   // Nothing special about the value, other than we're being more OS-friendly
   // than sleeping for 1 millisecond.
   //
   // TODO(scherkus): switch to pure event-driven frame timing instead of this
   // kIdleTimeDelta business http://crbug.com/106874
   const base::TimeDelta kIdleTimeDelta =
       base::TimeDelta::FromMilliseconds(10);
@@ skipping 77 matching lines @@
     PaintNextReadyFrame_Locked();
   }
 }
 
 void VideoRendererImpl::SetTickClockForTesting(
     scoped_ptr<base::TickClock> tick_clock) {
   tick_clock_.swap(tick_clock);
 }
 
 void VideoRendererImpl::OnTimeStateChanged(bool time_progressing) {
-  // TODO(dalecurtis): Wire up to the VideoRendererSink once it's implemented.
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  time_progressing_ = time_progressing;
+
+  // WARNING: Do not attempt to use |lock_| here as this may be a reentrant call
+  // in response to callbacks firing above.
+
+  if (!use_new_video_renderering_path_ || sink_started_ == time_progressing_)
+    return;
+
+  if (time_progressing_)
+    StartSink();
+  else
+    StopSink();
 }
 
 void VideoRendererImpl::PaintNextReadyFrame_Locked() {
+  DCHECK(!use_new_video_renderering_path_);
   lock_.AssertAcquired();
 
   scoped_refptr<VideoFrame> next_frame = ready_frames_.front();
   ready_frames_.pop_front();
-  frames_decoded_++;
 
   last_media_time_ = wall_clock_time_cb_.Run(next_frame->timestamp());
 
   paint_cb_.Run(next_frame);
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoRendererImpl::AttemptRead, weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::DropNextReadyFrame_Locked() {
+  DCHECK(!use_new_video_renderering_path_);
   TRACE_EVENT0("media", "VideoRendererImpl:frameDropped");
 
   lock_.AssertAcquired();
 
   last_media_time_ =
       wall_clock_time_cb_.Run(ready_frames_.front()->timestamp());
 
   ready_frames_.pop_front();
-  frames_decoded_++;
   frames_dropped_++;
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoRendererImpl::AttemptRead, weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::FrameReady(VideoFrameStream::Status status,
                                    const scoped_refptr<VideoFrame>& frame) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  base::AutoLock auto_lock(lock_);
-  DCHECK_NE(state_, kUninitialized);
-  DCHECK_NE(state_, kFlushed);
+  bool start_sink = false;
+  {
+    base::AutoLock auto_lock(lock_);
+    DCHECK_NE(state_, kUninitialized);
+    DCHECK_NE(state_, kFlushed);
 
-  CHECK(pending_read_);
-  pending_read_ = false;
+    CHECK(pending_read_);
+    pending_read_ = false;
 
-  if (status == VideoFrameStream::DECODE_ERROR ||
-      status == VideoFrameStream::DECRYPT_ERROR) {
-    DCHECK(!frame.get());
-    PipelineStatus error = PIPELINE_ERROR_DECODE;
-    if (status == VideoFrameStream::DECRYPT_ERROR)
-      error = PIPELINE_ERROR_DECRYPT;
-    task_runner_->PostTask(FROM_HERE, base::Bind(error_cb_, error));
-    return;
+    if (status == VideoFrameStream::DECODE_ERROR ||
+        status == VideoFrameStream::DECRYPT_ERROR) {
+      DCHECK(!frame.get());
+      PipelineStatus error = PIPELINE_ERROR_DECODE;
+      if (status == VideoFrameStream::DECRYPT_ERROR)
+        error = PIPELINE_ERROR_DECRYPT;
+      task_runner_->PostTask(FROM_HERE, base::Bind(error_cb_, error));
+      return;
+    }
+
+    // Already-queued VideoFrameStream ReadCB's can fire after various state
+    // transitions have happened; in that case just drop those frames
+    // immediately.
+    if (state_ == kFlushing)
+      return;
+
+    DCHECK_EQ(state_, kPlaying);
+
+    // Can happen when demuxers are preparing for a new Seek().
+    if (!frame.get()) {
+      DCHECK_EQ(status, VideoFrameStream::DEMUXER_READ_ABORTED);
+      return;
+    }
+
+    if (frame->end_of_stream()) {
+      DCHECK(!received_end_of_stream_);
+      received_end_of_stream_ = true;
+
+      // See if we can fire EOS immediately instead of waiting for Render() or
+      // BackgroundRender() to tick.  We also want to fire EOS if we have no
+      // frames and received EOS.
+      if (use_new_video_renderering_path_ &&
+          (time_progressing_ || !algorithm_->frames_queued())) {
+        MaybeFireEndedCallback();
+      }
+    } else {
+      // Maintain the latest frame decoded so the correct frame is displayed
+      // after prerolling has completed.
+      if (frame->timestamp() <= start_timestamp_) {
+        if (use_new_video_renderering_path_)
+          algorithm_->Reset();
+        ready_frames_.clear();
+      }
+      AddReadyFrame_Locked(frame);
+    }
+
+    // Signal buffering state if we've met our conditions for having enough
+    // data.
+    if (buffering_state_ != BUFFERING_HAVE_ENOUGH && HaveEnoughData_Locked()) {
+      TransitionToHaveEnough_Locked();
+      if (use_new_video_renderering_path_ && !sink_started_ &&
+          !rendered_end_of_stream_) {
+        start_sink = true;
+        render_first_frame_and_stop_ = true;
+      }
+    }
+
+    // BackgroundRender may not be ticking fast enough by itself to remove
+    // expired frames, so give it a boost here by ensuring we don't exit the
+    // decoding cycle too early.
+    if (is_background_rendering_) {
+      DCHECK(use_new_video_renderering_path_);
+      BackgroundRender_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
+    AttemptRead_Locked();
   }
 
-  // Already-queued VideoFrameStream ReadCB's can fire after various state
-  // transitions have happened; in that case just drop those frames immediately.
-  if (state_ == kFlushing)
-    return;
-
-  DCHECK_EQ(state_, kPlaying);
-
-  // Can happen when demuxers are preparing for a new Seek().
-  if (!frame.get()) {
-    DCHECK_EQ(status, VideoFrameStream::DEMUXER_READ_ABORTED);
-    return;
+  // If time is progressing, the sink has already been started; this may be true
+  // if we have previously underflowed, yet weren't stopped because of audio.
+  if (use_new_video_renderering_path_ && start_sink) {
+    DCHECK(!sink_started_);
+    StartSink();
   }
-
-  if (frame->end_of_stream()) {
-    DCHECK(!received_end_of_stream_);
-    received_end_of_stream_ = true;
-  } else {
-    // Maintain the latest frame decoded so the correct frame is displayed after
-    // prerolling has completed.
-    if (frame->timestamp() <= start_timestamp_)
-      ready_frames_.clear();
-    AddReadyFrame_Locked(frame);
-  }
-
-  // Signal buffering state if we've met our conditions for having enough data.
-  if (buffering_state_ != BUFFERING_HAVE_ENOUGH && 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
-  AttemptRead_Locked();
 }
 
 bool VideoRendererImpl::HaveEnoughData_Locked() {
   DCHECK_EQ(state_, kPlaying);
-  return received_end_of_stream_ ||
-      !video_frame_stream_->CanReadWithoutStalling() ||
-      ready_frames_.size() >= static_cast<size_t>(limits::kMaxVideoFrames) ||
-      (low_delay_ && ready_frames_.size() > 0);
+
+  if (received_end_of_stream_ || !video_frame_stream_->CanReadWithoutStalling())
+    return true;
+
+  if (HaveReachedBufferingCap())
+    return true;
+
+  if (!low_delay_)
+    return false;
+
+  return ready_frames_.size() > 0 ||
+         (use_new_video_renderering_path_ && algorithm_->frames_queued() > 0);
 }
 
 void VideoRendererImpl::TransitionToHaveEnough_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
   if (!ready_frames_.empty()) {
+    DCHECK(!use_new_video_renderering_path_);
     // Because the clock might remain paused in for an undetermined amount
     // of time (e.g., seeking while paused), paint the first frame.
     PaintNextReadyFrame_Locked();
   }
 
   buffering_state_ = BUFFERING_HAVE_ENOUGH;
   buffering_state_cb_.Run(BUFFERING_HAVE_ENOUGH);
 }
 
 void VideoRendererImpl::AddReadyFrame_Locked(
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
   DCHECK(!frame->end_of_stream());
 
+  frames_decoded_++;
+
+  if (use_new_video_renderering_path_) {
+    algorithm_->EnqueueFrame(frame);
+    return;
+  }
+
   ready_frames_.push_back(frame);
   DCHECK_LE(ready_frames_.size(),
             static_cast<size_t>(limits::kMaxVideoFrames));
 
   // Avoid needlessly waking up |thread_| unless playing.
   if (state_ == kPlaying)
     frame_available_.Signal();
 }
 
 void VideoRendererImpl::AttemptRead() {
   base::AutoLock auto_lock(lock_);
   AttemptRead_Locked();
 }
 
 void VideoRendererImpl::AttemptRead_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
-  if (pending_read_ || received_end_of_stream_ ||
-      ready_frames_.size() == static_cast<size_t>(limits::kMaxVideoFrames)) {
+  if (pending_read_ || received_end_of_stream_)
     return;
-  }
+
+  if (HaveReachedBufferingCap())
+    return;
 
   switch (state_) {
     case kPlaying:
       pending_read_ = true;
       video_frame_stream_->Read(base::Bind(&VideoRendererImpl::FrameReady,
                                            weak_factory_.GetWeakPtr()));
       return;
 
     case kUninitialized:
     case kInitializing:
@@ skipping 14 matching lines @@
 
   state_ = kFlushed;
   latest_possible_paint_time_ = last_media_time_ = base::TimeTicks();
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void VideoRendererImpl::UpdateStatsAndWait_Locked(
     base::TimeDelta wait_duration) {
   lock_.AssertAcquired();
   DCHECK_GE(frames_decoded_, 0);
-  DCHECK_LE(frames_dropped_, frames_decoded_);
+  DCHECK_GE(frames_dropped_, 0);
 
-  if (frames_decoded_) {
+  if (frames_decoded_ || frames_dropped_) {
     PipelineStatistics statistics;
     statistics.video_frames_decoded = frames_decoded_;
     statistics.video_frames_dropped = frames_dropped_;
     task_runner_->PostTask(FROM_HERE, base::Bind(statistics_cb_, statistics));
 
     frames_decoded_ = 0;
     frames_dropped_ = 0;
   }
 
-  frame_available_.TimedWait(wait_duration);
+  if (wait_duration > base::TimeDelta())
+    frame_available_.TimedWait(wait_duration);
+}
+
+void VideoRendererImpl::MaybeStopSinkAfterFirstPaint() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(use_new_video_renderering_path_);
+
+  {
+    base::AutoLock auto_lock(lock_);
+    render_first_frame_and_stop_ = false;
+  }
+
+  if (!time_progressing_ && sink_started_)
+    StopSink();
+}
+
+void VideoRendererImpl::StartBackgroundRenderTimer() {
+  DCHECK(use_new_video_renderering_path_);
+  if (!drop_frames_ || !should_use_background_renderering_)
+    return;
+
+  // |last_render_time_| and |background_rendering_timer_| work in conjunction
+  // to ensure we don't exceed |kBackgroundRenderingTimeoutMs| between calls to
+  // Render().  BackgroundRender() will tick repeatedly and verify that Render()
+  // has fired within the allotted time, by checking |last_render_time_|.
+  last_render_time_ = tick_clock_->NowTicks();
+  background_rendering_timer_.Start(
+      FROM_HERE, background_rendering_timeout_,
+      base::Bind(&VideoRendererImpl::BackgroundRender,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void VideoRendererImpl::BackgroundRender() {
+  base::AutoLock auto_lock(lock_);
+  BackgroundRender_Locked();
+}
+
+void VideoRendererImpl::BackgroundRender_Locked() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK_EQ(state_, kPlaying);
+  lock_.AssertAcquired();
+
+  // If a Render() call never occurs after starting playback for the first frame
+  // we need to carry out the duties of Render() and stop the sink.  We don't
+  // call MaybeStopSinkAfterFirstPaint() since it may need to mutate |sink_|,
+  // which can't be done under lock.
+  if (render_first_frame_and_stop_) {
+    task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VideoRendererImpl::MaybeStopSinkAfterFirstPaint,
+                              weak_factory_.GetWeakPtr()));
+
+    // MaybeStopSinkAfterFirstPaint isn't going to stop the sink if time is
+    // currently progressing, so only bail out if necessary.
+    if (!time_progressing_)
+      return;
+  }
+
+  // Do nothing if Render() calls are progressing normally.
+  if (tick_clock_->NowTicks() - last_render_time_ <
+      background_rendering_timeout_) {
+    return;
+  }
+
+  // First clear as many expired frames as we can.
+  algorithm_->RemoveExpiredFrames(tick_clock_->NowTicks());
+  is_background_rendering_ = true;
+
+  // See if we've run out of frames and need to fire the ended callback.
+  MaybeFireEndedCallback();
+  if (rendered_end_of_stream_)
+    return;
+
+  // Start queuing new frames and scheduled this process again otherwise.
+  AttemptRead_Locked();
+  UpdateStatsAndWait_Locked(base::TimeDelta());
+}
+
+bool VideoRendererImpl::HaveReachedBufferingCap() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  if (use_new_video_renderering_path_) {
+    // When the display rate is less than the frame rate, the effective frames
+    // queued may be much smaller than the actual number of frames queued.  Here
+    // we ensure that frames_queued() doesn't get excessive.
+    return algorithm_->EffectiveFramesQueued() >=
+               static_cast<size_t>(limits::kMaxVideoFrames) ||
+           algorithm_->frames_queued() >=
+               static_cast<size_t>(3 * limits::kMaxVideoFrames);
+  }
+
+  return ready_frames_.size() >= static_cast<size_t>(limits::kMaxVideoFrames);
+}
+
+void VideoRendererImpl::StartSink() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  sink_->Start(this);
+  sink_started_ = true;
+  StartBackgroundRenderTimer();
+}
+
+void VideoRendererImpl::StopSink() {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  sink_->Stop();
+  sink_started_ = false;
+  background_rendering_timer_.Stop();
+  is_background_rendering_ = false;
+}
+
+size_t VideoRendererImpl::MaybeFireEndedCallback() {
+  // If there's only one frame in the video or Render() was never called, the
+  // algorithm will have one frame linger indefinitely.  So in cases where the
+  // frame duration is unknown and we've received EOS, fire it once we get down
+  // to a single frame.
+  const size_t effective_frames = algorithm_->EffectiveFramesQueued();
+
+  if ((!effective_frames ||
+       (algorithm_->frames_queued() == 1u &&
+        algorithm_->average_frame_duration() == base::TimeDelta())) &&
+      received_end_of_stream_ && !rendered_end_of_stream_) {
+    rendered_end_of_stream_ = true;
+    task_runner_->PostTask(FROM_HERE, ended_cb_);
+  }
+
+  return effective_frames;
 }
 
 }  // namespace media