Chromoting to report roundtrip latency

remoting/host/screen_recorder.cc

 // Copyright (c) 2011 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/host/screen_recorder.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 31 matching lines @@
     Encoder* encoder)
     : capture_loop_(capture_loop),
       encode_loop_(encode_loop),
       network_loop_(network_loop),
       capturer_(capturer),
       encoder_(encoder),
       is_recording_(false),
       network_stopped_(false),
       recordings_(0),
       frame_skipped_(false),
-      max_rate_(kDefaultCaptureRate) {
+      max_rate_(kDefaultCaptureRate),
+      sequence_number_(0) {
   DCHECK(capture_loop_);
   DCHECK(encode_loop_);
   DCHECK(network_loop_);
 }
 
 ScreenRecorder::~ScreenRecorder() {
 }
 
 // Public methods --------------------------------------------------------------
 
@@ skipping 32 matching lines @@
       FROM_HERE,
       NewTracedMethod(this, &ScreenRecorder::DoRemoveClient, connection));
 }
 
 void ScreenRecorder::RemoveAllConnections() {
   network_loop_->PostTask(
       FROM_HERE,
       NewTracedMethod(this, &ScreenRecorder::DoRemoveAllClients));
 }
 
+void ScreenRecorder::UpdateSequenceNumber(int64 sequence_number) {
+  // Sequence number is used and written only on the capture thread.
+  if (MessageLoop::current() != capture_loop_) {
+    capture_loop_->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(this, &ScreenRecorder::UpdateSequenceNumber,
+                          sequence_number));
+    return;
+  }
+
+  sequence_number_ = sequence_number;
+}
+
 // Private accessors -----------------------------------------------------------
 
 Capturer* ScreenRecorder::capturer() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
   DCHECK(capturer_);
   return capturer_;
 }
 
 Encoder* ScreenRecorder::encoder() {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
@@ skipping 106 matching lines @@
     scoped_refptr<CaptureData> capture_data) {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   if (!is_recording_)
     return;
 
   TraceContext::tracer()->PrintString("Capture Done");
   int capture_time = static_cast<int>(
       (base::Time::Now() - capture_start_time_).InMilliseconds());
   capture_data->set_capture_time_ms(capture_time);
+
+  // The best way to get this value is by binding the sequence number to
+  // the callback when calling CaptureInvalidRects(). However the callback
+  // system doesn't allow this. Reading from the member variable is
+  // accurate as long as capture is synchronous as the following statement
+  // will obtain the most recent sequence number received.
+  capture_data->set_client_sequence_number(sequence_number_);
+
   encode_loop_->PostTask(
       FROM_HERE,
       NewTracedMethod(this, &ScreenRecorder::DoEncode, capture_data));
 }
 
 void ScreenRecorder::DoFinishOneRecording() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   if (!is_recording_)
     return;
@@ skipping 144 matching lines @@
         (base::Time::Now() - encode_start_time_).InMilliseconds());
     packet->set_encode_time_ms(encode_time);
   }
 
   network_loop_->PostTask(
       FROM_HERE,
       NewTracedMethod(this, &ScreenRecorder::DoSendVideoPacket, packet));
 }
 
 }  // namespace remoting