Cache effective frame count. Make expired frame count useful.

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 183 matching lines @@
   //
   // We use the inverse of |render_first_frame_and_stop_| as a proxy for the
   // value of |time_progressing_| here since we can't access it from the
   // compositor thread.  If we're here (in Render()) the sink must have been
   // started -- but if it was started only to render the first frame and stop,
   // then |time_progressing_| is likely false.  If we're still in Render() when
   // |render_first_frame_and_stop_| is false, then |time_progressing_| is true.
   // If |time_progressing_| is actually true when |render_first_frame_and_stop_|
   // is also true, then the ended callback will be harmlessly delayed until
   // MaybeStopSinkAfterFirstPaint() runs and the next Render() call comes in.
-  const size_t effective_frames =
-      MaybeFireEndedCallback_Locked(!render_first_frame_and_stop_);
+  MaybeFireEndedCallback_Locked(!render_first_frame_and_stop_);
   if (buffering_state_ == BUFFERING_HAVE_ENOUGH && !received_end_of_stream_ &&
-      !effective_frames && (!background_rendering ||
-                            (!frames_decoded_ && was_background_rendering_))) {
+      !algorithm_->effective_frames_queued() &&
+      (!background_rendering ||
+       (!frames_decoded_ && was_background_rendering_))) {
     // Do not set |buffering_state_| here as the lock in FrameReady() may be
     // held already and it fire the state changes in the wrong order.
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoRendererImpl::TransitionToHaveNothing,
                               weak_factory_.GetWeakPtr()));
   }
 
   // We don't count dropped frames in the background to avoid skewing the count
   // and impacting JavaScript visible metrics used by web developers.
   //
@@ skipping 113 matching lines @@
     if (sequence_token != sequence_token_)
       return;
 
     DCHECK_NE(state_, kUninitialized);
     DCHECK_NE(state_, kFlushed);
 
     CHECK(pending_read_);
     pending_read_ = false;
 
     if (status == VideoFrameStream::DECODE_ERROR) {
-      DCHECK(!frame.get());
+      DCHECK(!frame);
       PipelineStatus error = PIPELINE_ERROR_DECODE;
       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()) {
+    if (!frame) {
       DCHECK_EQ(status, VideoFrameStream::DEMUXER_READ_ABORTED);
       return;
     }
 
     if (frame->metadata()->IsTrue(VideoFrameMetadata::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().
       MaybeFireEndedCallback_Locked(time_progressing_);
@@ skipping 200 matching lines @@
   render_first_frame_and_stop_ = false;
 }
 
 bool VideoRendererImpl::HaveReachedBufferingCap() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   const size_t kMaxVideoFrames = limits::kMaxVideoFrames;
 
   // 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() >= kMaxVideoFrames ||
+  return algorithm_->effective_frames_queued() >= kMaxVideoFrames ||
          algorithm_->frames_queued() >= 3 * kMaxVideoFrames;
 }
 
 void VideoRendererImpl::StartSink() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_GT(algorithm_->frames_queued(), 0u);
   sink_started_ = true;
   was_background_rendering_ = false;
   sink_->Start(this);
 }
 
 void VideoRendererImpl::StopSink() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   sink_->Stop();
   algorithm_->set_time_stopped();
   sink_started_ = false;
   was_background_rendering_ = false;
 }
 
-size_t VideoRendererImpl::MaybeFireEndedCallback_Locked(bool time_progressing) {
+void VideoRendererImpl::MaybeFireEndedCallback_Locked(bool time_progressing) {
   lock_.AssertAcquired();
 
   // 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();
 
   // Don't fire ended if we haven't received EOS or have already done so.
   if (!received_end_of_stream_ || rendered_end_of_stream_)
-    return effective_frames;
+    return;
 
   // Don't fire ended if time isn't moving and we have frames.
   if (!time_progressing && algorithm_->frames_queued())
-    return effective_frames;
+    return;
 
   // Fire ended if we have no more effective frames or only ever had one frame.
-  if (!effective_frames ||
+  if (!algorithm_->effective_frames_queued() ||
       (algorithm_->frames_queued() == 1u &&
-       algorithm_->average_frame_duration() == base::TimeDelta())) {
+       algorithm_->average_frame_duration().is_zero())) {
     rendered_end_of_stream_ = true;
     task_runner_->PostTask(FROM_HERE, ended_cb_);
   }
-
-  return effective_frames;
 }
 
 base::TimeTicks VideoRendererImpl::ConvertMediaTimestamp(
     base::TimeDelta media_time) {
   std::vector<base::TimeDelta> media_times(1, media_time);
   std::vector<base::TimeTicks> wall_clock_times;
   if (!wall_clock_time_cb_.Run(media_times, &wall_clock_times))
     return base::TimeTicks();
   return wall_clock_times[0];
 }
 
 base::TimeTicks VideoRendererImpl::GetCurrentMediaTimeAsWallClockTime() {
   std::vector<base::TimeTicks> current_time;
   wall_clock_time_cb_.Run(std::vector<base::TimeDelta>(), &current_time);
   return current_time[0];
 }
 
 bool VideoRendererImpl::IsBeforeStartTime(base::TimeDelta timestamp) {
   return timestamp + video_frame_stream_->AverageDuration() < start_timestamp_;
 }
 
 }  // namespace media