WebContentsVideoCaptureDevice: Recover after errors.

content/browser/renderer_host/media/web_contents_video_capture_device.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.
 //
 // Implementation notes: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance.  Therefore, the process of capturing has been split up into a
 // pipeline of three stages.  Each stage executes on its own thread:
 //
 //   1. Capture: A bitmap is snapshotted/copied from the RenderView's backing
@@ skipping 415 matching lines @@
 
 void VideoFrameRenderer::RenderOnRenderThread(
     int frame_number,
     const SkBitmap& captured_bitmap,
     int frame_width, int frame_height,
     const DoneCB& done_cb) {
   DCHECK_EQ(render_thread_.message_loop(), MessageLoop::current());
 
   TRACE_EVENT1("mirroring", "RenderFrame", "frame_number", frame_number);
 
+  base::ScopedClosureRunner failure_handler(
+      base::Bind(done_cb, static_cast<const SkBitmap*>(NULL)));
+
   gfx::Size fitted_size;
   {
     SkAutoLockPixels locker(captured_bitmap);
 
     // Sanity-check the captured bitmap.
     if (captured_bitmap.empty() ||
         !captured_bitmap.readyToDraw() ||
         captured_bitmap.config() != SkBitmap::kARGB_8888_Config ||
         captured_bitmap.width() < 2 || captured_bitmap.height() < 2) {
       DVLOG(1) << "captured_bitmap unacceptable (size="
@@ skipping 68 matching lines @@
     out->region_used = region_in_frame;
 
     scaled_bitmap->copyPixelsTo(
         out->frame_buffer.getAddr32(region_in_frame.x(), region_in_frame.y()),
         out->frame_buffer.getSize(),
         out->frame_buffer.rowBytes(),
         true);
   }
 
   // The result is now ready.
+  failure_handler.Release();
   {
     base::AutoLock guard(lock_);
     out->in_use = true;
   }
   done_cb.Run(&out->frame_buffer);
 }
 
 void VideoFrameRenderer::Release(const SkBitmap* frame_buffer) {
   if (frame_buffer == &(output_[0].frame_buffer)) {
     base::AutoLock guard(lock_);
@@ skipping 459 matching lines @@
 }
 
 void CaptureMachine::RenderComplete(int frame_number,
                                     const base::Time& capture_time,
                                     const SkBitmap* frame_buffer) {
   DCHECK_EQ(manager_thread_.message_loop(), MessageLoop::current());
 
   --num_renders_pending_;
   DCHECK_LE(0, num_renders_pending_);
 
-  if (state_ != kCapturing) {
+  if (state_ != kCapturing || !frame_buffer) {
     return;
   }
 
   DCHECK(!capture_time.is_null());
   DCHECK(frame_buffer);
   deliverer_.Deliver(
       frame_number, *frame_buffer, capture_time,
       base::Bind(&CaptureMachine::DeliverComplete, this, frame_buffer));
 }
 
@@ skipping 69 matching lines @@
   capturer_->SetConsumer(NULL);
   capturer_->DeAllocate();
 }
 
 const media::VideoCaptureDevice::Name&
 WebContentsVideoCaptureDevice::device_name() {
   return device_name_;
 }
 
 }  // namespace content