Partially revert change to not post AttemptRead() every Render().

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"
@@ skipping 221 matching lines @@
   // and MaybeStopSinkAfterFirstPaint() will ignore this request if time starts
   // before the call executes.
   if (render_first_frame_and_stop_ && !posted_maybe_stop_after_first_paint_) {
     posted_maybe_stop_after_first_paint_ = true;
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&VideoRendererImpl::MaybeStopSinkAfterFirstPaint,
                               weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(250));
   }
 
-  // To avoid unnecessary work, only post this task if there is a chance of work
-  // to be done.  AttemptRead() may still ignore this call for other reasons.
-  if (!rendered_end_of_stream_ && !HaveReachedBufferingCap(effective_frames)) {
-    task_runner_->PostTask(FROM_HERE,
-                           base::Bind(&VideoRendererImpl::AttemptRead,
-                                      weak_factory_.GetWeakPtr()));
-  }
+  // Always post this task, it will acquire new frames if necessary and since it
+  // happens on another thread, even if we don't have room in the queue now, by
+  // the time it runs (may be delayed up to 50ms for complex decodes!) we might.
+  task_runner_->PostTask(FROM_HERE, base::Bind(&VideoRendererImpl::AttemptRead,
+                                               weak_factory_.GetWeakPtr()));
 
   return result;
 }
 
 void VideoRendererImpl::OnFrameDropped() {
   base::AutoLock auto_lock(lock_);
   DCHECK(use_new_video_renderering_path_);
   algorithm_->OnLastFrameDropped();
 }
 
@@ skipping 419 matching lines @@
     base::AutoLock auto_lock(lock_);
     render_first_frame_and_stop_ = false;
   }
 
   if (!time_progressing_ && sink_started_)
     StopSink();
 }
 
 bool VideoRendererImpl::HaveReachedBufferingCap() {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  return HaveReachedBufferingCap(use_new_video_renderering_path_
-                                     ? algorithm_->EffectiveFramesQueued()
-                                     : 0);
-}
+  const size_t kMaxVideoFrames = limits::kMaxVideoFrames;
 
-bool VideoRendererImpl::HaveReachedBufferingCap(size_t effective_frames) {
   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 effective_frames >= static_cast<size_t>(limits::kMaxVideoFrames) ||
-           algorithm_->frames_queued() >=
-               static_cast<size_t>(3 * limits::kMaxVideoFrames);
+    return algorithm_->EffectiveFramesQueued() >= kMaxVideoFrames ||
+           algorithm_->frames_queued() >= 3 * kMaxVideoFrames;
   }
 
-  return ready_frames_.size() >= static_cast<size_t>(limits::kMaxVideoFrames);
+  return ready_frames_.size() >= kMaxVideoFrames;
 }
 
 void VideoRendererImpl::StartSink() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   sink_->Start(this);
   sink_started_ = true;
   was_background_rendering_ = false;
 }
 
 void VideoRendererImpl::StopSink() {
@@ skipping 23 matching lines @@
       (algorithm_->frames_queued() == 1u &&
        algorithm_->average_frame_duration() == base::TimeDelta())) {
     rendered_end_of_stream_ = true;
     task_runner_->PostTask(FROM_HERE, ended_cb_);
   }
 
   return effective_frames;
 }
 
 }  // namespace media