Implement video frame acknowledgements in the chromoting protocol.

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 62 matching lines @@
 }
 
 void VideoScheduler::Start() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   keep_alive_timer_.reset(new base::DelayTimer<VideoScheduler>(
       FROM_HERE, base::TimeDelta::FromMilliseconds(kKeepAlivePacketIntervalMs),
       this, &VideoScheduler::SendKeepAlivePacket));
 
   capture_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this));
+      FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this,
+                            video_stub_->SupportsAcks()));
 }
 
 void VideoScheduler::Stop() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // Clear stubs to prevent further updates reaching the client.
   cursor_stub_ = nullptr;
   video_stub_ = nullptr;
 
   keep_alive_timer_.reset();
@@ skipping 102 matching lines @@
                             base::Passed(&cursor_proto)));
 }
 
 void VideoScheduler::OnMouseCursorPosition(
     webrtc::MouseCursorMonitor::CursorState state,
     const webrtc::DesktopVector& position) {
   // We're not subscribing to mouse position changes.
   NOTREACHED();
 }
 
-void VideoScheduler::StartOnCaptureThread() {
+void VideoScheduler::StartOnCaptureThread(bool acks_supported) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DCHECK(!capture_scheduler_);
 
   mouse_cursor_monitor_->Init(this, webrtc::MouseCursorMonitor::SHAPE_ONLY);
   capturer_->Start(this);
 
   capture_scheduler_.reset(new CaptureScheduler(
-      base::Bind(&VideoScheduler::CaptureNextFrame, this)));
+      base::Bind(&VideoScheduler::CaptureNextFrame, this), acks_supported));
   capture_scheduler_->Start();
 }
 
 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.
   capturer_.reset();
 
@@ skipping 17 matching lines @@
     capture_scheduler_->OnFrameEncoded(encode_time);
 }
 
 void VideoScheduler::ProcessFrameSentOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   if (capture_scheduler_)
     capture_scheduler_->OnFrameSent();
 }
 
+void VideoScheduler::ProcessFrameAckOnCaptureThread() {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+
+  if (capture_scheduler_)
+    capture_scheduler_->OnFrameAck();
+}
+
 // 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::OnVideoPacketSent, this));
+      packet.Pass(), base::Bind(&VideoScheduler::OnVideoPacketProgress, this));
 }
 
-void VideoScheduler::OnVideoPacketSent() {
+void VideoScheduler::OnVideoPacketProgress(
+    protocol::VideoStub::PacketProgress progress) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!video_stub_)
     return;
 
-  keep_alive_timer_->Reset();
+  switch (progress) {
+    case protocol::VideoStub::PacketProgress::SENT:
+      keep_alive_timer_->Reset();
+      capture_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&VideoScheduler::ProcessFrameSentOnCaptureThread, this));
+      break;
 
-  capture_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoScheduler::ProcessFrameSentOnCaptureThread, this));
+    case protocol::VideoStub::PacketProgress::DONE:
+      if (video_stub_->SupportsAcks()) {
+        capture_task_runner_->PostTask(
+            FROM_HERE,
+            base::Bind(&VideoScheduler::ProcessFrameAckOnCaptureThread, this));
+      }
+      break;
+  }
 }
 
 void VideoScheduler::SendKeepAlivePacket() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!video_stub_)
     return;
 
   video_stub_->ProcessVideoPacket(
       make_scoped_ptr(new VideoPacket()),
-      base::Bind(&VideoScheduler::OnKeepAlivePacketSent, this));
+      base::Bind(&VideoScheduler::OnKeepAlivePacketProgress, this));
 }
 
-void VideoScheduler::OnKeepAlivePacketSent() {
+void VideoScheduler::OnKeepAlivePacketProgress(
+    protocol::VideoStub::PacketProgress progress) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
-  if (keep_alive_timer_)
+  if (progress == protocol::VideoStub::PacketProgress::SENT &&
+      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);
@@ skipping 30 matching lines @@
   capture_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoScheduler::ProcessFrameEncodedOnCaptureThread, this,
                  base::TimeDelta::FromMilliseconds(packet->encode_time_ms())));
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 }  // namespace remoting