Revert of 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 use_webrtc);
-  void MeasureScrollPerformance(bool use_webrtc);
+  void MeasureTotalLatency(bool 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);
+    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();
+    }
+
+    base::TimeDelta total_latency_big_frames;
+    int big_frame_count = 0;
+    base::TimeDelta total_latency_small_frames;
+    int small_frame_count = 0;
+
+    while (big_frame_count + small_frame_count < 30) {
+      std::unique_ptr<webrtc::DesktopFrame> frame = ReceiveFrame();
+      base::TimeTicks frame_received_time = base::TimeTicks::Now();
+      test::CyclicFrameGenerator::ChangeInfoList changes =
+          frame_generator->GetChangeList(frame.get());
+      for (auto& change_info : changes) {
+        base::TimeDelta latency = frame_received_time - change_info.timestamp;
+        switch (change_info.type) {
+          case test::CyclicFrameGenerator::ChangeType::NO_CHANGES:
+            NOTREACHED();
+            break;
+          case test::CyclicFrameGenerator::ChangeType::FULL:
+            total_latency_big_frames += latency;
+            ++big_frame_count;
+            break;
+          case test::CyclicFrameGenerator::ChangeType::CURSOR:
+            total_latency_small_frames += latency;
+            ++small_frame_count;
+            break;
+        }
+      }
+    }
+
+    CHECK(big_frame_count);
+    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();
+    }
+  }
 
   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 43 matching lines @@
     ::testing::Values(NetworkPerformanceParams(0, 0, 2, 0, 0.01),
                       NetworkPerformanceParams(0, 0, 30, 1, 0.01),
                       NetworkPerformanceParams(0, 0, 30, 1, 0.1),
                       NetworkPerformanceParams(0, 0, 300, 20, 0.01),
                       NetworkPerformanceParams(0, 0, 300, 20, 0.1)));
 
 INSTANTIATE_TEST_CASE_P(
     LimitedBandwidth,
     ProtocolPerfTest,
     ::testing::Values(
-        // 100 Mbps
-        NetworkPerformanceParams(12500000, 12500000, 2, 1, 0.0),
-        // 8 Mbps
+        // 100 MBps
+        NetworkPerformanceParams(800000000, 800000000, 2, 1, 0.0),
+        // 8 MBps
         NetworkPerformanceParams(1000000, 300000, 30, 5, 0.01),
         NetworkPerformanceParams(1000000, 2000000, 30, 5, 0.01),
         // 800 kBps
         NetworkPerformanceParams(100000, 30000, 130, 5, 0.01),
         NetworkPerformanceParams(100000, 200000, 130, 5, 0.01)));
 
 TEST_P(ProtocolPerfTest, StreamFrameRate) {
   StartHostAndClient(false, protocol::ChannelConfig::CODEC_VP8);
   ASSERT_NO_FATAL_FAILURE(WaitConnected());
 
@@ skipping 79 matching lines @@
     LOG(INFO) << "Latency: " << latency.InMillisecondsF()
               << "ms Encode: " << last_video_packet_->encode_time_ms()
               << "ms Capture: " << last_video_packet_->capture_time_ms()
               << "ms";
     sum += latency;
   }
 
   LOG(INFO) << "Average: " << (sum / kFrames).InMillisecondsF();
 }
 
-// TotalLatency[Ice|Webrtc] tests measure video latency in the case when the
-// whole screen is updated occasionally. It's intended to simulate the case when
-// user actions (e.g. Alt-Tab, click on the task bar) cause whole screen to be
-// updated.
-void ProtocolPerfTest::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(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();
-  }
-
-  base::TimeDelta total_latency_big_frames;
-  int big_frame_count = 0;
-  base::TimeDelta total_latency_small_frames;
-  int small_frame_count = 0;
-
-  while (big_frame_count + small_frame_count < 30) {
-    std::unique_ptr<webrtc::DesktopFrame> frame = ReceiveFrame();
-    base::TimeTicks frame_received_time = base::TimeTicks::Now();
-    test::CyclicFrameGenerator::ChangeInfoList changes =
-        frame_generator->GetChangeList(frame.get());
-    for (auto& change_info : changes) {
-      base::TimeDelta latency = frame_received_time - change_info.timestamp;
-      switch (change_info.type) {
-        case test::CyclicFrameGenerator::ChangeType::NO_CHANGES:
-          NOTREACHED();
-          break;
-        case test::CyclicFrameGenerator::ChangeType::FULL:
-          total_latency_big_frames += latency;
-          ++big_frame_count;
-          break;
-        case test::CyclicFrameGenerator::ChangeType::CURSOR:
-          total_latency_small_frames += latency;
-          ++small_frame_count;
-          break;
-      }
-    }
-  }
-
-  CHECK(big_frame_count);
-  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();
-  }
-}
-
 TEST_P(ProtocolPerfTest, TotalLatencyIce) {
   MeasureTotalLatency(false);
 }
 
 TEST_P(ProtocolPerfTest, TotalLatencyWebrtc) {
   MeasureTotalLatency(true);
 }
 
-// ScrollPerformance[Ice|Webrtc] tests simulate whole screen being scrolled
-// continuously. They measure FPS and video latency.
-void ProtocolPerfTest::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;
-}
-
-TEST_P(ProtocolPerfTest, ScrollPerformanceIce) {
-  MeasureScrollPerformance(false);
-}
-
-TEST_P(ProtocolPerfTest, ScrollPerformanceWebrtc) {
-  MeasureScrollPerformance(true);
-}
-
 }  // namespace remoting