Fix VideoRendererBase to allow the decoder to be flushed with a pending read.

media/filters/video_renderer_base.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/filter_host.h"
@@ skipping 36 matching lines @@
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized || state_ == kError);
   state_ = kPaused;
   callback.Run();
 }
 
 void VideoRendererBase::Flush(const base::Closure& callback) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPaused);
   flush_cb_ = callback;
-  state_ = kFlushing;
+  state_ = kFlushingDecoder;
 
-  AttemptFlush_Locked();
+  // We must unlock here because the callback might run within the Flush()
+  // call.

[scherkus (not reviewing), 2012/04/25 03:33:58]

should we have semantics similar to VideoDecoder::Read() that the cb must be
executed on a separate call stack?

[acolwell GONE FROM CHROMIUM, 2012/04/25 17:41:44]

Yes. I think that is a good idea. I created a bug for this work
(http://crbug.com/125020)

+  base::AutoUnlock auto_unlock(lock_);
+  decoder_->Flush(base::Bind(&VideoRendererBase::OnDecoderFlushDone, this));
 }
 
 void VideoRendererBase::Stop(const base::Closure& callback) {
   if (state_ == kStopped) {
     callback.Run();
     return;
   }
 
   base::PlatformThreadHandle thread_to_join = base::kNullThreadHandle;
   {
@@ skipping 265 matching lines @@
     DCHECK(!pending_paint_);
     pending_paint_with_last_available_ = false;
   } else {
     DCHECK(!frame);
   }
 
   // We had cleared the |pending_paint_| flag, there are chances that current
   // frame is timed-out. We will wake up our main thread to advance the current
   // frame when this is true.
   frame_available_.Signal();
+  if (state_ == kFlushingDecoder)
+    return;
+
   if (state_ == kFlushing) {
     AttemptFlush_Locked();
-  } else if (state_ == kError || state_ == kStopped) {
+    return;
+  }
+
+  if (state_ == kError || state_ == kStopped) {
     DoStopOrError_Locked();
   }
 }
 
 void VideoRendererBase::FrameReady(scoped_refptr<VideoFrame> frame) {
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, kUninitialized);
 
   CHECK(pending_read_);
   pending_read_ = false;
 
   // Already-queued Decoder ReadCB's can fire after various state transitions
   // have happened; in that case just drop those frames immediately.
-  if (state_ == kStopped || state_ == kError || state_ == kFlushed)
+  if (state_ == kStopped || state_ == kError || state_ == kFlushed ||
+      state_ == kFlushingDecoder)
     return;
 
   if (state_ == kFlushing) {
     AttemptFlush_Locked();
     return;
   }
 
   if (!frame) {
     if (state_ != kSeeking)
       return;
@@ skipping 67 matching lines @@
     paint_cb_.Run();
   }
 }
 
 void VideoRendererBase::AttemptRead_Locked() {
   lock_.AssertAcquired();
   DCHECK_NE(kEnded, state_);
 
   if (pending_read_ ||
       NumFrames_Locked() == limits::kMaxVideoFrames ||
-      (!ready_frames_.empty() && ready_frames_.back()->IsEndOfStream())) {
-    return;
-  }
+      (!ready_frames_.empty() && ready_frames_.back()->IsEndOfStream()) ||
+      state_ == kFlushingDecoder ||
+      state_ == kFlushing) {
+     return;
+   }
 
   pending_read_ = true;
   decoder_->Read(base::Bind(&VideoRendererBase::FrameReady, this));
 }
 
+void VideoRendererBase::OnDecoderFlushDone() {
+  base::AutoLock auto_lock(lock_);
+  DCHECK_EQ(kFlushingDecoder, state_);
+  DCHECK(!pending_read_);
+
+  state_ = kFlushing;
+  AttemptFlush_Locked();
+}
+
 void VideoRendererBase::AttemptFlush_Locked() {
   lock_.AssertAcquired();
   DCHECK_EQ(kFlushing, state_);
 
   // Get rid of any ready frames.
   ready_frames_.clear();
 
   if (!pending_paint_ && !pending_read_) {
     state_ = kFlushed;
     current_frame_ = NULL;
-
-    base::Closure flush_cb = flush_cb_;
-    flush_cb_.Reset();
-    decoder_->Flush(flush_cb);
+    base::ResetAndReturn(&flush_cb_).Run();
   }
 }
 
 base::TimeDelta VideoRendererBase::CalculateSleepDuration(
     const scoped_refptr<VideoFrame>& next_frame,
     float playback_rate) {
   // Determine the current and next presentation timestamps.
   base::TimeDelta now = host()->GetTime();
   base::TimeDelta this_pts = current_frame_->GetTimestamp();
   base::TimeDelta next_pts;
@@ skipping 20 matching lines @@
 
 int VideoRendererBase::NumFrames_Locked() const {
   lock_.AssertAcquired();
   int outstanding_frames =
       (current_frame_ ? 1 : 0) + (last_available_frame_ ? 1 : 0) +
       (current_frame_ && (current_frame_ == last_available_frame_) ? -1 : 0);
   return ready_frames_.size() + outstanding_frames;
 }
 
 }  // namespace media