Implement video frame acknowledgements in the chromoting protocol.

remoting/host/capture_scheduler.h

 // Copyright (c) 2011 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.
 
-// 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();
 
   // Starts the scheduler.
   void Start();
 
   // Pauses or unpauses the stream.
   void Pause(bool pause);
 
   // 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;
   }
 
   // Helper functions for tests.
   void SetTickClockForTest(scoped_ptr<base::TickClock> tick_clock);
   void SetTimerForTest(scoped_ptr<base::Timer> timer);
   void SetNumOfProcessorsForTest(int num_of_processors);
 
  private:
   // Schedules |capture_timer_| to call CaptureNextFrame() at appropriate time.
   // Doesn't do anything if next frame cannot be captured yet (e.g. because
   // there are too many frames being processed).
   void ScheduleNextCapture();
 
   // Called by |capture_timer_|. Calls |capture_closure_| to start capturing a
   // new frame.
   void CaptureNextFrame();
 
   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().
   scoped_ptr<base::Timer> capture_timer_;
 
   // Minimum interval between frames that determines maximum possible framerate.
   base::TimeDelta minimum_interval_;
 
   int num_of_processors_;
 
   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_;
 
   // Time at which the last capture started. Used to schedule |capture_timer_|.
   base::TimeTicks last_capture_started_time_;
 
   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);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_CAPTURE_SCHEDULER_H_