Add InputEventTimestampSource interface.

remoting/protocol/video_frame_pump.cc

 // 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.
 
 #include "remoting/protocol/video_frame_pump.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 51 matching lines @@
   DCHECK(video_stub_);
 
   capturer_->Start(this);
   capture_scheduler_.Start();
 }
 
 VideoFramePump::~VideoFramePump() {
   encode_task_runner_->DeleteSoon(FROM_HERE, encoder_.release());
 }
 
+void VideoFramePump::SetEventTimestampsSource(
+    scoped_refptr<InputEventTimestampsSource> event_timestamps_source) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  event_timestamps_source_ = event_timestamps_source;
+}
+
 void VideoFramePump::Pause(bool pause) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   capture_scheduler_.Pause(pause);
 }
 
-void VideoFramePump::OnInputEventReceived(int64_t event_timestamp) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (!next_frame_timestamps_)
-    next_frame_timestamps_.reset(new FrameTimestamps());
-  next_frame_timestamps_->input_event_client_timestamp = event_timestamp;
-  next_frame_timestamps_->input_event_received_time = base::TimeTicks::Now();
-}
-
 void VideoFramePump::SetLosslessEncode(bool want_lossless) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoEncoder::SetLosslessEncode,
                             base::Unretained(encoder_.get()), want_lossless));
 }
 
 void VideoFramePump::SetLosslessColor(bool want_lossless) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 36 matching lines @@
       encode_task_runner_.get(), FROM_HERE,
       base::Bind(&VideoFramePump::EncodeFrame, encoder_.get(),
                  base::Passed(&frame),
                  base::Passed(&captured_frame_timestamps_)),
       base::Bind(&VideoFramePump::OnFrameEncoded, weak_factory_.GetWeakPtr()));
 }
 
 void VideoFramePump::CaptureNextFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // |next_frame_timestamps_| is not set if no input events were received since
-  // the previous frame. In that case create FrameTimestamps instance without
-  // setting |input_event_client_timestamp| and |input_event_received_time|.
-  if (!next_frame_timestamps_)
-    next_frame_timestamps_.reset(new FrameTimestamps());
+  captured_frame_timestamps_.reset(new FrameTimestamps());
+  captured_frame_timestamps_->capture_started_time = base::TimeTicks::Now();
 
-  captured_frame_timestamps_ = std::move(next_frame_timestamps_);
-  captured_frame_timestamps_->capture_started_time = base::TimeTicks::Now();
+  if (event_timestamps_source_) {
+    captured_frame_timestamps_->input_event_timestamps =
+        event_timestamps_source_->TakeLastEventTimestamps();
+  }
 
   capturer_->Capture(webrtc::DesktopRegion());
 }
 
 // static
 std::unique_ptr<VideoFramePump::PacketWithTimestamps>
 VideoFramePump::EncodeFrame(VideoEncoder* encoder,
                             std::unique_ptr<webrtc::DesktopFrame> frame,
                             std::unique_ptr<FrameTimestamps> timestamps) {
   timestamps->encode_started_time = base::TimeTicks::Now();
@@ skipping 41 matching lines @@
   UpdateFrameTimers(packet->packet.get(), packet->timestamps.get());
 
   send_pending_ = true;
   video_stub_->ProcessVideoPacket(std::move(packet->packet),
                                   base::Bind(&VideoFramePump::OnVideoPacketSent,
                                              weak_factory_.GetWeakPtr()));
 }
 
 void VideoFramePump::UpdateFrameTimers(VideoPacket* packet,
                                        FrameTimestamps* timestamps) {
-  if (!timestamps->input_event_received_time.is_null()) {
-    packet->set_capture_pending_time_ms((timestamps->capture_started_time -
-                                         timestamps->input_event_received_time)
-                                            .InMilliseconds());
+  if (!timestamps->input_event_timestamps.is_null()) {
+    packet->set_capture_pending_time_ms(
+        (timestamps->capture_started_time -
+         timestamps->input_event_timestamps.host_timestamp)
+            .InMilliseconds());
     packet->set_latest_event_timestamp(
-        timestamps->input_event_client_timestamp);
+        timestamps->input_event_timestamps.client_timestamp.ToInternalValue());
   }
 
   packet->set_capture_overhead_time_ms(
       (timestamps->capture_ended_time - timestamps->capture_started_time)
           .InMilliseconds() -
       packet->capture_time_ms());
 
   packet->set_encode_pending_time_ms(
       (timestamps->encode_started_time - timestamps->capture_ended_time)
           .InMilliseconds());
@@ skipping 28 matching lines @@
 }
 
 void VideoFramePump::OnKeepAlivePacketSent() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   keep_alive_timer_.Reset();
 }
 
 }  // namespace protocol
 }  // namespace remoting