Fix WebrtcVideoStream to handle failed capture requests.

remoting/codec/webrtc_video_encoder_vpx.cc

 // Copyright 2016 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 "remoting/codec/webrtc_video_encoder_vpx.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 256 matching lines @@
     // TODO(wez): Switch to ConfigureCodec() path once libvpx supports it.
     // See https://code.google.com/p/webm/issues/detail?id=913.
     // if (codec_)
     //  Configure(webrtc::DesktopSize(codec_->config.enc->g_w,
     //                                codec_->config.enc->g_h));
     codec_.reset();
   }
 }
 
 std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> WebrtcVideoEncoderVpx::Encode(
-    const webrtc::DesktopFrame& frame,
+    const webrtc::DesktopFrame* frame,
     const FrameParams& params) {
-  DCHECK_LE(32, frame.size().width());
-  DCHECK_LE(32, frame.size().height());
+  webrtc::DesktopSize previous_frame_size =
+      image_ ? webrtc::DesktopSize(image_->w, image_->h)
+             : webrtc::DesktopSize();
+
+  webrtc::DesktopSize frame_size = frame ? frame->size() : previous_frame_size;
+
+  // Don't need to send anything until we get the first non-null frame.
+  if (frame_size.is_empty()) {
+    return nullptr;
+  }
+
+  DCHECK_GE(frame_size.width(), 32);
+  DCHECK_GE(frame_size.height(), 32);
 
   // Create or reconfigure the codec to match the size of |frame|.
-  if (!codec_ ||
-      (image_ &&
-       !frame.size().equals(webrtc::DesktopSize(image_->w, image_->h)))) {
-    Configure(frame.size());
+  if (!codec_ || !frame_size.equals(previous_frame_size)) {
+    Configure(frame_size);
   }
 
   UpdateConfig(params);
 
   vpx_active_map_t act_map;
   act_map.rows = active_map_size_.height();
   act_map.cols = active_map_size_.width();
   act_map.active_map = active_map_.get();
 
   webrtc::DesktopRegion updated_region;
   // Convert the updated capture data ready for encode.
   PrepareImage(frame, &updated_region);
 
   // Update active map based on updated region.
   if (params.clear_active_map)
     ClearActiveMap();
 
   if (params.key_frame)
-    updated_region.SetRect(webrtc::DesktopRect::MakeSize(frame.size()));
+    updated_region.SetRect(webrtc::DesktopRect::MakeSize(frame_size));
 
   SetActiveMapFromRegion(updated_region);
 
   // Apply active map to the encoder.
   if (vpx_codec_control(codec_.get(), VP8E_SET_ACTIVEMAP, &act_map)) {
     LOG(ERROR) << "Unable to apply active map";
   }
 
   vpx_codec_err_t ret = vpx_codec_encode(
       codec_.get(), image_.get(), 0, params.duration.InMicroseconds(),
@@ skipping 14 matching lines @@
     }
 
     UpdateRegionFromActiveMap(&updated_region);
   }
 
   // Read the encoded data.
   vpx_codec_iter_t iter = nullptr;
   bool got_data = false;
 
   std::unique_ptr<EncodedFrame> encoded_frame(new EncodedFrame());
-  encoded_frame->size = frame.size();
+  encoded_frame->size = frame_size;
 
   while (!got_data) {
     const vpx_codec_cx_pkt_t* vpx_packet =
         vpx_codec_get_cx_data(codec_.get(), &iter);
     if (!vpx_packet)
       continue;
 
     switch (vpx_packet->kind) {
       case VPX_CODEC_CX_FRAME_PKT: {
         got_data = true;
@@ skipping 114 matching lines @@
   if (!changed)
     return;
 
   // Update encoder context.
   if (vpx_codec_enc_config_set(codec_.get(), &config_))
     NOTREACHED() << "Unable to set encoder config";
 
 }
 
 void WebrtcVideoEncoderVpx::PrepareImage(
-    const webrtc::DesktopFrame& frame,
+    const webrtc::DesktopFrame* frame,
     webrtc::DesktopRegion* updated_region) {
-  if (frame.updated_region().is_empty()) {
+  if (!frame || frame->updated_region().is_empty()) {
     updated_region->Clear();
     return;
   }
 
   updated_region->Clear();
   if (image_) {
     // Pad each rectangle to avoid the block-artifact filters in libvpx from
     // introducing artifacts; VP9 includes up to 8px either side, and VP8 up to
     // 3px, so unchanged pixels up to that far out may still be affected by the
     // changes in the updated region, and so must be listed in the active map.
     // After padding we align each rectangle to 16x16 active-map macroblocks.
     // This implicitly ensures all rects have even top-left coords, which is
     // is required by ConvertRGBToYUVWithRect().
     // TODO(wez): Do we still need 16x16 align, or is even alignment sufficient?
     int padding = use_vp9_ ? 8 : 3;
-    for (webrtc::DesktopRegion::Iterator r(frame.updated_region());
+    for (webrtc::DesktopRegion::Iterator r(frame->updated_region());
          !r.IsAtEnd(); r.Advance()) {
       const webrtc::DesktopRect& rect = r.rect();
       updated_region->AddRect(AlignRect(webrtc::DesktopRect::MakeLTRB(
           rect.left() - padding, rect.top() - padding, rect.right() + padding,
           rect.bottom() + padding)));
     }
     DCHECK(!updated_region->is_empty());
 
     // Clip back to the screen dimensions, in case they're not macroblock
     // aligned. The conversion routines don't require even width & height,
     // so this is safe even if the source dimensions are not even.
     updated_region->IntersectWith(
         webrtc::DesktopRect::MakeWH(image_->w, image_->h));
   } else {
-    CreateImage(lossless_color_, frame.size(), &image_, &image_buffer_);
+    CreateImage(lossless_color_, frame->size(), &image_, &image_buffer_);
     updated_region->AddRect(webrtc::DesktopRect::MakeWH(image_->w, image_->h));
   }
 
   // Convert the updated region to YUV ready for encoding.
-  const uint8_t* rgb_data = frame.data();
-  const int rgb_stride = frame.stride();
+  const uint8_t* rgb_data = frame->data();
+  const int rgb_stride = frame->stride();
   const int y_stride = image_->stride[0];
   DCHECK_EQ(image_->stride[1], image_->stride[2]);
   const int uv_stride = image_->stride[1];
   uint8_t* y_data = image_->planes[0];
   uint8_t* u_data = image_->planes[1];
   uint8_t* v_data = image_->planes[2];
 
   switch (image_->fmt) {
     case VPX_IMG_FMT_I444:
       for (webrtc::DesktopRegion::Iterator r(*updated_region); !r.IsAtEnd();
@@ skipping 73 matching lines @@
             kMacroBlockSize * (y + 1)));
       }
       x0 = x1 + 1;
     }
   }
   updated_region->IntersectWith(
       webrtc::DesktopRect::MakeWH(image_->w, image_->h));
 }
 
 }  // namespace remoting