Add InputEventTimestampSource interface.

remoting/protocol/webrtc_video_stream.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/webrtc_video_stream.h"
 
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "remoting/base/constants.h"
 #include "remoting/codec/webrtc_video_encoder_vpx.h"
 #include "remoting/protocol/frame_stats.h"
 #include "remoting/protocol/host_video_stats_dispatcher.h"
 #include "remoting/protocol/webrtc_dummy_video_capturer.h"
 #include "remoting/protocol/webrtc_frame_scheduler_simple.h"
 #include "remoting/protocol/webrtc_transport.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
 #include "third_party/webrtc/api/peerconnectioninterface.h"
 #include "third_party/webrtc/api/test/fakeconstraints.h"
 #include "third_party/webrtc/media/base/videocapturer.h"
 
 namespace remoting {
 namespace protocol {
 
 const char kStreamLabel[] = "screen_stream";
 const char kVideoLabel[] = "screen_video";
 
 struct WebrtcVideoStream::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 fields is not null only for one frame after each incoming
+  // input event.
+  InputEventTimestamps input_event_timestamps;
 
   base::TimeTicks capture_started_time;
   base::TimeTicks capture_ended_time;
   base::TimeDelta capture_delay;
   base::TimeTicks encode_started_time;
   base::TimeTicks encode_ended_time;
 };
 
 struct WebrtcVideoStream::EncodedFrameWithTimestamps {
   std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> frame;
@@ skipping 61 matching lines @@
   scheduler_.reset(new WebrtcFrameSchedulerSimple());
   scheduler_->Start(
       webrtc_transport_->video_encoder_factory(),
       base::Bind(&WebrtcVideoStream::CaptureNextFrame, base::Unretained(this)));
 
   video_stats_dispatcher_.Init(webrtc_transport_->CreateOutgoingChannel(
                                    video_stats_dispatcher_.channel_name()),
                                this);
 }
 
+void WebrtcVideoStream::SetEventTimestampsSource(
+    scoped_refptr<InputEventTimestampsSource> event_timestamps_source) {
+  event_timestamps_source_ = event_timestamps_source;
+}
+
 void WebrtcVideoStream::Pause(bool pause) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scheduler_->Pause(pause);
 }
 
-void WebrtcVideoStream::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 WebrtcVideoStream::SetLosslessEncode(bool want_lossless) {
   NOTIMPLEMENTED();
 }
 
 void WebrtcVideoStream::SetLosslessColor(bool want_lossless) {
   NOTIMPLEMENTED();
 }
 
 void WebrtcVideoStream::SetObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 41 matching lines @@
 }
 void WebrtcVideoStream::OnChannelClosed(
     ChannelDispatcherBase* channel_dispatcher) {
   DCHECK(&video_stats_dispatcher_ == channel_dispatcher);
   LOG(WARNING) << "video_stats channel was closed.";
 }
 
 void WebrtcVideoStream::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
 WebrtcVideoStream::EncodedFrameWithTimestamps WebrtcVideoStream::EncodeFrame(
     WebrtcVideoEncoder* encoder,
     std::unique_ptr<webrtc::DesktopFrame> frame,
     WebrtcVideoEncoder::FrameParams params,
     std::unique_ptr<WebrtcVideoStream::FrameTimestamps> timestamps) {
@@ skipping 15 matching lines @@
     // TODO(sergeyu): Stop the stream.
     LOG(ERROR) << "Failed to send video frame.";
     return;
   }
 
   // Send FrameStats message.
   if (video_stats_dispatcher_.is_connected()) {
     HostFrameStats stats;
     stats.frame_size = frame.frame->data.size();
 
-    if (!frame.timestamps->input_event_received_time.is_null()) {
-      stats.capture_pending_delay = frame.timestamps->capture_started_time -
-                                    frame.timestamps->input_event_received_time;
-      stats.latest_event_timestamp = base::TimeTicks::FromInternalValue(
-          frame.timestamps->input_event_client_timestamp);
+    if (!frame.timestamps->input_event_timestamps.is_null()) {
+      stats.capture_pending_delay =
+          frame.timestamps->capture_started_time -
+          frame.timestamps->input_event_timestamps.host_timestamp;
+      stats.latest_event_timestamp =
+          frame.timestamps->input_event_timestamps.host_timestamp;
     }
 
     stats.capture_delay = frame.timestamps->capture_delay;
 
     // Total overhead time for IPC and threading when capturing frames.
     stats.capture_overhead_delay = (frame.timestamps->capture_ended_time -
                                     frame.timestamps->capture_started_time) -
                                    stats.capture_delay;
 
     stats.encode_pending_delay = frame.timestamps->encode_started_time -
                                  frame.timestamps->capture_ended_time;
 
     stats.encode_delay = frame.timestamps->encode_ended_time -
                          frame.timestamps->encode_started_time;
 
     // TODO(sergeyu): Figure out how to measure send_pending time with WebRTC
     // and set it here.
     stats.send_pending_delay = base::TimeDelta();
 
     video_stats_dispatcher_.OnVideoFrameStats(result.frame_id, stats);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting