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..42a1657879506e8176bc9bdfc6e0f644c98afe30 100644
--- a/remoting/host/capture_scheduler.h
+++ b/remoting/host/capture_scheduler.h
@@ -2,29 +2,35 @@
 // 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.
+//  - Parallelize capture, encode and transmission, to achieve frame rate as
+//    close to the target of 30fps as possible.
+//  - Limit CPU usage to 50%.
+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();
+  ~CaptureScheduler() override;
 
   // Starts the scheduler.
   void Start();
@@ -35,12 +41,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 +73,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 +89,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 +106,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);
 };