Add InputEventTimestampSource interface.

remoting/protocol/video_frame_pump.h

 // Copyright 2015 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_PROTOCOL_VIDEO_FRAME_PUMP_H_
 #define REMOTING_PROTOCOL_VIDEO_FRAME_PUMP_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 62 matching lines @@
   // Creates a VideoFramePump running capture, encode and network tasks on the
   // supplied TaskRunners. Video will be pumped to |video_stub|, which must
   // outlive the pump..
   VideoFramePump(scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
                  std::unique_ptr<webrtc::DesktopCapturer> capturer,
                  std::unique_ptr<VideoEncoder> encoder,
                  protocol::VideoStub* video_stub);
   ~VideoFramePump() override;
 
   // VideoStream interface.
+  void SetEventTimestampsSource(scoped_refptr<InputEventTimestampsSource>
+                                    event_timestamps_source) override;
   void Pause(bool pause) override;
-  void OnInputEventReceived(int64_t event_timestamp) override;
   void SetLosslessEncode(bool want_lossless) override;
   void SetLosslessColor(bool want_lossless) override;
   void SetObserver(Observer* observer) override;
 
   protocol::VideoFeedbackStub* video_feedback_stub() {
     return &capture_scheduler_;
   }
 
  private:
   struct FrameTimestamps {
     FrameTimestamps();
     ~FrameTimestamps();
 
-    // The following two fields are set only for one frame after each incoming
-    // input event. |input_event_client_timestamp| is event timestamp
-    // received from the client. |input_event_received_time| is local time when
-    // the event was received.
-    int64_t input_event_client_timestamp = -1;
-    base::TimeTicks input_event_received_time;
+    // The following field is not-null for a single frame after each incoming
+    // input event.
+    InputEventTimestamps input_event_timestamps;
 
     base::TimeTicks capture_started_time;
     base::TimeTicks capture_ended_time;
     base::TimeTicks encode_started_time;
     base::TimeTicks encode_ended_time;
     base::TimeTicks can_send_time;
   };
 
   struct PacketWithTimestamps {
     PacketWithTimestamps(std::unique_ptr<VideoPacket> packet,
@@ skipping 38 matching lines @@
 
   // Task runner used to run |encoder_|.
   scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner_;
 
   // Capturer used to capture the screen.
   std::unique_ptr<webrtc::DesktopCapturer> capturer_;
 
   // Used to encode captured frames. Always accessed on the encode thread.
   std::unique_ptr<VideoEncoder> encoder_;
 
+  scoped_refptr<InputEventTimestampsSource> event_timestamps_source_;
+
   // Interface through which video frames are passed to the client.
   protocol::VideoStub* video_stub_;
 
   Observer* observer_ = nullptr;
   webrtc::DesktopSize frame_size_;
   webrtc::DesktopVector frame_dpi_;
 
   // Timer used to ensure that we send empty keep-alive frames to the client
   // even when the video stream is paused or encoder is busy.
   base::Timer keep_alive_timer_;
 
   // CaptureScheduler calls CaptureNextFrame() whenever a new frame needs to be
   // captured.
   CaptureScheduler capture_scheduler_;
 
-  // Timestamps for the frame to be captured next.
-  std::unique_ptr<FrameTimestamps> next_frame_timestamps_;
-
   // Timestamps for the frame that's being captured.
   std::unique_ptr<FrameTimestamps> captured_frame_timestamps_;
 
   bool send_pending_ = false;
 
   ScopedVector<PacketWithTimestamps> pending_packets_;
 
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<VideoFramePump> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFramePump);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_VIDEO_FRAME_PUMP_H_