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/time/tick_clock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "remoting/base/running_average.h"
 
 namespace remoting {
 
 // CaptureScheduler is used by the VideoScheduler to scheduler frame capturer,
 // taking into account capture delay, encoder delay, network bandwidth, etc.
 class CaptureScheduler : public base::NonThreadSafe {
  public:
-  explicit CaptureScheduler(const base::Closure& capture_closure);
+  CaptureScheduler(const base::Closure& capture_closure, bool acks_supported);
   ~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 than a frame has been encoded.
   void OnFrameEncoded(base::TimeDelta encode_time);
 
   // Notifies the scheduler than a frame has been sent.
   void OnFrameSent();
 
+  // Notifies the scheduler than a frame has been acknowledged.
+  void OnFrameAck();
+
+  // Sets maximum number of pending frames in the sending queue. When ACKs are
+  // supported frames is considered to be pending until ACK message is received,

[Wez, 2015/02/03 00:54:32]

s/is/are

[Sergey Ulanov, 2015/02/09 19:14:54]

Removed this function now

+  // otherwise it's pending until it's sent (OnFrameSent() is called).

[Wez, 2015/02/03 00:54:32]

If the two things are treated equivalently, simply dependent on whether ACKs are
supported, then why not deal with the difference in the lower levels and avoid
polluting the CaptureScheduler with both concepts?

[Sergey Ulanov, 2015/02/09 19:14:54]

Removed this function now

+  void set_maximum_pending_frames(int max_pending_frames) {
+    max_pending_frames_ = max_pending_frames;
+  }
+
   // Sets minimum interval between frames.
   void set_minimum_interval(base::TimeDelta minimum_interval) {
     minimum_interval_ = minimum_interval;
   }
 
   // Helper functions for tests.
   void set_tick_clock_for_tests(scoped_ptr<base::TickClock> tick_clock) {
     tick_clock_ = tick_clock.Pass();
   }
   void set_timer_for_tests(scoped_ptr<base::Timer> timer) {
     capture_timer_ = timer.Pass();
   }
   void set_num_of_processors_for_tests(int num_of_processors) {
     num_of_processors_ = 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_;
+
+  // Maximum number of pending frames.
+  int max_pending_frames_;
+
   scoped_ptr<base::TickClock> tick_clock_;
 
   // Timer used to schedule CaptureNextFrame().
   scoped_ptr<base::Timer> capture_timer_;
 
   // Minimum interval between frames.
   base::TimeDelta minimum_interval_;
 
   int num_of_processors_;
 
   RunningAverage capture_time_;
   RunningAverage encode_time_;
 
-  int pending_frames_;
+  int num_encoding_frames_;
+  int num_sending_frames_;
+
   bool capture_pending_;
   base::TimeTicks last_capture_started_time_;
   bool is_paused_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptureScheduler);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_CAPTURE_SCHEDULER_H_