Switch to standard integer types in remoting/.

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "remoting/test/leaky_bucket.h"
 #include "third_party/webrtc/base/asyncpacketsocket.h"
 
 namespace remoting {
 
 namespace {
@@ skipping 168 matching lines @@
 
 void FakePacketSocketFactory::SetLatency(base::TimeDelta average,
                                          base::TimeDelta stddev) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   latency_average_ = average;
   latency_stddev_ = stddev;
 }
 
 rtc::AsyncPacketSocket* FakePacketSocketFactory::CreateUdpSocket(
     const rtc::SocketAddress& local_address,
-    uint16 min_port, uint16 max_port) {
+    uint16_t min_port,
+    uint16_t max_port) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   int port = -1;
   if (min_port > 0 && max_port > 0) {
-    for (uint16 i = min_port; i <= max_port; ++i) {
+    for (uint16_t i = min_port; i <= max_port; ++i) {
       if (udp_sockets_.find(i) == udp_sockets_.end()) {
         port = i;
         break;
       }
     }
     if (port < 0)
       return nullptr;
   } else {
     do {
       port = next_port_;
       next_port_ =
           (next_port_ >= kPortRangeEnd) ? kPortRangeStart : (next_port_ + 1);
     } while (udp_sockets_.find(port) != udp_sockets_.end());
   }
 
   CHECK(local_address.ipaddr() == address_);
 
   FakeUdpSocket* result =
       new FakeUdpSocket(this, dispatcher_,
                         rtc::SocketAddress(local_address.ipaddr(), port));
 
   udp_sockets_[port] =
       base::Bind(&FakeUdpSocket::ReceivePacket, base::Unretained(result));
 
   return result;
 }
 
 rtc::AsyncPacketSocket* FakePacketSocketFactory::CreateServerTcpSocket(
     const rtc::SocketAddress& local_address,
-    uint16 min_port, uint16 max_port,
+    uint16_t min_port,
+    uint16_t max_port,
     int opts) {
   return nullptr;
 }
 
 rtc::AsyncPacketSocket* FakePacketSocketFactory::CreateClientTcpSocket(
     const rtc::SocketAddress& local_address,
     const rtc::SocketAddress& remote_address,
     const rtc::ProxyInfo& proxy_info,
     const std::string& user_agent,
     int opts) {
@@ skipping 72 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);
 }
 
 }  // namespace remoting