Implement video frame acknowledgements in the chromoting protocol.

remoting/host/video_scheduler.h

 // 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.
 
 #ifndef REMOTING_HOST_VIDEO_SCHEDULER_H_
 #define REMOTING_HOST_VIDEO_SCHEDULER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/proto/video.pb.h"
+#include "remoting/protocol/video_stub.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_monitor.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace media {
 class DesktopCapturer;
 }  // namespace media
 
 namespace remoting {
 
 class CaptureScheduler;
 class CursorShapeInfo;
 
 namespace protocol {
 class CursorShapeInfo;
 class CursorShapeStub;
-class VideoStub;
 }  // namespace protocol
 
 // Class responsible for scheduling frame captures from a
 // webrtc::DesktopCapturer, delivering them to a VideoEncoder to encode, and
 // finally passing the encoded video packets to the specified VideoStub to send
 // on the network.
 //
 // THREADING
 //
 // This class is supplied TaskRunners to use for capture, encode and network
@@ skipping 76 matching lines @@
   // webrtc::DesktopCapturer::Callback implementation.
   webrtc::SharedMemory* CreateSharedMemory(size_t size) override;
   void OnCaptureCompleted(webrtc::DesktopFrame* frame) override;
 
   // webrtc::MouseCursorMonitor::Callback implementation.
   void OnMouseCursor(webrtc::MouseCursor* mouse_cursor) override;
   void OnMouseCursorPosition(webrtc::MouseCursorMonitor::CursorState state,
                              const webrtc::DesktopVector& position) override;
 
   // Starts the capturer on the capture thread.
-  void StartOnCaptureThread();
+  void StartOnCaptureThread(bool acks_supported);
 
   // Stops scheduling frame captures on the capture thread.
   void StopOnCaptureThread();
 
   // Starts the next frame capture, unless there are already too many pending.
   void CaptureNextFrame();
 
   // Called when a frame has been encoded.
   void ProcessFrameEncodedOnCaptureThread(base::TimeDelta encode_time);
 
   // Called when a frame has been sent to the client.
   void ProcessFrameSentOnCaptureThread();
 
+  // Called when a frame has been sent to the client.
+  void ProcessFrameAckOnCaptureThread();
+
   // Network thread -----------------------------------------------------------
 
   // Send |packet| to the client, unless we are in the process of stopping.
   void SendVideoPacket(scoped_ptr<VideoPacket> packet);
 
-  // Callback passed to |video_stub_| for the last packet in each frame, to
+  // Callback passed to |video_stub_|, to
   // rate-limit frame captures to network throughput.
-  void OnVideoPacketSent();
+  void OnVideoPacketProgress(protocol::VideoStub::PacketProgress progress);
 
   // Called by |keep_alive_timer_|.
   void SendKeepAlivePacket();
 
   // Callback for |video_stub_| called after a keep-alive packet is sent.
-  void OnKeepAlivePacketSent();
+  void OnKeepAlivePacketProgress(protocol::VideoStub::PacketProgress progress);
 
   // Send updated cursor shape to client.
   void SendCursorShape(scoped_ptr<protocol::CursorShapeInfo> cursor_shape);
 
   // Encoder thread -----------------------------------------------------------
 
   // Encode a frame, passing generated VideoPackets to SendVideoPacket().
   void EncodeFrame(scoped_ptr<webrtc::DesktopFrame> frame,
                    int64 latest_event_timestamp,
                    base::TimeTicks timestamp);
@@ skipping 28 matching lines @@
   int64 latest_event_timestamp_;
 
   scoped_ptr<CaptureScheduler> capture_scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoScheduler);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_VIDEO_SCHEDULER_H_