Add scroll perf test for protocol in chromoting

remoting/test/protocol_perftest.cc

 // Copyright 2014 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 <utility>
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 25 matching lines @@
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
 #include "remoting/protocol/session_config.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/video_frame_pump.h"
 #include "remoting/protocol/video_renderer.h"
 #include "remoting/signaling/fake_signal_strategy.h"
 #include "remoting/test/cyclic_frame_generator.h"
 #include "remoting/test/fake_network_dispatcher.h"
 #include "remoting/test/fake_port_allocator.h"
 #include "remoting/test/fake_socket_factory.h"
+#include "remoting/test/scroll_frame_generator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 
 using protocol::ChannelConfig;
 
 namespace {
 
 const char kHostJid[] = "host_jid@example.com/host";
 const char kHostOwner[] = "jane.doe@example.com";
@@ skipping 352 matching lines @@
     client_->Start(client_signaling_.get(), client_auth_config,
                    transport_context, kHostJid, std::string());
   }
 
   void FetchPin(
       bool pairing_supported,
       const protocol::SecretFetchedCallback& secret_fetched_callback) {
     secret_fetched_callback.Run(kHostPin);
   }
 
-  void MeasureTotalLatency(bool webrtc) {
+  void MeasureTotalLatency(bool use_webrtc) {
     scoped_refptr<test::CyclicFrameGenerator> frame_generator =
         test::CyclicFrameGenerator::Create();
     frame_generator->set_draw_barcode(true);
 
     desktop_environment_factory_.set_frame_generator(base::Bind(
         &test::CyclicFrameGenerator::GenerateFrame, frame_generator));
 
-    StartHostAndClient(webrtc, protocol::ChannelConfig::CODEC_VP8);
+    StartHostAndClient(use_webrtc, protocol::ChannelConfig::CODEC_VP8);
     ASSERT_NO_FATAL_FAILURE(WaitConnected());
 
     int skipped_frames = 0;
     while (skipped_frames < 10) {
       std::unique_ptr<webrtc::DesktopFrame> frame = ReceiveFrame();
       test::CyclicFrameGenerator::ChangeInfoList changes =
           frame_generator->GetChangeList(frame.get());
       skipped_frames += changes.size();
     }
 
@@ skipping 29 matching lines @@
     VLOG(0) << "Average latency for big frames: "
             << (total_latency_big_frames / big_frame_count).InMillisecondsF();
 
     if (small_frame_count) {
       VLOG(0)
           << "Average latency for small frames: "
           << (total_latency_small_frames / small_frame_count).InMillisecondsF();
     }
   }
 
+  void MeasureScrollPerformance(bool use_webrtc) {
+    scoped_refptr<test::ScrollFrameGenerator> frame_generator =
+        new test::ScrollFrameGenerator();
+
+    desktop_environment_factory_.set_frame_generator(base::Bind(
+        &test::ScrollFrameGenerator::GenerateFrame, frame_generator));
+
+    StartHostAndClient(use_webrtc, protocol::ChannelConfig::CODEC_VP8);
+    ASSERT_NO_FATAL_FAILURE(WaitConnected());
+
+    base::TimeTicks start_time = base::TimeTicks::Now();
+    const base::TimeDelta kWarmUpTime = base::TimeDelta::FromSeconds(2);
+    while ((base::TimeTicks::Now() - start_time) < kWarmUpTime) {
+      ReceiveFrame();
+    }
+
+    // Run the test for 2 seconds.
+    const base::TimeDelta kTestTime = base::TimeDelta::FromSeconds(2);
+
+    int num_frames = 0;
+    base::TimeDelta total_latency;
+    start_time = base::TimeTicks::Now();
+    while ((base::TimeTicks::Now() - start_time) < kTestTime) {
+      std::unique_ptr<webrtc::DesktopFrame> frame = ReceiveFrame();
+      ++num_frames;
+      total_latency += frame_generator->GetFrameLatency(*frame);
+    }
+
+    VLOG(0) << "FPS: "
+            << num_frames / (base::TimeTicks::Now() - start_time).InSecondsF();
+
+    VLOG(0) << "Average latency: "
+            << (total_latency).InMillisecondsF() / num_frames;
+  }
+
   base::MessageLoopForIO message_loop_;
 
   scoped_refptr<FakeNetworkDispatcher> fake_network_dispatcher_;
 
   base::Thread host_thread_;
   base::Thread capture_thread_;
   base::Thread encode_thread_;
   base::Thread decode_thread_;
   FakeDesktopEnvironmentFactory desktop_environment_factory_;
 
@@ skipping 152 matching lines @@
 }
 
 TEST_P(ProtocolPerfTest, TotalLatencyIce) {
   MeasureTotalLatency(false);
 }
 
 TEST_P(ProtocolPerfTest, TotalLatencyWebrtc) {
   MeasureTotalLatency(true);
 }
 
+TEST_P(ProtocolPerfTest, ScrollPerformanceIce) {
+  MeasureScrollPerformance(false);
+}
+
+TEST_P(ProtocolPerfTest, ScrollPerformanceWebrtc) {
+  MeasureScrollPerformance(true);
+}
+
 }  // namespace remoting