Add InputEventTimestampSource interface.

remoting/protocol/host_event_dispatcher.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_PROTOCOL_HOST_EVENT_DISPATCHER_H_
 #define REMOTING_PROTOCOL_HOST_EVENT_DISPATCHER_H_
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "remoting/protocol/channel_dispatcher_base.h"
+#include "remoting/protocol/input_event_timestamps.h"
 
 namespace remoting {
 namespace protocol {
 
 class EventMessage;
 class InputStub;
 
 // HostEventDispatcher dispatches incoming messages on the event
 // channel to InputStub.
 class HostEventDispatcher : public ChannelDispatcherBase {
  public:
-  typedef base::Callback<void(int64_t)> OnInputEventCallback;
-
   HostEventDispatcher();
   ~HostEventDispatcher() override;
 
   // Set InputStub that will be called for each incoming input
   // message. Doesn't take ownership of |input_stub|. It must outlive
   // the dispatcher.
   void set_input_stub(InputStub* input_stub) { input_stub_ = input_stub; }
 
-  // Set callback to notify of each message's sequence number. The
-  // callback cannot tear down this object.
-  void set_on_input_event_callback(const OnInputEventCallback& value) {
-    on_input_event_callback_ = value;
+  // Returns InputEventTimestampsSource for events received on input channel.
+  //
+  // TODO(sergeyu): Here we assume that |input_stub_| injects all events
+  // instantly, which is not always the case. Consider moving this to
+  // InputInjector. This would require updating InputStub to get
+  // timestamps for each event.

[Jamie, 2016/10/14 20:30:30]

I don't understand this comment. The host timestamp is documented as being the
time at which the event was received, not when it was injected. Are you saying
that current implementations measure the latter instead?

[Sergey Ulanov, 2016/10/14 21:04:20]

The current implementation matches the comments for host_timestamp.
InputEventTimestamps.host_timestamp is the time when the event was received and
that's what this timestamps source will return. The point here is that it's not
an ideal approach. It would be better if latest_event_timestamp field in
VideoStats message was set according to injected events, not as they are
received. In other words currently we don't account for event injection delay
when measuring interactive latency.

Rephrased this TODO and also updated comment for host_timestamp

+  scoped_refptr<InputEventTimestampsSource> event_timestamps_source() {
+    return event_timestamps_source_;
   }
 
  private:
   void OnIncomingMessage(std::unique_ptr<CompoundBuffer> buffer) override;
 
+  scoped_refptr<InputEventTimestampsSourceImpl> event_timestamps_source_;
+
   InputStub* input_stub_ = nullptr;
-  OnInputEventCallback on_input_event_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(HostEventDispatcher);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_HOST_EVENT_DISPATCHER_H_