Report network stats in the scroll performance tests

remoting/test/fake_socket_factory.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "remoting/test/fake_socket_factory.h"
 
 #include <math.h>
@@ skipping 158 matching lines @@
     const rtc::SocketAddress& from,
     const rtc::SocketAddress& to,
     const scoped_refptr<net::IOBuffer>& data,
     int data_size)
     : from(from), to(to), data(data), data_size(data_size) {
 }
 
 FakePacketSocketFactory::PendingPacket::PendingPacket(
     const PendingPacket& other) = default;
 
-FakePacketSocketFactory::PendingPacket::~PendingPacket() {
-}
+FakePacketSocketFactory::PendingPacket::~PendingPacket() {}
 
 FakePacketSocketFactory::FakePacketSocketFactory(
     FakeNetworkDispatcher* dispatcher)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       dispatcher_(dispatcher),
       address_(dispatcher_->AllocateAddress()),
       out_of_order_rate_(0.0),
       next_port_(kPortRangeStart),
       weak_factory_(this) {
   dispatcher_->AddNode(this);
@@ skipping 111 matching lines @@
   }
 
   if (latency_average_ > base::TimeDelta()) {
     delay += base::TimeDelta::FromMillisecondsD(
         GetNormalRandom(latency_average_.InMillisecondsF(),
                         latency_stddev_.InMillisecondsF()));
   }
   if (delay < base::TimeDelta())
     delay = base::TimeDelta();
 
+  total_delay_ += delay;
+  ++total_packets_received_;
+
   // Put the packet to the |pending_packets_| and post a task for
   // DoReceivePackets(). Note that the DoReceivePackets() task posted here may
   // deliver a different packet, not the one added to the queue here. This
   // would happen if another task gets posted with a shorted delay or when
   // |out_of_order_rate_| is greater than 0. It's implemented this way to
   // decouple latency variability from out-of-order delivery.
   PendingPacket packet(from, to, data, data_size);
   pending_packets_.push_back(packet);
   task_runner_->PostDelayedTask(
       FROM_HERE,
@@ skipping 18 matching lines @@
 
   UdpSocketsMap::iterator iter = udp_sockets_.find(packet.to.port());
   if (iter == udp_sockets_.end()) {
     // Invalid port number.
     return;
   }
 
   iter->second.Run(packet.from, packet.to, packet.data, packet.data_size);
 }
 
+void FakePacketSocketFactory::ResetStats() {
+  total_packets_received_ = 0;
+  total_delay_ = base::TimeDelta();
+}
+
+base::TimeDelta FakePacketSocketFactory::GetAverageDelay() {
+  return total_packets_received_ > 0 ? (total_delay_ / total_packets_received_)
+                                     : base::TimeDelta();
+}
+
 }  // namespace remoting