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

content/renderer/media/capture_video_decoder.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_CAPTURE_VIDEO_DECODER_H_
 #define CONTENT_RENDERER_MEDIA_CAPTURE_VIDEO_DECODER_H_
 
-#include <deque>
+#include <queue>
 
 #include "base/time.h"
 #include "content/common/content_export.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/filters.h"
 #include "media/base/video_frame.h"
 #include "media/video/capture/video_capture.h"
 
 namespace base {
 class MessageLoopProxy;
@@ skipping 11 matching lines @@
       media::VideoCaptureSessionId video_stream_id,
       VideoCaptureImplManager* vc_manager,
       const media::VideoCapture::VideoCaptureCapability& capability);
   virtual ~CaptureVideoDecoder();
 
   // Filter implementation.
   virtual void Play(const base::Closure& callback) OVERRIDE;
   virtual void Seek(base::TimeDelta time,
                     const media::FilterStatusCB& cb) OVERRIDE;
   virtual void Pause(const base::Closure& callback) OVERRIDE;
+  virtual void Flush(const base::Closure& callback) OVERRIDE;
   virtual void Stop(const base::Closure& callback) OVERRIDE;
 
   // Decoder implementation.
   virtual void Initialize(
       media::DemuxerStream* demuxer_stream,
       const base::Closure& filter_callback,
       const media::StatisticsCallback& stat_callback) OVERRIDE;
   virtual void Read(const ReadCB& callback) OVERRIDE;
   virtual const gfx::Size& natural_size() OVERRIDE;
 
@@ skipping 17 matching lines @@
     kUnInitialized,
     kNormal,
     kStopped,
     kPaused
   };
 
   void PlayOnDecoderThread(const base::Closure& callback);
   void SeekOnDecoderThread(base::TimeDelta time,
                            const media::FilterStatusCB& cb);
   void PauseOnDecoderThread(const base::Closure& callback);
+  void FlushOnDecoderThread(const base::Closure& callback);
   void StopOnDecoderThread(const base::Closure& callback);
 
   void InitializeOnDecoderThread(
       media::DemuxerStream* demuxer_stream,
       const base::Closure& filter_callback,
       const media::StatisticsCallback& stat_callback);
   void ReadOnDecoderThread(const ReadCB& callback);
 
   void OnStoppedOnDecoderThread(media::VideoCapture* capture);
   void OnBufferReadyOnDecoderThread(
       media::VideoCapture* capture,
       scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf);
   void OnDeviceInfoReceivedOnDecoderThread(
       media::VideoCapture* capture,
       const media::VideoCaptureParams& device_info);
 
-  // Delivers the frame to |read_cb_| and resets the callback.
-  void DeliverFrame(const scoped_refptr<media::VideoFrame>& video_frame);
+  // Helper.
+  void DeliverBlackFrame(const ReadCB& read_cb);
 
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   scoped_refptr<VideoCaptureImplManager> vc_manager_;
   media::VideoCapture::VideoCaptureCapability capability_;
   gfx::Size natural_size_;
   DecoderState state_;
-  ReadCB read_cb_;
+  std::queue<ReadCB> read_cbs_;

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

take a look at the definition of VideoDecoder::Read() and FFmpegVideoDecoder --
the new contract is that only one pending read can be in progress at any time

this is to help make things easier so we don't have to worry about queues of
callbacks :)

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

That sounds scary since single buffer scheme serializes the pipeline operations.
That could slow down the decoding, lead to display jittering, etc.

The callback queue doesn't cost much here and it's more generic.

[acolwell GONE FROM CHROMIUM, 2011/11/16 18:49:21]

It does not serialize pipeline operations. Decoding is happening on a different
thread and the rendererer maintains a queue of frames to avoid display jitter.
The callback queue does have a cost. It makes handling state transitions,
teardown, and ownership more complicated. We have been suffering from this cost
for a while which is why Andrew made the changes he did. The refactoring was
done to simplify the code so it would be less error prone and more predictable. 

Until we start seeing the potential problems you are stating I think it is
better to stick with the simpler solution and avoid callback queues.

   base::Closure pending_stop_cb_;
   media::StatisticsCallback statistics_callback_;
 
   media::VideoCaptureSessionId video_stream_id_;
   media::VideoCapture* capture_engine_;
   base::Time start_time_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptureVideoDecoder);
 };
 
 #endif  // CONTENT_RENDERER_MEDIA_CAPTURE_VIDEO_DECODER_H_