corresponding change in CaptureVideoDecoder and RTCVideoDecoder due to pull model used in medi...

content/renderer/media/capture_video_decoder.cc

 // Copyright (c) 2011 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 "content/renderer/media/capture_video_decoder.h"
 
 #include "base/bind.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
@@ skipping 49 matching lines @@
                  this, callback));
 }
 
 void CaptureVideoDecoder::Pause(const base::Closure& callback) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&CaptureVideoDecoder::PauseOnDecoderThread,
                  this, callback));
 }
 
+void CaptureVideoDecoder::Flush(const base::Closure& callback) {
+  message_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&CaptureVideoDecoder::FlushOnDecoderThread,
+                 this, callback));
+}
+
 void CaptureVideoDecoder::Stop(const base::Closure& callback) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&CaptureVideoDecoder::StopOnDecoderThread,
                  this, callback));
 }
 
 void CaptureVideoDecoder::Seek(base::TimeDelta time,
                                const media::FilterStatusCB& cb) {
   message_loop_proxy_->PostTask(
@@ skipping 54 matching lines @@
 
   capture_engine_ = vc_manager_->AddDevice(video_stream_id_, this);
 
   statistics_callback_ = stat_callback;
   filter_callback.Run();
   state_ = kNormal;
 }
 
 void CaptureVideoDecoder::ReadOnDecoderThread(const ReadCB& callback) {
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-  CHECK(read_cb_.is_null());
-  read_cb_ = callback;
+  CHECK(!callback.is_null());
+  if (state_ != kNormal) {

[scherkus (not reviewing), 2011/11/16 01:12:36]

does this actually happen in practice?

I'd be interested in knowing the conditions

[wjia(left Chromium), 2011/11/16 05:25:54]

It could happen in two cases:
1. When pipeline put all filters in pause, there could be racing between Pause()
from pipeline and Read() from VideoRenderer.
2. VideoCapture device has an error event. In the future, error handling will be
added.

+    DeliverBlackFrame(callback);
+    return;
+  }
+  read_cbs_.push(callback);
 }
 
 void CaptureVideoDecoder::PlayOnDecoderThread(const base::Closure& callback) {
   DVLOG(1) << "PlayOnDecoderThread";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   callback.Run();
 }
 
 void CaptureVideoDecoder::PauseOnDecoderThread(const base::Closure& callback) {
   DVLOG(1) << "PauseOnDecoderThread";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   state_ = kPaused;
   media::VideoDecoder::Pause(callback);
 }
 
+void CaptureVideoDecoder::FlushOnDecoderThread(const base::Closure& callback) {
+  DVLOG(1) << "FlushOnDecoderThread";
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  while (!read_cbs_.empty()) {
+    DeliverBlackFrame(read_cbs_.front());
+    read_cbs_.pop();
+  }
+  media::VideoDecoder::Flush(callback);
+}
+
 void CaptureVideoDecoder::StopOnDecoderThread(const base::Closure& callback) {
   DVLOG(1) << "StopOnDecoderThread";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   pending_stop_cb_ = callback;
   state_ = kStopped;
   capture_engine_->StopCapture(this);
 }
 
 void CaptureVideoDecoder::SeekOnDecoderThread(base::TimeDelta time,
                                               const media::FilterStatusCB& cb) {
@@ skipping 23 matching lines @@
     natural_size_.SetSize(device_info.width, device_info.height);
     host()->SetNaturalVideoSize(natural_size_);
   }
 }
 
 void CaptureVideoDecoder::OnBufferReadyOnDecoderThread(
     media::VideoCapture* capture,
     scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf) {
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
 
-  if (read_cb_.is_null() || kNormal != state_) {
+  if (read_cbs_.empty() || kNormal != state_) {
     capture->FeedBuffer(buf);
     return;
   }
 
   // TODO(wjia): should we always expect device to send device info before
   // any buffer, and buffers should have dimension stated in device info?
   // Or should we be flexible as in following code?
   if (buf->width != natural_size_.width() ||
       buf->height != natural_size_.height()) {
     natural_size_.SetSize(buf->width, buf->height);
@@ skipping 18 matching lines @@
   int y_width = buf->width;
   int y_height = buf->height;
   int uv_width = buf->width / 2;
   int uv_height = buf->height / 2;  // YV12 format.
   CopyYPlane(buffer, y_width, y_height, video_frame);
   buffer += y_width * y_height;
   CopyUPlane(buffer, uv_width, uv_height, video_frame);
   buffer += uv_width * uv_height;
   CopyVPlane(buffer, uv_width, uv_height, video_frame);
 
-  DeliverFrame(video_frame);
+  read_cbs_.front().Run(video_frame);
+  read_cbs_.pop();
   capture->FeedBuffer(buf);
 }
 
-void CaptureVideoDecoder::DeliverFrame(
-    const scoped_refptr<media::VideoFrame>& video_frame) {
-  // Reset the callback before running to protect against reentrancy.
-  ReadCB read_cb = read_cb_;
-  read_cb_.Reset();
+void CaptureVideoDecoder::DeliverBlackFrame(
+    const ReadCB& read_cb) {
+  CHECK(!read_cb.is_null());
+  scoped_refptr<media::VideoFrame> video_frame =
+      media::VideoFrame::CreateBlackFrame(natural_size_.width(),
+                                          natural_size_.height());
   read_cb.Run(video_frame);
 }