Report network stats in the scroll performance tests

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 <numeric>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
@@ skipping 293 matching lines @@
     protocol::NetworkSettings network_settings(
         protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING);
 
     // Initialize client.
     client_context_.reset(
         new ClientContext(base::ThreadTaskRunnerHandle::Get()));
     client_context_->Start();
 
     std::unique_ptr<FakePortAllocatorFactory> port_allocator_factory(
         new FakePortAllocatorFactory(fake_network_dispatcher_));
+    client_socket_factory_ = port_allocator_factory->socket_factory();
     port_allocator_factory->socket_factory()->SetBandwidth(
         GetParam().bandwidth, GetParam().max_buffers);
     port_allocator_factory->socket_factory()->SetLatency(
         GetParam().latency_average, GetParam().latency_stddev);
     port_allocator_factory->socket_factory()->set_out_of_order_rate(
         GetParam().out_of_order_rate);
     scoped_refptr<protocol::TransportContext> transport_context(
         new protocol::TransportContext(
             host_signaling_.get(), std::move(port_allocator_factory), nullptr,
             network_settings, protocol::TransportRole::CLIENT));
@@ skipping 37 matching lines @@
   std::unique_ptr<protocol::CandidateSessionConfig> protocol_config_;
 
   std::unique_ptr<FakeSignalStrategy> host_signaling_;
   std::unique_ptr<FakeSignalStrategy> client_signaling_;
 
   std::unique_ptr<ChromotingHost> host_;
   std::unique_ptr<ClientContext> client_context_;
   std::unique_ptr<SoftwareVideoRenderer> video_renderer_;
   std::unique_ptr<ChromotingClient> client_;
 
+  FakePacketSocketFactory* client_socket_factory_;
+
   std::unique_ptr<base::RunLoop> connecting_loop_;
   std::unique_ptr<base::RunLoop> waiting_frames_loop_;
 
   std::unique_ptr<base::RunLoop> waiting_frame_stats_loop_;
   size_t num_expected_frame_stats_;
 
   bool client_connected_;
   bool host_connected_;
 
   base::Closure on_frame_task_;
@@ skipping 166 matching lines @@
 
   int warm_up_frames = 0;
 
   base::TimeTicks start_time = base::TimeTicks::Now();
   const base::TimeDelta kWarmUpTime = base::TimeDelta::FromSeconds(2);
   while ((base::TimeTicks::Now() - start_time) < kWarmUpTime) {
     ReceiveFrame();
     ++warm_up_frames;
   }
 
+  client_socket_factory_->ResetStats();
+
   // Run the test for 2 seconds.
   const base::TimeDelta kTestTime = base::TimeDelta::FromSeconds(2);
 
   int num_frames = 0;
   base::TimeDelta latency_sum;
   start_time = base::TimeTicks::Now();
   while ((base::TimeTicks::Now() - start_time) < kTestTime) {
     std::unique_ptr<webrtc::DesktopFrame> frame = ReceiveFrame();
     ++num_frames;
     latency_sum += frame_generator->GetFrameLatency(*frame);
@@ skipping 10 matching lines @@
                         return sum + stats.host_stats.frame_size;
                       });
 
   VLOG(0) << "FPS: " << num_frames / total_time.InSecondsF();
   VLOG(0) << "Average latency: " << latency_sum.InMillisecondsF() / num_frames
           << " ms";
   VLOG(0) << "Total size: " << total_size << " bytes";
   VLOG(0) << "Bandwidth utilization: "
           << 100 * total_size / (total_time.InSecondsF() * GetParam().bandwidth)
           << "%";
+  VLOG(0) << "Average host->client network latency + bufferbloat: "
+          << client_socket_factory_->GetAverageDelay().InMilliseconds()

[Irfan, 2016/09/27 17:52:07]

It appears a packet is dropped when the buffer overflows in the leaky bucket and
this does not get taken into account.

If you want true impact of the buffer + latency, it seems we should either
measure the packet loss as a result of the buffer drop or take into account the
latency of these dropped packets (MAX) WDYT ?

[Sergey Ulanov, 2016/09/27 20:21:35]

This is good point. Problem is that the fake network layer doesn't know when
packets are resent, so I don't see how it could measure impact of dropped
packets on total latency.
The goal here is to measure impact of buffer bloat, not the network latency
overall. Updated how this value is reported. Also updated this code to report
packet drop rate.

+          << " ms";
 }
 
 TEST_P(ProtocolPerfTest, ScrollPerformanceIce) {
   MeasureScrollPerformance(false);
 }
 
 TEST_P(ProtocolPerfTest, ScrollPerformanceWebrtc) {
   MeasureScrollPerformance(true);
 }
 
 }  // namespace remoting