Use suffixed {uint,int}{8,16,32,64}_t types.

webrtc/base/socketaddress.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 29 matching lines @@
 
 SocketAddress::SocketAddress() {
   Clear();
 }
 
 SocketAddress::SocketAddress(const std::string& hostname, int port) {
   SetIP(hostname);
   SetPort(port);
 }
 
-SocketAddress::SocketAddress(uint32 ip_as_host_order_integer, int port) {
+SocketAddress::SocketAddress(uint32_t ip_as_host_order_integer, int port) {
   SetIP(IPAddress(ip_as_host_order_integer));
   SetPort(port);
 }
 
 SocketAddress::SocketAddress(const IPAddress& ip, int port) {
   SetIP(ip);
   SetPort(port);
 }
 
 SocketAddress::SocketAddress(const SocketAddress& addr) {
@@ skipping 18 matching lines @@
 
 SocketAddress& SocketAddress::operator=(const SocketAddress& addr) {
   hostname_ = addr.hostname_;
   ip_ = addr.ip_;
   port_ = addr.port_;
   literal_ = addr.literal_;
   scope_id_ = addr.scope_id_;
   return *this;
 }
 
-void SocketAddress::SetIP(uint32 ip_as_host_order_integer) {
+void SocketAddress::SetIP(uint32_t ip_as_host_order_integer) {
   hostname_.clear();
   literal_ = false;
   ip_ = IPAddress(ip_as_host_order_integer);
   scope_id_ = 0;
 }
 
 void SocketAddress::SetIP(const IPAddress& ip) {
   hostname_.clear();
   literal_ = false;
   ip_ = ip;
   scope_id_ = 0;
 }
 
 void SocketAddress::SetIP(const std::string& hostname) {
   hostname_ = hostname;
   literal_ = IPFromString(hostname, &ip_);
   if (!literal_) {
     ip_ = IPAddress();
   }
   scope_id_ = 0;
 }
 
-void SocketAddress::SetResolvedIP(uint32 ip_as_host_order_integer) {
+void SocketAddress::SetResolvedIP(uint32_t ip_as_host_order_integer) {
   ip_ = IPAddress(ip_as_host_order_integer);
   scope_id_ = 0;
 }
 
 void SocketAddress::SetResolvedIP(const IPAddress& ip) {
   ip_ = ip;
   scope_id_ = 0;
 }
 
 void SocketAddress::SetPort(int port) {
   ASSERT((0 <= port) && (port < 65536));
-  port_ = static_cast<uint16>(port);
+  port_ = static_cast<uint16_t>(port);
 }
 
-uint32 SocketAddress::ip() const {
+uint32_t SocketAddress::ip() const {
   return ip_.v4AddressAsHostOrderInteger();
 }
 
 const IPAddress& SocketAddress::ipaddr() const {
   return ip_;
 }
 
-uint16 SocketAddress::port() const {
+uint16_t SocketAddress::port() const {
   return port_;
 }
 
 std::string SocketAddress::HostAsURIString() const {
   // If the hostname was a literal IP string, it may need to have square
   // brackets added (for SocketAddress::ToString()).
   if (!literal_ && !hostname_.empty())
     return hostname_;
   if (ip_.family() == AF_INET6) {
     return "[" + ip_.ToString() + "]";
@@ skipping 126 matching lines @@
 bool SocketAddress::FromSockAddr(const sockaddr_in& saddr) {
   if (saddr.sin_family != AF_INET)
     return false;
   SetIP(NetworkToHost32(saddr.sin_addr.s_addr));
   SetPort(NetworkToHost16(saddr.sin_port));
   literal_ = false;
   return true;
 }
 
 static size_t ToSockAddrStorageHelper(sockaddr_storage* addr,
-                                      IPAddress ip, uint16 port, int scope_id) {
+                                      IPAddress ip,
+                                      uint16_t port,
+                                      int scope_id) {
   memset(addr, 0, sizeof(sockaddr_storage));
   addr->ss_family = static_cast<unsigned short>(ip.family());
   if (addr->ss_family == AF_INET6) {
     sockaddr_in6* saddr = reinterpret_cast<sockaddr_in6*>(addr);
     saddr->sin6_addr = ip.ipv6_address();
     saddr->sin6_port = HostToNetwork16(port);
     saddr->sin6_scope_id = scope_id;
     return sizeof(sockaddr_in6);
   } else if (addr->ss_family == AF_INET) {
     sockaddr_in* saddr = reinterpret_cast<sockaddr_in*>(addr);
     saddr->sin_addr = ip.ipv4_address();
     saddr->sin_port = HostToNetwork16(port);
     return sizeof(sockaddr_in);
   }
   return 0;
 }
 
 size_t SocketAddress::ToDualStackSockAddrStorage(sockaddr_storage *addr) const {
   return ToSockAddrStorageHelper(addr, ip_.AsIPv6Address(), port_, scope_id_);
 }
 
 size_t SocketAddress::ToSockAddrStorage(sockaddr_storage* addr) const {
   return ToSockAddrStorageHelper(addr, ip_, port_, scope_id_);
 }
 
-std::string SocketAddress::IPToString(uint32 ip_as_host_order_integer) {
+std::string SocketAddress::IPToString(uint32_t ip_as_host_order_integer) {
   return IPAddress(ip_as_host_order_integer).ToString();
 }
 
-std::string IPToSensitiveString(uint32 ip_as_host_order_integer) {
+std::string IPToSensitiveString(uint32_t ip_as_host_order_integer) {
   return IPAddress(ip_as_host_order_integer).ToSensitiveString();
 }
 
-bool SocketAddress::StringToIP(const std::string& hostname, uint32* ip) {
+bool SocketAddress::StringToIP(const std::string& hostname, uint32_t* ip) {
   in_addr addr;
   if (rtc::inet_pton(AF_INET, hostname.c_str(), &addr) == 0)
     return false;
   *ip = NetworkToHost32(addr.s_addr);
   return true;
 }
 
 bool SocketAddress::StringToIP(const std::string& hostname, IPAddress* ip) {
   in_addr addr4;
   if (rtc::inet_pton(AF_INET, hostname.c_str(), &addr4) > 0) {
     if (ip) {
       *ip = IPAddress(addr4);
     }
     return true;
   }
 
   in6_addr addr6;
   if (rtc::inet_pton(AF_INET6, hostname.c_str(), &addr6) > 0) {
     if (ip) {
       *ip = IPAddress(addr6);
     }
     return true;
   }
   return false;
 }
 
-uint32 SocketAddress::StringToIP(const std::string& hostname) {
-  uint32 ip = 0;
+uint32_t SocketAddress::StringToIP(const std::string& hostname) {
+  uint32_t ip = 0;
   StringToIP(hostname, &ip);
   return ip;
 }
 
 bool SocketAddressFromSockAddrStorage(const sockaddr_storage& addr,
                                       SocketAddress* out) {
   if (!out) {
     return false;
   }
   if (addr.ss_family == AF_INET) {
@@ skipping 14 matching lines @@
 SocketAddress EmptySocketAddressWithFamily(int family) {
   if (family == AF_INET) {
     return SocketAddress(IPAddress(INADDR_ANY), 0);
   } else if (family == AF_INET6) {
     return SocketAddress(IPAddress(in6addr_any), 0);
   }
   return SocketAddress();
 }
 
 }  // namespace rtc