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) {
+    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);
 }