Fix WebrtcVideoStream to handle failed capture requests.

remoting/protocol/webrtc_frame_scheduler_simple.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/protocol/webrtc_frame_scheduler_simple.h"
 
 #include <algorithm>
 
 #include "remoting/protocol/frame_stats.h"
 #include "remoting/protocol/webrtc_dummy_video_encoder.h"
@@ skipping 66 matching lines @@
     int bandwidth_kbps,
     base::TimeTicks now) {
   while (!bandwidth_samples_.empty() &&
          now - bandwidth_samples_.front().first > kBandwidthAveragingInterval) {
     bandwidth_samples_sum_ -= bandwidth_samples_.front().second;
     bandwidth_samples_.pop();
   }
 
   bandwidth_samples_.push(std::make_pair(now, bandwidth_kbps));
   bandwidth_samples_sum_ += bandwidth_kbps;
+
+  UpdateTargetBitrate();
 }
 
-int WebrtcFrameSchedulerSimple::EncoderBitrateFilter::GetTargetBitrateKbps(
-    webrtc::DesktopSize size,
-    base::TimeTicks now) {
-  DCHECK(!bandwidth_samples_.empty());
-
-  // TODO(sergeyu): This logic is applicable only to VP8. Reconsider it for
-  // VP9.
-  int bandwidth_estimate = bandwidth_samples_sum_ / bandwidth_samples_.size();
-  int minimum_bitrate =
+void WebrtcFrameSchedulerSimple::EncoderBitrateFilter::SetFrameSize(
+    webrtc::DesktopSize size) {
+  // TODO(sergeyu): This logic is applicable only to VP8. Reconsider it for VP9.
+  minimum_bitrate_ =
       static_cast<int64_t>(kVp8MinimumTargetBitrateKbpsPerMegapixel) *
       size.width() * size.height() / 1000000LL;
-  int target_bitrate = std::max(minimum_bitrate, bandwidth_estimate);
+
+  UpdateTargetBitrate();
+}
+
+int WebrtcFrameSchedulerSimple::EncoderBitrateFilter::GetTargetBitrateKbps()
+    const {
+  DCHECK_GT(current_target_bitrate_, 0);
+  return current_target_bitrate_;
+}
+
+void WebrtcFrameSchedulerSimple::EncoderBitrateFilter::UpdateTargetBitrate() {
+  if (bandwidth_samples_.empty()) {
+    return;
+  }
+
+  int bandwidth_estimate = bandwidth_samples_sum_ / bandwidth_samples_.size();
+  int target_bitrate = std::max(minimum_bitrate_, bandwidth_estimate);
 
   // Update encoder bitrate only when it changes by more than 30%. This is
   // necessary because the encoder resets internal state when it's reconfigured
   // and this causes visible drop in quality.
   if (current_target_bitrate_ == 0 ||
       std::abs(target_bitrate - current_target_bitrate_) >
           current_target_bitrate_ * kEncoderBitrateChangePercentage / 100) {
     current_target_bitrate_ = target_bitrate;
   }
-  return current_target_bitrate_;
 }
 
 WebrtcFrameSchedulerSimple::WebrtcFrameSchedulerSimple()
     : pacing_bucket_(LeakyBucket::kUnlimitedDepth, 0),
       frame_processing_delay_us_(kStatsWindow),
       updated_region_area_(kStatsWindow),
       weak_factory_(this) {}
 
 WebrtcFrameSchedulerSimple::~WebrtcFrameSchedulerSimple() {}
 
@@ skipping 31 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   paused_ = pause;
   if (paused_) {
     capture_timer_.Stop();
   } else {
     ScheduleNextFrame(base::TimeTicks::Now());
   }
 }
 
-bool WebrtcFrameSchedulerSimple::GetEncoderFrameParams(
-    const webrtc::DesktopFrame& frame,
+bool WebrtcFrameSchedulerSimple::OnFrameCaptured(
+    const webrtc::DesktopFrame* frame,
     WebrtcVideoEncoder::FrameParams* params_out) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::TimeTicks now = base::TimeTicks::Now();
 
-  if (frame.updated_region().is_empty() && !top_off_is_active_ &&
+  if ((!frame || frame->updated_region().is_empty()) && !top_off_is_active_ &&
       !key_frame_request_) {
     frame_pending_ = false;
     ScheduleNextFrame(now);
     return false;
   }
 
-  params_out->bitrate_kbps =
-      encoder_bitrate_.GetTargetBitrateKbps(frame.size(), now);
+  if (frame) {
+    encoder_bitrate_.SetFrameSize(frame->size());
+  }
 
+  params_out->bitrate_kbps = encoder_bitrate_.GetTargetBitrateKbps();
   params_out->duration = kTargetFrameInterval;
   params_out->key_frame = key_frame_request_;
   key_frame_request_ = false;
 
   params_out->vpx_min_quantizer = 10;
 
-  int64_t updated_area = params_out->key_frame
-                             ? frame.size().width() * frame.size().height()
-                             : GetRegionArea(frame.updated_region());
+  int64_t updated_area = 0;
+  if (frame) {
+    updated_area = params_out->key_frame
+                       ? frame->size().width() * frame->size().height()
+                       : GetRegionArea(frame->updated_region());
+  }
 
   // If bandwidth is being underutilized then libvpx is likely to choose the
-  // minimum allowed quantizer value, which means that encoded frame size may be
-  // significantly bigger than the bandwidth allows. Detect this case and set
+  // minimum allowed quantizer value, which means that encoded frame size may
+  // be significantly bigger than the bandwidth allows. Detect this case and set
   // vpx_min_quantizer to 60. The quality will be topped off later.
   if (updated_area - updated_region_area_.Max() > kBigFrameThresholdPixels) {
-    int expected_frame_size = updated_area *
-                              kEstimatedBytesPerMegapixel / kPixelsPerMegapixel;
+    int expected_frame_size =
+        updated_area * kEstimatedBytesPerMegapixel / kPixelsPerMegapixel;
     base::TimeDelta expected_send_delay = base::TimeDelta::FromMicroseconds(
         base::Time::kMicrosecondsPerSecond * expected_frame_size /
         pacing_bucket_.rate());
-    if (expected_send_delay > kTargetFrameInterval)
+    if (expected_send_delay > kTargetFrameInterval) {
       params_out->vpx_min_quantizer = 60;
+    }
   }
 
   updated_region_area_.Record(updated_area);
 
   params_out->vpx_max_quantizer = 63;
 
   params_out->clear_active_map = !top_off_is_active_;
 
   return true;
 }
 
 void WebrtcFrameSchedulerSimple::OnFrameEncoded(
-    const WebrtcVideoEncoder::EncodedFrame& encoded_frame,
-    const webrtc::EncodedImageCallback::Result& send_result,
+    const WebrtcVideoEncoder::EncodedFrame* encoded_frame,
     HostFrameStats* frame_stats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(frame_pending_);
   frame_pending_ = false;
 
   base::TimeTicks now = base::TimeTicks::Now();
 
   if (frame_stats) {
     // Calculate |send_pending_delay| before refilling |pacing_bucket_|.
     frame_stats->send_pending_delay =
         std::max(base::TimeDelta(), pacing_bucket_.GetEmptyTime() - now);
   }
 
-  pacing_bucket_.RefillOrSpill(encoded_frame.data.size(), now);
-
-  if (encoded_frame.data.empty()) {
+  if (!encoded_frame || encoded_frame->data.empty()) {
     top_off_is_active_ = false;
   } else {
+    pacing_bucket_.RefillOrSpill(encoded_frame->data.size(), now);
+
     frame_processing_delay_us_.Record(
         (now - last_capture_started_time_).InMicroseconds());
 
     // Top-off until the target quantizer value is reached.
-    top_off_is_active_ = encoded_frame.quantizer > kTargetQuantizerForVp8TopOff;
+    top_off_is_active_ =
+        encoded_frame->quantizer > kTargetQuantizerForVp8TopOff;
   }
 
   ScheduleNextFrame(now);
 
   if (frame_stats) {
     frame_stats->rtt_estimate = rtt_estimate_;
     frame_stats->bandwidth_estimate_kbps = pacing_bucket_.rate() * 8 / 1000;
   }
 }
 
@@ skipping 11 matching lines @@
       base::TimeDelta::FromMicroseconds(frame_processing_delay_us_.Max());
   base::TimeTicks target_capture_time =
       pacing_bucket_.GetEmptyTime() - expected_processing_time;
 
   // Cap interval between frames to kTargetFrameInterval.
   if (!last_capture_started_time_.is_null()) {
     target_capture_time = std::max(
         target_capture_time, last_capture_started_time_ + kTargetFrameInterval);
   }
 
-  if (target_capture_time < now)
+  if (target_capture_time < now) {
     target_capture_time = now;
+  }
 
   capture_timer_.Start(FROM_HERE, target_capture_time - now,
                        base::Bind(&WebrtcFrameSchedulerSimple::CaptureNextFrame,
                                   base::Unretained(this)));
 }
 
 void WebrtcFrameSchedulerSimple::CaptureNextFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!frame_pending_);
   last_capture_started_time_ = base::TimeTicks::Now();
   frame_pending_ = true;
   capture_callback_.Run();
 }
 
 }  // namespace protocol
 }  // namespace remoting