More reliable keep-alive video packets.

remoting/host/video_scheduler.cc

 // Copyright (c) 2012 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/host/video_scheduler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 12 matching lines @@
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_shape.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
 
 namespace remoting {
 
 // Maximum number of frames that can be processed simultaneously.
 // TODO(hclam): Move this value to CaptureScheduler.
 static const int kMaxPendingFrames = 2;
 
+// Interval between empty keep-alive frames. These frames are sent only
+// when there are no real video frames being sent.
+static const int kKeepAlivePacketIntervalMs = 500;
+
 VideoScheduler::VideoScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_ptr<webrtc::ScreenCapturer> capturer,
     scoped_ptr<VideoEncoder> encoder,
     protocol::CursorShapeStub* cursor_stub,
     protocol::VideoStub* video_stub)
     : capture_task_runner_(capture_task_runner),
       encode_task_runner_(encode_task_runner),
@@ skipping 18 matching lines @@
 
 webrtc::SharedMemory* VideoScheduler::CreateSharedMemory(size_t size) {
   return NULL;
 }
 
 void VideoScheduler::OnCaptureCompleted(webrtc::DesktopFrame* frame) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   capture_pending_ = false;
 
+  if (!frame) {
+    LOG(ERROR) << "Capture failed.";
+    return;
+  }
+
   scoped_ptr<webrtc::DesktopFrame> owned_frame(frame);
 
-  if (frame) {
-    scheduler_.RecordCaptureTime(
-        base::TimeDelta::FromMilliseconds(frame->capture_time_ms()));
+  scheduler_.RecordCaptureTime(
+      base::TimeDelta::FromMilliseconds(frame->capture_time_ms()));
+
+  // Encode and send only non-empty frames.
+  if (!frame->updated_region().is_empty()) {
+    encode_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this,
+                              base::Passed(&owned_frame), sequence_number_));
   }
 
-  encode_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this,
-                            base::Passed(&owned_frame), sequence_number_));
-
   // If a frame was skipped, try to capture it again.
   if (did_skip_frame_) {
     capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::CaptureNextFrame, this));
   }
 }
 
 void VideoScheduler::OnCursorShapeChanged(
     webrtc::MouseCursorShape* cursor_shape) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
@@ skipping 24 matching lines @@
       FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this));
 }
 
 void VideoScheduler::Stop() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // Clear stubs to prevent further updates reaching the client.
   cursor_stub_ = NULL;
   video_stub_ = NULL;
 
-  capture_task_runner_->PostTask(FROM_HERE,
-      base::Bind(&VideoScheduler::StopOnCaptureThread, this));
+  keep_alive_timer_.reset();
+
+  capture_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoScheduler::StopOnCaptureThread, this));
 }
 
 void VideoScheduler::Pause(bool pause) {
   if (!capture_task_runner_->BelongsToCurrentThread()) {
     DCHECK(network_task_runner_->BelongsToCurrentThread());
     capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::Pause, this, pause));
     return;
   }
 
@@ skipping 27 matching lines @@
 
 void VideoScheduler::StartOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DCHECK(!capture_timer_);
 
   // Start the capturer and let it notify us if cursor shape changes.
   capturer_->SetMouseShapeObserver(this);
   capturer_->Start(this);
 
   capture_timer_.reset(new base::OneShotTimer<VideoScheduler>());
+  keep_alive_timer_.reset(new base::DelayTimer<VideoScheduler>(
+      FROM_HERE, base::TimeDelta::FromMilliseconds(kKeepAlivePacketIntervalMs),
+      this, &VideoScheduler::SendKeepAlivePacket));
 
   // Capture first frame immedately.
   CaptureNextFrame();
 }
 
 void VideoScheduler::StopOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   // This doesn't deleted already captured frames, so encoder can keep using the
   // frames that were captured previously.
@@ skipping 57 matching lines @@
 
 // Network thread --------------------------------------------------------------
 
 void VideoScheduler::SendVideoPacket(scoped_ptr<VideoPacket> packet) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!video_stub_)
     return;
 
   video_stub_->ProcessVideoPacket(
-      packet.Pass(), base::Bind(&VideoScheduler::VideoFrameSentCallback, this));
+      packet.Pass(), base::Bind(&VideoScheduler::OnVideoPacketSent, this));
 }
 
-void VideoScheduler::VideoFrameSentCallback() {
+void VideoScheduler::OnVideoPacketSent() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!video_stub_)
     return;
 
+  keep_alive_timer_->Reset();
+
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::FrameCaptureCompleted, this));
 }
 
+void VideoScheduler::SendKeepAlivePacket() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  if (!video_stub_)
+    return;
+
+  video_stub_->ProcessVideoPacket(
+      scoped_ptr<VideoPacket>(new VideoPacket()),
+      base::Bind(&VideoScheduler::OnKeepAlivePacketSent, this));
+}
+
+void VideoScheduler::OnKeepAlivePacketSent() {
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
+
+  if (keep_alive_timer_)
+    keep_alive_timer_->Reset();
+}
+
 void VideoScheduler::SendCursorShape(
     scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!cursor_stub_)
     return;
 
   cursor_stub_->SetCursorShape(*cursor_shape);
 }
 
 // Encoder thread --------------------------------------------------------------
 
 void VideoScheduler::EncodeFrame(
     scoped_ptr<webrtc::DesktopFrame> frame,
     int64 sequence_number) {
   DCHECK(encode_task_runner_->BelongsToCurrentThread());
-
-  // If there is nothing to encode then send an empty keep-alive packet.
-  if (!frame || frame->updated_region().is_empty()) {
-    scoped_ptr<VideoPacket> packet(new VideoPacket());
-    packet->set_client_sequence_number(sequence_number);
-    network_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
-                              base::Passed(&packet)));
-    capture_task_runner_->DeleteSoon(FROM_HERE, frame.release());
-    return;
-  }
+  DCHECK(!frame->updated_region().is_empty());
 
   scoped_ptr<VideoPacket> packet = encoder_->Encode(*frame);
   packet->set_client_sequence_number(sequence_number);
 
   // Destroy the frame before sending |packet| because SendVideoPacket() may
   // trigger another frame to be captured, and the screen capturer expects the
   // old frame to be freed by then.
   frame.reset();
 
   scheduler_.RecordEncodeTime(
       base::TimeDelta::FromMilliseconds(packet->encode_time_ms()));
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 }  // namespace remoting