Transition to have nothing if background rendering evicts all frames.

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 298 matching lines @@
     }
 
     StartSink();
   } else {
     StopSink();
 
     // 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)
+    if (buffering_state_ == BUFFERING_HAVE_NOTHING) {
+      base::AutoLock al(lock_);

[watk, 2016/09/26 23:12:43]

I just noticed this. The comment on l.292 says not to hold lock_ :\ Is this a
deadlock?

[DaleCurtis, 2016/09/26 23:23:42]

I think the comment is out of date since we no longer issue buffering state
changes w/o posting. I don't see any other cases where this could be reentrant
now.

       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 118 matching lines @@
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 void VideoRendererImpl::TransitionToHaveNothing() {
   DVLOG(3) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
+  TransitionToHaveNothing_Locked();
+}
+
+void VideoRendererImpl::TransitionToHaveNothing_Locked() {
+  DVLOG(3) << __func__;
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  lock_.AssertAcquired();
+
   if (buffering_state_ != BUFFERING_HAVE_ENOUGH || HaveEnoughData_Locked())
     return;
 
   buffering_state_ = BUFFERING_HAVE_NOTHING;
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoRendererImpl::OnBufferingStateChange,
                             weak_factory_.GetWeakPtr(), buffering_state_));
 }
 
 void VideoRendererImpl::AddReadyFrame_Locked(
@@ skipping 181 matching lines @@
   frames_dropped_ += algorithm_->RemoveExpiredFrames(
       current_time + algorithm_->average_frame_duration());
 
   // If we've paused for underflow, and still have no effective frames, clear
   // the entire queue.  Note: this may cause slight inaccuracies in the number
   // of dropped frames since the frame may have been rendered before.
   if (!sink_started_ && !algorithm_->effective_frames_queued()) {
     frames_dropped_ += algorithm_->frames_queued();
     algorithm_->Reset(
         VideoRendererAlgorithm::ResetFlag::kPreserveNextFrameEstimates);
+
+    // It's possible in the background rendering case for us to expire enough
+    // frames that we need to transition from HAVE_ENOUGH => HAVE_NOTHING. Just
+    // calling this function will check if we need to transition or not.
+    if (buffering_state_ == BUFFERING_HAVE_ENOUGH)
+      TransitionToHaveNothing_Locked();
   }
 }
 
 void VideoRendererImpl::CheckForMetadataChanges(VideoPixelFormat pixel_format,
                                                 const gfx::Size& natural_size) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Notify client of size and opacity changes if this is the first frame
   // or if those have changed from the last frame.
   if (!have_renderered_frames_ || last_frame_natural_size_ != natural_size) {
@@ skipping 12 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