Fix WebrtcVideoStream to handle failed capture requests.

remoting/protocol/connection_unittest.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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 58 matching lines @@
 
 class TestScreenCapturer : public webrtc::DesktopCapturer {
  public:
   TestScreenCapturer() {}
   ~TestScreenCapturer() override {}
 
   // webrtc::DesktopCapturer interface.
   void Start(Callback* callback) override {
     callback_ = callback;
   }
+
   void CaptureFrame() override {
+    if (capture_request_index_to_fail_ >= 0) {
+      capture_request_index_to_fail_--;
+      if (capture_request_index_to_fail_ < 0) {
+        callback_->OnCaptureResult(
+            webrtc::DesktopCapturer::Result::ERROR_TEMPORARY, nullptr);
+        return;
+      }
+    }
+
     // Return black 100x100 frame.
     std::unique_ptr<webrtc::DesktopFrame> frame(
         new webrtc::BasicDesktopFrame(webrtc::DesktopSize(100, 100)));
-    memset(frame->data(), 0, frame->stride() * frame->size().height());
-
-    // Set updated_region only for the first frame, as the frame content
-    // doesn't change.
-    if (!first_frame_sent_) {
-      first_frame_sent_ = true;
-      frame->mutable_updated_region()->SetRect(
-          webrtc::DesktopRect::MakeSize(frame->size()));
-    }
+    memset(frame->data(), frame_index_,
+           frame->stride() * frame->size().height());
+    frame_index_++;
+    frame->mutable_updated_region()->SetRect(
+        webrtc::DesktopRect::MakeSize(frame->size()));
 
     callback_->OnCaptureResult(webrtc::DesktopCapturer::Result::SUCCESS,
                                std::move(frame));
   }
 
   bool GetSourceList(SourceList* sources) override {
     return true;
   }
 
   bool SelectSource(SourceId id) override {
     return true;
   }
 
+  void FailNthFrame(int n) { capture_request_index_to_fail_ = n; }
+
  private:
   Callback* callback_ = nullptr;
-  bool first_frame_sent_ = false;
+  int frame_index_ = 0;
+
+  int capture_request_index_to_fail_ = -1;
 };
 
 static const int kAudioSampleRate = AudioPacket::SAMPLING_RATE_48000;
 static const int kAudioPacketDurationMs = 50;
 static constexpr int kSamplesPerAudioPacket =
     kAudioSampleRate * kAudioPacketDurationMs /
     base::Time::kMillisecondsPerSecond;
 static constexpr base::TimeDelta kAudioPacketDuration =
     base::TimeDelta::FromMilliseconds(kAudioPacketDurationMs);
 
@@ skipping 221 matching lines @@
     if (client_connected_ && run_loop_)
       run_loop_->Quit();
   }
 
   void OnClientConnected() {
     client_connected_ = true;
     if (host_connected_ && run_loop_)
       run_loop_->Quit();
   }
 
-  void WaitFirstVideoFrame() {
+  void WaitNextVideoFrame() {
+    size_t received_frames =
+        is_using_webrtc()
+            ? client_video_renderer_.GetFrameConsumer()
+                  ->received_frames()
+                  .size()
+            : client_video_renderer_.GetVideoStub()->received_packets().size();
+
     base::RunLoop run_loop;
 
     // Expect frames to be passed to FrameConsumer when WebRTC is used, or to
     // VideoStub otherwise.
     if (is_using_webrtc()) {
       client_video_renderer_.GetFrameConsumer()->set_on_frame_callback(
           base::Bind(&base::RunLoop::Quit, base::Unretained(&run_loop)));
     } else {
       client_video_renderer_.GetVideoStub()->set_on_frame_callback(
           base::Bind(&base::RunLoop::Quit, base::Unretained(&run_loop)));
     }
 
     run_loop.Run();
 
     if (is_using_webrtc()) {
       EXPECT_EQ(
           client_video_renderer_.GetFrameConsumer()->received_frames().size(),
-          1U);
+          received_frames + 1);
       EXPECT_EQ(
           client_video_renderer_.GetVideoStub()->received_packets().size(), 0U);
       client_video_renderer_.GetFrameConsumer()->set_on_frame_callback(
           base::Closure());
     } else {
       EXPECT_EQ(
           client_video_renderer_.GetFrameConsumer()->received_frames().size(),
           0U);
       EXPECT_EQ(
-          client_video_renderer_.GetVideoStub()->received_packets().size(), 1U);
+          client_video_renderer_.GetVideoStub()->received_packets().size(),
+          received_frames + 1);
       client_video_renderer_.GetVideoStub()->set_on_frame_callback(
           base::Closure());
     }
   }
 
   void WaitFirstFrameStats() {
     if (!client_video_renderer_.GetFrameStatsConsumer()
              ->received_stats()
              .empty()) {
       return;
@@ skipping 99 matching lines @@
   run_loop.Run();
 }
 
 TEST_P(ConnectionTest, Video) {
   Connect();
 
   std::unique_ptr<VideoStream> video_stream =
       host_connection_->StartVideoStream(
           base::MakeUnique<TestScreenCapturer>());
 
-  WaitFirstVideoFrame();
+  WaitNextVideoFrame();
 }
 
 // Verifies that the VideoStream doesn't loose any video frames while the
 // connection is being established.
 TEST_P(ConnectionTest, VideoWithSlowSignaling) {
   // Add signaling delay to slow down connection handshake.
   host_session_->set_signaling_delay(base::TimeDelta::FromMilliseconds(100));
   client_session_->set_signaling_delay(base::TimeDelta::FromMilliseconds(100));
 
   Connect();
 
   std::unique_ptr<VideoStream> video_stream =
       host_connection_->StartVideoStream(
           base::WrapUnique(new TestScreenCapturer()));
 
-  WaitFirstVideoFrame();
+  WaitNextVideoFrame();
 }
 
 TEST_P(ConnectionTest, DestroyOnIncomingMessage) {
   Connect();
 
   KeyEvent event;
   event.set_usb_keycode(3);
   event.set_pressed(true);
 
   base::RunLoop run_loop;
@@ skipping 23 matching lines @@
   scoped_refptr<InputEventTimestampsSourceImpl> input_event_timestamps_source =
       new InputEventTimestampsSourceImpl();
   input_event_timestamps_source->OnEventReceived(
       InputEventTimestamps{event_timestamp, start_time});
 
   std::unique_ptr<VideoStream> video_stream =
       host_connection_->StartVideoStream(
           base::MakeUnique<TestScreenCapturer>());
   video_stream->SetEventTimestampsSource(input_event_timestamps_source);
 
-  WaitFirstVideoFrame();
+  WaitNextVideoFrame();
 
   base::TimeTicks finish_time = base::TimeTicks::Now();
 
   WaitFirstFrameStats();
 
   const FrameStats& stats =
       client_video_renderer_.GetFrameStatsConsumer()->received_stats().front();
 
   EXPECT_GT(stats.host_stats.frame_size, 0);
 
@@ skipping 22 matching lines @@
   Connect();
 
   std::unique_ptr<AudioStream> audio_stream =
       host_connection_->StartAudioStream(base::MakeUnique<TestAudioSource>());
 
   // Wait for 1 second worth of audio samples.
   client_audio_player_.WaitForSamples(kAudioSampleRate * 2);
   client_audio_player_.Verify();
 }
 
+TEST_P(ConnectionTest, FirstCaptureFailed) {
+  Connect();
+
+  base::TimeTicks event_timestamp = base::TimeTicks::FromInternalValue(42);
+
+  scoped_refptr<InputEventTimestampsSourceImpl> input_event_timestamps_source =
+      new InputEventTimestampsSourceImpl();
+  input_event_timestamps_source->OnEventReceived(
+      InputEventTimestamps{event_timestamp, base::TimeTicks::Now()});
+
+  auto capturer = base::MakeUnique<TestScreenCapturer>();
+  capturer->FailNthFrame(0);
+  auto video_stream = host_connection_->StartVideoStream(std::move(capturer));
+  video_stream->SetEventTimestampsSource(input_event_timestamps_source);
+
+  WaitNextVideoFrame();
+
+  // Currently stats work in this test only for WebRTC because for ICE
+  // connections stats are reported by SoftwareVideoRenderer which is not used
+  // in this test.
+  // TODO(sergeyu): Fix this.
+  if (is_using_webrtc())  {
+    WaitFirstFrameStats();
+
+    // Verify that the event timestamp received before the first frame gets used
+    // for the second frame.
+    const FrameStats& stats = client_video_renderer_.GetFrameStatsConsumer()
+                                  ->received_stats()
+                                  .front();
+    EXPECT_EQ(event_timestamp, stats.host_stats.latest_event_timestamp);
+  }
+}
+
+TEST_P(ConnectionTest, SecondCaptureFailed) {
+  Connect();
+
+  auto capturer = base::MakeUnique<TestScreenCapturer>();
+  capturer->FailNthFrame(1);
+  auto video_stream = host_connection_->StartVideoStream(std::move(capturer));
+
+  WaitNextVideoFrame();
+  WaitNextVideoFrame();
+}
+
 }  // namespace protocol
 }  // namespace remoting