Implement video frame acknowledgements in the chromoting protocol.

remoting/host/capture_scheduler.h

Index: remoting/host/capture_scheduler.h
diff --git a/remoting/host/capture_scheduler.h b/remoting/host/capture_scheduler.h
index b3136e78d84d88f5b526b830dd095893b10de7e9..0cea9e4b51214f814145302d70f5d37bb2af3075 100644
--- a/remoting/host/capture_scheduler.h
+++ b/remoting/host/capture_scheduler.h
@@ -2,27 +2,32 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// This class chooses a capture interval so as to limit CPU usage to not exceed
-// a specified %age. It bases this on the CPU usage of recent capture and encode
-// operations, and on the number of available CPUs.
-
 #ifndef REMOTING_HOST_CAPTURE_SCHEDULER_H_
 #define REMOTING_HOST_CAPTURE_SCHEDULER_H_
 
 #include "base/callback.h"
-#include "base/threading/non_thread_safe.h"
+#include "base/threading/thread_checker.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "remoting/base/running_average.h"
+#include "remoting/protocol/video_feedback_stub.h"
 
 namespace remoting {
 
+class VideoPacket;
+
 // CaptureScheduler is used by the VideoFramePump to schedule frame capturer,
 // taking into account capture delay, encoder delay, network bandwidth, etc.
-class CaptureScheduler : public base::NonThreadSafe {
+// It implements VideoFeedbackStub to receive frame acknowledgments from the
+// client.
+//
+// It attempts to achieve the following goals when scheduling frames:
+//  - Keep round-trip latency as low a possible.
+//  - Maximize frame-rate.
+//  - Limit CPU usage.

[Wez, 2015/02/23 21:52:17]

nit: Specificy that it limits to less-than some target %age?

Maximizing the frame rate isn't quite a goal; ideally we want a fixed frame rate
that matches what the client can display, e.g. 60fps, but we also want to
balance capture vs encode overhead.

It might be clearer to say that the intention is to parallelise capture, encode
and transmission, to achieve as close to a target frame rate as possible.

[Sergey Ulanov, 2015/02/23 22:22:33]

Done.
Done (BTW currently we limit frame-rate to 30fps, not 60)

+class CaptureScheduler : public protocol::VideoFeedbackStub {
  public:
-  // |capture_closure| is called every time a new frame needs to be captured.
   explicit CaptureScheduler(const base::Closure& capture_closure);
   ~CaptureScheduler();
 
@@ -35,12 +40,16 @@ class CaptureScheduler : public base::NonThreadSafe {
   // Notifies the scheduler that a capture has been completed.
   void OnCaptureCompleted();
 
-  // Notifies the scheduler that a frame has been encoded.
-  void OnFrameEncoded(base::TimeDelta encode_time);
+  // Notifies the scheduler that a frame has been encoded. The scheduler can
+  // change |packet| if necessary, e.g. set |frame_id|.
+  void OnFrameEncoded(VideoPacket* packet);
 
   // Notifies the scheduler that a frame has been sent.
   void OnFrameSent();
 
+  // VideoFeedbackStub interface.
+  void ProcessVideoAck(scoped_ptr<VideoAck> video_ack) override;
+
   // Sets minimum interval between frames.
   void set_minimum_interval(base::TimeDelta minimum_interval) {
     minimum_interval_ = minimum_interval;
@@ -63,6 +72,9 @@ class CaptureScheduler : public base::NonThreadSafe {
 
   base::Closure capture_closure_;
 
+  // Set to true if the connection supports video frame acknowledgments.
+  bool acks_supported_;
+
   scoped_ptr<base::TickClock> tick_clock_;
 
   // Timer used to schedule CaptureNextFrame().
@@ -76,8 +88,14 @@ class CaptureScheduler : public base::NonThreadSafe {
   RunningAverage capture_time_;
   RunningAverage encode_time_;
 
-  // Total number of pending frames that are being captured, encoded or sent.
-  int pending_frames_;
+  // Number of frames pending encoding.
+  int num_encoding_frames_;
+
+  // Number of frames in the sending queue.
+  int num_sending_frames_;
+
+  // Number of outgoing frames for which we haven't received an acknowledgment.
+  int num_unacknowledged_frames_;
 
   // Set to true when capture is pending.
   bool capture_pending_;
@@ -87,6 +105,11 @@ class CaptureScheduler : public base::NonThreadSafe {
 
   bool is_paused_;
 
+  // Frame ID to be assigned to the next outgoing video frame.
+  uint32_t next_frame_id_;
+
+  base::ThreadChecker thread_checker_;
+
   DISALLOW_COPY_AND_ASSIGN(CaptureScheduler);
 };