handle the case when device is closed before media pipeline is fully initialized.

content/renderer/media/capture_video_decoder.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 "content/renderer/media/capture_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "media/base/demuxer_stream.h"
@@ skipping 58 matching lines @@
 }
 
 void CaptureVideoDecoder::OnStopped(media::VideoCapture* capture) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&CaptureVideoDecoder::OnStoppedOnDecoderThread,
                  this, capture));
 }
 
 void CaptureVideoDecoder::OnPaused(media::VideoCapture* capture) {
-  NOTIMPLEMENTED();
+  message_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&CaptureVideoDecoder::OnPausedOnDecoderThread,
+                 this, capture));
 }
 
 void CaptureVideoDecoder::OnError(media::VideoCapture* capture,
                                   int error_code) {
-  NOTIMPLEMENTED();
+  message_loop_proxy_->PostTask(

[Ronghua Wu (Left Chromium), 2012/05/17 22:54:37]

Add comment why we do OnPusedOnDecoderThread in the OnError callback.

[wjia(left Chromium), 2012/05/23 18:46:48]

This is the video capture protocol between browser process and renderer process.
When there is an error, browser process will no longer send frame over. It's
stated in VideoCaptureHost.

+      FROM_HERE,
+      base::Bind(&CaptureVideoDecoder::OnPausedOnDecoderThread,
+                 this, capture));
 }
 
 void CaptureVideoDecoder::OnRemoved(media::VideoCapture* capture) {
   NOTIMPLEMENTED();
 }
 
 void CaptureVideoDecoder::OnBufferReady(
     media::VideoCapture* capture,
     scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf) {
   DCHECK(buf);
@@ skipping 26 matching lines @@
   statistics_cb_ = statistics_cb;
   status_cb.Run(media::PIPELINE_OK);
   state_ = kNormal;
   capture_engine_->StartCapture(this, capability_);
 }
 
 void CaptureVideoDecoder::ReadOnDecoderThread(const ReadCB& read_cb) {
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   CHECK(read_cb_.is_null());
   read_cb_ = read_cb;
+  if (state_ == kPaused) {
+    DeliverFrame(media::VideoFrame::CreateEmptyFrame());
+  }
 }
 
 void CaptureVideoDecoder::ResetOnDecoderThread(const base::Closure& closure) {
   DVLOG(1) << "ResetOnDecoderThread";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   if (!read_cb_.is_null()) {
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateBlackFrame(natural_size_.width(),
                                             natural_size_.height());
     DeliverFrame(video_frame);
@@ skipping 11 matching lines @@
 
 void CaptureVideoDecoder::OnStoppedOnDecoderThread(
     media::VideoCapture* capture) {
   DVLOG(1) << "OnStoppedOnDecoderThread";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   if (!pending_stop_cb_.is_null())
     base::ResetAndReturn(&pending_stop_cb_).Run();
   vc_manager_->RemoveDevice(video_stream_id_, this);
 }
 
+void CaptureVideoDecoder::OnPausedOnDecoderThread(
+    media::VideoCapture* capture) {
+  DVLOG(1) << "OnPausedOnDecoderThread";
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  state_ = kPaused;
+  if (!read_cb_.is_null()) {
+    DeliverFrame(media::VideoFrame::CreateEmptyFrame());
+  }
+}
+
 void CaptureVideoDecoder::OnDeviceInfoReceivedOnDecoderThread(
     media::VideoCapture* capture,
     const media::VideoCaptureParams& device_info) {
+  DVLOG(1) << "OnDeviceInfoReceivedOnDecoderThread";
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   if (device_info.width != natural_size_.width() ||
       device_info.height != natural_size_.height()) {
     natural_size_.SetSize(device_info.width, device_info.height);
   }
 }
 
 void CaptureVideoDecoder::OnBufferReadyOnDecoderThread(
     media::VideoCapture* capture,
     scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf) {
@@ skipping 51 matching lines @@
 
   DeliverFrame(video_frame);
   capture->FeedBuffer(buf);
 }
 
 void CaptureVideoDecoder::DeliverFrame(
     const scoped_refptr<media::VideoFrame>& video_frame) {
   // Reset the callback before running to protect against reentrancy.
   base::ResetAndReturn(&read_cb_).Run(kOk, video_frame);
 }