Add basic perf tests for chromoting protocol.

remoting/host/video_scheduler.cc

 // 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.
 
 #include "remoting/host/video_scheduler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 18 matching lines @@
 // Maximum number of frames that can be processed simultaneously.
 // TODO(hclam): Move this value to CaptureScheduler.
 static const int kMaxPendingFrames = 2;
 
 // Interval between empty keep-alive frames. These frames are sent only
 // when there are no real video frames being sent. To prevent PseudoTCP from
 // resetting congestion window this value must be smaller than the minimum
 // RTO used in PseudoTCP, which is 250ms.
 static const int kKeepAlivePacketIntervalMs = 200;
 
+static bool g_enable_timestamps = false;
+
+// static
+void VideoScheduler::EnableTimestampsForTests() {
+  g_enable_timestamps = true;
+}
+
 VideoScheduler::VideoScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_ptr<webrtc::ScreenCapturer> capturer,
     scoped_ptr<VideoEncoder> encoder,
     protocol::CursorShapeStub* cursor_stub,
     protocol::VideoStub* video_stub)
     : capture_task_runner_(capture_task_runner),
       encode_task_runner_(encode_task_runner),
@@ skipping 30 matching lines @@
   if (owned_frame) {
     scheduler_.RecordCaptureTime(
         base::TimeDelta::FromMilliseconds(owned_frame->capture_time_ms()));
   }
 
   // Even when |frame| is NULL we still need to post it to the encode thread
   // to make sure frames are freed in the same order they are received and
   // that we don't start capturing frame n+2 before frame n is freed.
   encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this,
-                            base::Passed(&owned_frame), sequence_number_));
+                            base::Passed(&owned_frame), sequence_number_,
+                            base::TimeTicks::Now()));
 
   // If a frame was skipped, try to capture it again.
   if (did_skip_frame_) {
     capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::CaptureNextFrame, this));
   }
 }
 
 void VideoScheduler::OnCursorShapeChanged(
     webrtc::MouseCursorShape* cursor_shape) {
@@ skipping 230 matching lines @@
   if (!cursor_stub_)
     return;
 
   cursor_stub_->SetCursorShape(*cursor_shape);
 }
 
 // Encoder thread --------------------------------------------------------------
 
 void VideoScheduler::EncodeFrame(
     scoped_ptr<webrtc::DesktopFrame> frame,
-    int64 sequence_number) {
+    int64 sequence_number,
+    base::TimeTicks timestamp) {
   DCHECK(encode_task_runner_->BelongsToCurrentThread());
 
   // Drop the frame if there were no changes.
   if (!frame || frame->updated_region().is_empty()) {
     capture_task_runner_->DeleteSoon(FROM_HERE, frame.release());
     capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::FrameCaptureCompleted, this));
     return;
   }
 
   scoped_ptr<VideoPacket> packet = encoder_->Encode(*frame);
   packet->set_client_sequence_number(sequence_number);
 
+  if (g_enable_timestamps) {
+    packet->set_timestamp(timestamp.ToInternalValue());
+  }
+
   // Destroy the frame before sending |packet| because SendVideoPacket() may
   // trigger another frame to be captured, and the screen capturer expects the
   // old frame to be freed by then.
   frame.reset();
 
   scheduler_.RecordEncodeTime(
       base::TimeDelta::FromMilliseconds(packet->encode_time_ms()));
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 }  // namespace remoting