Switch to standard integer types in remoting/.

remoting/client/plugin/pepper_packet_socket_factory.cc

 // Copyright (c) 2012 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 "remoting/client/plugin/pepper_packet_socket_factory.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "ppapi/cpp/net_address.h"
 #include "ppapi/cpp/udp_socket.h"
 #include "ppapi/utility/completion_callback_factory.h"
 #include "remoting/client/plugin/pepper_address_resolver.h"
 #include "remoting/client/plugin/pepper_util.h"
 #include "remoting/protocol/socket_util.h"
 #include "third_party/webrtc/base/asyncpacketsocket.h"
 #include "third_party/webrtc/base/nethelpers.h"
@@ skipping 65 matching lines @@
 }
 
 class UdpPacketSocket : public rtc::AsyncPacketSocket {
  public:
   explicit UdpPacketSocket(const pp::InstanceHandle& instance);
   ~UdpPacketSocket() override;
 
   // |min_port| and |max_port| are set to zero if the port number
   // should be assigned by the OS.
   bool Init(const rtc::SocketAddress& local_address,
-            uint16 min_port,
-            uint16 max_port);
+            uint16_t min_port,
+            uint16_t max_port);
 
   // rtc::AsyncPacketSocket interface.
   rtc::SocketAddress GetLocalAddress() const override;
   rtc::SocketAddress GetRemoteAddress() const override;
   int Send(const void* data,
            size_t data_size,
            const rtc::PacketOptions& options) override;
   int SendTo(const void* data,
              size_t data_size,
              const rtc::SocketAddress& address,
@@ skipping 70 matching lines @@
       send_pending_(false),
       send_queue_size_(0),
       callback_factory_(this) {
 }
 
 UdpPacketSocket::~UdpPacketSocket() {
   Close();
 }
 
 bool UdpPacketSocket::Init(const rtc::SocketAddress& local_address,
-                           uint16 min_port,
-                           uint16 max_port) {
+                           uint16_t min_port,
+                           uint16_t max_port) {
   if (socket_.is_null()) {
     return false;
   }
 
   local_address_ = local_address;
   max_port_ = max_port;
   min_port_ = min_port;
 
   pp::NetAddress pp_local_address;
   if (!SocketAddressToPpNetAddressWithPort(
@@ skipping 203 matching lines @@
 
 PepperPacketSocketFactory::PepperPacketSocketFactory(
     const pp::InstanceHandle& instance)
     : pp_instance_(instance) {
 }
 
 PepperPacketSocketFactory::~PepperPacketSocketFactory() {
 }
 
 rtc::AsyncPacketSocket* PepperPacketSocketFactory::CreateUdpSocket(
-      const rtc::SocketAddress& local_address,
-      uint16 min_port,
-      uint16 max_port) {
+    const rtc::SocketAddress& local_address,
+    uint16_t min_port,
+    uint16_t max_port) {
   scoped_ptr<UdpPacketSocket> result(new UdpPacketSocket(pp_instance_));
   if (!result->Init(local_address, min_port, max_port))
     return nullptr;
   return result.release();
 }
 
 rtc::AsyncPacketSocket* PepperPacketSocketFactory::CreateServerTcpSocket(
     const rtc::SocketAddress& local_address,
-    uint16 min_port,
-    uint16 max_port,
+    uint16_t min_port,
+    uint16_t max_port,
     int opts) {
   // We don't use TCP sockets for remoting connections.
   NOTREACHED();
   return nullptr;
 }
 
 rtc::AsyncPacketSocket* PepperPacketSocketFactory::CreateClientTcpSocket(
       const rtc::SocketAddress& local_address,
       const rtc::SocketAddress& remote_address,
       const rtc::ProxyInfo& proxy_info,
       const std::string& user_agent,
       int opts) {
   // We don't use TCP sockets for remoting connections.
   NOTREACHED();
   return nullptr;
 }
 
 rtc::AsyncResolverInterface*
 PepperPacketSocketFactory::CreateAsyncResolver() {
   return new PepperAddressResolver(pp_instance_);
 }
 
 }  // namespace remoting