Minor fixes for protocol perf 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>
-#include <stddef.h>
-
+#include <cmath>
+#include <cstddef>
+#include <cstdlib>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/rand_util.h"

[Irfan, 2016/09/27 15:38:34]

Do you still need the base/rand_util ? Also, what is the reason for moving awway
from base::Rand

[Irfan, 2016/09/27 15:39:45]

duh, saw your commit message. The first Q still holds

[Sergey Ulanov, 2016/09/27 17:15:06]

Done.

 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/base/io_buffer.h"
 #include "remoting/test/leaky_bucket.h"
 #include "third_party/webrtc/base/asyncpacketsocket.h"
 #include "third_party/webrtc/base/socket.h"
 #include "third_party/webrtc/media/base/rtputils.h"
 
 namespace remoting {
 
 namespace {
 
 const int kPortRangeStart = 1024;
 const int kPortRangeEnd = 65535;
 
+double RandDouble() {
+  return static_cast<double>(std::rand()) / RAND_MAX;
+}
+
 double GetNormalRandom(double average, double stddev) {
   // Based on Box-Muller transform, see
   // http://en.wikipedia.org/wiki/Box_Muller_transform .
   return average +
-         stddev * sqrt(-2.0 * log(1.0 - base::RandDouble())) *
-             cos(base::RandDouble() * 2.0 * M_PI);
+         stddev * sqrt(-2.0 * log(1.0 - RandDouble())) *
+             cos(RandDouble() * 2.0 * M_PI);
 }
 
 class FakeUdpSocket : public rtc::AsyncPacketSocket {
  public:
   FakeUdpSocket(FakePacketSocketFactory* factory,
                 scoped_refptr<FakeNetworkDispatcher> dispatcher,
                 const rtc::SocketAddress& local_address);
   ~FakeUdpSocket() override;
 
   void ReceivePacket(const rtc::SocketAddress& from,
@@ skipping 269 matching lines @@
       FROM_HERE,
       base::Bind(&FakePacketSocketFactory::DoReceivePacket,
                  weak_factory_.GetWeakPtr()),
       delay);
 }
 
 void FakePacketSocketFactory::DoReceivePacket() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   PendingPacket packet;
-  if (pending_packets_.size() > 1 && base::RandDouble() < out_of_order_rate_) {
+  if (pending_packets_.size() > 1 && RandDouble() < out_of_order_rate_) {
     std::list<PendingPacket>::iterator it = pending_packets_.begin();
     ++it;
     packet = *it;
     pending_packets_.erase(it);
   } else {
     packet = pending_packets_.front();
     pending_packets_.pop_front();
   }
 
   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);
 }
 
 }  // namespace remoting