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

content/renderer/media/rtc_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/rtc_video_decoder.h"
 
-#include <deque>
-
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "media/base/demuxer.h"
 #include "media/base/filter_host.h"
 #include "media/base/filters.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
@@ skipping 61 matching lines @@
     return;
   }
 
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   state_ = kPaused;
 
   VideoDecoder::Pause(callback);
 }
 
+void RTCVideoDecoder::Flush(const base::Closure& callback) {
+  if (MessageLoop::current() != message_loop_) {
+    message_loop_->PostTask(FROM_HERE,
+                            base::Bind(&RTCVideoDecoder::Flush,
+                                       this, callback));
+    return;
+  }
+
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+
+  {
+    base::AutoLock auto_lock(lock_);
+    while (!read_cbs_.empty()) {
+      DeliverBlackFrame(read_cbs_.front());
+      read_cbs_.pop();
+    }
+  }
+
+  VideoDecoder::Flush(callback);
+}
+
 void RTCVideoDecoder::Stop(const base::Closure& callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(FROM_HERE,
                             base::Bind(&RTCVideoDecoder::Stop,
                                        this, callback));
     return;
   }
 
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
@@ skipping 16 matching lines @@
 }
 
 void RTCVideoDecoder::Read(const ReadCB& callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&RTCVideoDecoder::Read, this, callback));
     return;
   }
   DCHECK_EQ(MessageLoop::current(), message_loop_);
+  CHECK(!callback.is_null());
+  if (state_ != kNormal) {
+    DeliverBlackFrame(callback);
+    return;
+  }
   base::AutoLock auto_lock(lock_);
-  CHECK(read_cb_.is_null());
-  read_cb_ = callback;
+  read_cbs_.push(callback);
 }
 
 const gfx::Size& RTCVideoDecoder::natural_size() {
   // TODO(vrk): Return natural size when aspect ratio support is implemented.
   return visible_size_;
 }
 
 bool RTCVideoDecoder::SetSize(int width, int height, int reserved) {
   visible_size_.SetSize(width, height);
 
   // TODO(vrk): Provide natural size when aspect ratio support is implemented.
   host()->SetNaturalVideoSize(visible_size_);
   return true;
 }
 
+// TODO(wjia): this function can be split into two parts so that the |lock_|
+// can be removed.
+// First creates media::VideoFrame, then post a task onto |message_loop_|
+// to deliver that frame.
 bool RTCVideoDecoder::RenderFrame(const cricket::VideoFrame* frame) {
   // Called from libjingle thread.
   DCHECK(frame);
 
   if (state_ != kNormal)
     return true;
 
   ReadCB read_cb;
   {
     base::AutoLock auto_lock(lock_);
-    if (read_cb_.is_null()) {
+    if (read_cbs_.empty()) {
       return true;
     }
-    std::swap(read_cb, read_cb_);
+    read_cb = read_cbs_.front();
+    read_cbs_.pop();
   }
 
   // Always allocate a new frame.
   //
   // TODO(scherkus): migrate this to proper buffer recycling.
   scoped_refptr<media::VideoFrame> video_frame =
       VideoFrame::CreateFrame(VideoFrame::YV12,
                               visible_size_.width(),
                               visible_size_.height(),
                               host()->GetTime(),
                               base::TimeDelta::FromMilliseconds(30));
 
   // Aspect ratio unsupported; DCHECK when there are non-square pixels.
   DCHECK_EQ(frame->GetPixelWidth(), 1u);
   DCHECK_EQ(frame->GetPixelHeight(), 1u);
 
   int y_rows = frame->GetHeight();
   int uv_rows = frame->GetHeight() / 2;  // YV12 format.
   CopyYPlane(frame->GetYPlane(), frame->GetYPitch(), y_rows, video_frame);
   CopyUPlane(frame->GetUPlane(), frame->GetUPitch(), uv_rows, video_frame);
   CopyVPlane(frame->GetVPlane(), frame->GetVPitch(), uv_rows, video_frame);
 
   read_cb.Run(video_frame);
   return true;
 }
+
+void RTCVideoDecoder::DeliverBlackFrame(
+    const ReadCB& read_cb) {
+  CHECK(!read_cb.is_null());
+  scoped_refptr<media::VideoFrame> video_frame =
+      media::VideoFrame::CreateBlackFrame(visible_size_.width(),
+                                          visible_size_.height());
+  read_cb.Run(video_frame);
+}