Fix WebrtcVideoStream to handle failed capture requests.

remoting/protocol/webrtc_video_stream.cc

 // Copyright 2015 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_video_stream.h"
 
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 121 matching lines @@
 void WebrtcVideoStream::SetObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observer_ = observer;
 }
 
 void WebrtcVideoStream::OnCaptureResult(
     webrtc::DesktopCapturer::Result result,
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // TODO(sergeyu): Handle ERROR_PERMANENT result here.
+  captured_frame_timestamps_->capture_ended_time = base::TimeTicks::Now();
+  captured_frame_timestamps_->capture_delay =
+      base::TimeDelta::FromMilliseconds(frame ? frame->capture_time_ms() : 0);
 
-  webrtc::DesktopVector dpi =
-      frame->dpi().is_zero() ? webrtc::DesktopVector(kDefaultDpi, kDefaultDpi)
-                             : frame->dpi();
-
-  if (!frame_size_.equals(frame->size()) || !frame_dpi_.equals(dpi)) {
-    frame_size_ = frame->size();
-    frame_dpi_ = dpi;
-    if (observer_)
-      observer_->OnVideoSizeChanged(this, frame_size_, frame_dpi_);
+  WebrtcVideoEncoder::FrameParams frame_params;
+  if (!scheduler_->OnFrameCaptured(frame.get(), &frame_params)) {
+    return;
   }
 
-  captured_frame_timestamps_->capture_ended_time = base::TimeTicks::Now();
-  captured_frame_timestamps_->capture_delay =
-      base::TimeDelta::FromMilliseconds(frame->capture_time_ms());
+  // TODO(sergeyu): Handle ERROR_PERMANENT result here.
+  if (frame) {
+    webrtc::DesktopVector dpi =
+        frame->dpi().is_zero() ? webrtc::DesktopVector(kDefaultDpi, kDefaultDpi)
+                               : frame->dpi();
 
-  WebrtcVideoEncoder::FrameParams frame_params;
-  if (!scheduler_->GetEncoderFrameParams(*frame, &frame_params))
-    return;
+    if (!frame_size_.equals(frame->size()) || !frame_dpi_.equals(dpi)) {
+      frame_size_ = frame->size();
+      frame_dpi_ = dpi;
+      if (observer_)
+        observer_->OnVideoSizeChanged(this, frame_size_, frame_dpi_);
+    }
+  } else {
+    // Save event timestamps to be used for the next frame.
+    next_frame_input_event_timestamps_ =
+        captured_frame_timestamps_->input_event_timestamps;
+    captured_frame_timestamps_->input_event_timestamps = InputEventTimestamps();
+  }
 
   base::PostTaskAndReplyWithResult(
       encode_task_runner_.get(), FROM_HERE,
       base::Bind(&WebrtcVideoStream::EncodeFrame, encoder_.get(),
                  base::Passed(std::move(frame)), frame_params,
                  base::Passed(std::move(captured_frame_timestamps_))),
       base::Bind(&WebrtcVideoStream::OnFrameEncoded,
                  weak_factory_.GetWeakPtr()));
 }
 
 void WebrtcVideoStream::OnChannelInitialized(
     ChannelDispatcherBase* channel_dispatcher) {
   DCHECK(&video_stats_dispatcher_ == channel_dispatcher);
 }
 void WebrtcVideoStream::OnChannelClosed(
     ChannelDispatcherBase* channel_dispatcher) {
   DCHECK(&video_stats_dispatcher_ == channel_dispatcher);
   LOG(WARNING) << "video_stats channel was closed.";
 }
 
 void WebrtcVideoStream::CaptureNextFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   captured_frame_timestamps_.reset(new FrameTimestamps());
   captured_frame_timestamps_->capture_started_time = base::TimeTicks::Now();
 
-  if (event_timestamps_source_) {
+  if (!next_frame_input_event_timestamps_.is_null()) {
+    captured_frame_timestamps_->input_event_timestamps =
+        next_frame_input_event_timestamps_;
+    next_frame_input_event_timestamps_ = InputEventTimestamps();
+  } else if (event_timestamps_source_) {
     captured_frame_timestamps_->input_event_timestamps =
         event_timestamps_source_->TakeLastEventTimestamps();
   }
 
   capturer_->CaptureFrame();
 }
 
 // static
 WebrtcVideoStream::EncodedFrameWithTimestamps WebrtcVideoStream::EncodeFrame(
     WebrtcVideoEncoder* encoder,
     std::unique_ptr<webrtc::DesktopFrame> frame,
     WebrtcVideoEncoder::FrameParams params,
     std::unique_ptr<WebrtcVideoStream::FrameTimestamps> timestamps) {
   EncodedFrameWithTimestamps result;
   result.timestamps = std::move(timestamps);
   result.timestamps->encode_started_time = base::TimeTicks::Now();
-  result.frame = encoder->Encode(*frame, params);
+  result.frame = encoder->Encode(frame.get(), params);
   result.timestamps->encode_ended_time = base::TimeTicks::Now();
   return result;
 }
 
 void WebrtcVideoStream::OnFrameEncoded(EncodedFrameWithTimestamps frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  HostFrameStats stats;
+  scheduler_->OnFrameEncoded(frame.frame.get(), &stats);
+
+  if (!frame.frame) {
+    return;
+  }
+
   webrtc::EncodedImageCallback::Result result =
       webrtc_transport_->video_encoder_factory()->SendEncodedFrame(
           *frame.frame, frame.timestamps->capture_started_time);
   if (result.error != webrtc::EncodedImageCallback::Result::OK) {
     // TODO(sergeyu): Stop the stream.
     LOG(ERROR) << "Failed to send video frame.";
     return;
   }
 
-  HostFrameStats stats;
-  scheduler_->OnFrameEncoded(*frame.frame, result, &stats);
-
   // Send FrameStats message.
   if (video_stats_dispatcher_.is_connected()) {
-    stats.frame_size = frame.frame->data.size();
+    stats.frame_size = frame.frame ? frame.frame->data.size() : 0;
 
     if (!frame.timestamps->input_event_timestamps.is_null()) {
       stats.capture_pending_delay =
           frame.timestamps->capture_started_time -
           frame.timestamps->input_event_timestamps.host_timestamp;
       stats.latest_event_timestamp =
           frame.timestamps->input_event_timestamps.client_timestamp;
     }
 
     stats.capture_delay = frame.timestamps->capture_delay;
 
     // Total overhead time for IPC and threading when capturing frames.
     stats.capture_overhead_delay = (frame.timestamps->capture_ended_time -
                                     frame.timestamps->capture_started_time) -
                                    stats.capture_delay;
 
     stats.encode_pending_delay = frame.timestamps->encode_started_time -
                                  frame.timestamps->capture_ended_time;
 
     stats.encode_delay = frame.timestamps->encode_ended_time -
                          frame.timestamps->encode_started_time;
 
     video_stats_dispatcher_.OnVideoFrameStats(result.frame_id, stats);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting