Invalidate VideoRendererImpl's weak ptrs before resetting the decoder

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 75 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (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.
   if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
     buffering_state_ = BUFFERING_HAVE_NOTHING;
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoRendererImpl::OnBufferingStateChange,
                               weak_factory_.GetWeakPtr(), buffering_state_));
   }
   received_end_of_stream_ = false;
   rendered_end_of_stream_ = false;
 
-  algorithm_->Reset();
-
+  // Reset |video_frame_stream_| and drop any pending read callbacks from it.
+  pending_read_ = false;
+  frame_callback_weak_factory_.InvalidateWeakPtrs();
   video_frame_stream_->Reset(
       base::Bind(&VideoRendererImpl::OnVideoFrameStreamResetDone,
                  weak_factory_.GetWeakPtr()));
+
+  // To avoid unnecessary work by VDAs, only delete queued frames after
+  // resetting |video_frame_stream_|. If this is done in the opposite order VDAs
+  // will get a bunch of ReusePictureBuffer() calls before the Reset(), which
+  // they may use to output more frames that won't be used.
+  algorithm_->Reset();
 }
 
 void VideoRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
   DVLOG(1) << __func__ << "(" << timestamp.InMicroseconds() << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK(!pending_read_);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
@@ skipping 208 matching lines @@
   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
       frame, base::Bind(&VideoRendererImpl::FrameReady,
                         frame_callback_weak_factory_.GetWeakPtr(), status));
 }
 
 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);
-
+  DCHECK_EQ(state_, kPlaying);
   CHECK(pending_read_);
   pending_read_ = false;
 
   if (status == VideoFrameStream::DECODE_ERROR) {
     DCHECK(!frame);
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&VideoRendererImpl::OnPlaybackError,
                    weak_factory_.GetWeakPtr(), PIPELINE_ERROR_DECODE));
     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) {
     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;
   } else if ((low_delay_ || !video_frame_stream_->CanReadWithoutStalling()) &&
@@ skipping 140 matching lines @@
 void VideoRendererImpl::OnVideoFrameStreamResetDone() {
   // We don't need to acquire the |lock_| here, because we can only get here
   // when Flush is in progress, so rendering and video sink must be stopped.
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!sink_started_);
   DCHECK_EQ(kFlushing, state_);
   DCHECK(!received_end_of_stream_);
   DCHECK(!rendered_end_of_stream_);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
-  // Pending read might be true if an async video frame copy is in flight.
-  pending_read_ = false;
-  // Drop any pending calls to FrameReady() and
-  // FrameReadyForCopyingToGpuMemoryBuffers()
-  frame_callback_weak_factory_.InvalidateWeakPtrs();
   state_ = kFlushed;
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void VideoRendererImpl::UpdateStats_Locked() {
   lock_.AssertAcquired();
   DCHECK_GE(frames_decoded_, 0);
   DCHECK_GE(frames_dropped_, 0);
 
   if (frames_decoded_ || frames_dropped_) {
@@ skipping 152 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