Fix WebRtcFrameScheduler to wait for first key frame request.

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.
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 53 matching lines @@
 class TestScreenCapturer : public webrtc::DesktopCapturer {
  public:
   TestScreenCapturer() {}
   ~TestScreenCapturer() override {}
 
   // webrtc::DesktopCapturer interface.
   void Start(Callback* callback) override {
     callback_ = callback;
   }
   void Capture(const webrtc::DesktopRegion& region) override {
-    // Return black 10x10 frame.
+    // 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());
-    frame->mutable_updated_region()->SetRect(
-        webrtc::DesktopRect::MakeSize(frame->size()));
+
+    // 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()));
+    }
+
     callback_->OnCaptureCompleted(frame.release());
   }
 
  private:
   Callback* callback_ = nullptr;
+  bool first_frame_sent_ = false;
 };
 
 }  // namespace
 
 class ConnectionTest : public testing::Test,
                        public testing::WithParamInterface<bool> {
  public:
   ConnectionTest() {}
 
  protected:
@@ skipping 86 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() {
+    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);
+      EXPECT_EQ(
+          client_video_renderer_.GetVideoStub()->received_packets().size(), 0U);
+    } else {
+      EXPECT_EQ(
+          client_video_renderer_.GetFrameConsumer()->received_frames().size(),
+          0U);
+      EXPECT_EQ(
+          client_video_renderer_.GetVideoStub()->received_packets().size(), 1U);
+    }
+  }
+
   base::MessageLoopForIO message_loop_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   MockConnectionToClientEventHandler host_event_handler_;
   MockClipboardStub host_clipboard_stub_;
   MockHostStub host_stub_;
   MockInputStub host_input_stub_;
   std::unique_ptr<ConnectionToClient> host_connection_;
   FakeSession* host_session_;  // Owned by |host_connection_|.
   bool host_connected_ = false;
@@ skipping 77 matching lines @@
   run_loop.Run();
 }
 
 TEST_P(ConnectionTest, Video) {
   Connect();
 
   std::unique_ptr<VideoStream> video_stream =
       host_connection_->StartVideoStream(
           base::WrapUnique(new TestScreenCapturer()));
 
-  base::RunLoop run_loop;
+  WaitFirstVideoFrame();
+}
 
-  // 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)));
-  }
+// 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));
 
-  run_loop.Run();
+  Connect();
 
-  if (is_using_webrtc()) {
-    EXPECT_EQ(
-        client_video_renderer_.GetFrameConsumer()->received_frames().size(),
-        1U);
-    EXPECT_EQ(client_video_renderer_.GetVideoStub()->received_packets().size(),
-              0U);
-  } else {
-    EXPECT_EQ(
-        client_video_renderer_.GetFrameConsumer()->received_frames().size(),
-        0U);
-    EXPECT_EQ(client_video_renderer_.GetVideoStub()->received_packets().size(),
-              1U);
-  }
+  std::unique_ptr<VideoStream> video_stream =
+      host_connection_->StartVideoStream(
+          base::WrapUnique(new TestScreenCapturer()));
 
+  WaitFirstVideoFrame();
 }
 
 }  // namespace protocol
 }  // namespace remoting