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

webrtc/base/win32socketserver.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 10 matching lines @@
 
 namespace rtc {
 
 ///////////////////////////////////////////////////////////////////////////////
 // Win32Socket
 ///////////////////////////////////////////////////////////////////////////////
 
 // TODO: Move this to a common place where PhysicalSocketServer can
 // share it.
 // Standard MTUs
-static const uint16 PACKET_MAXIMUMS[] = {
-  65535,    // Theoretical maximum, Hyperchannel
-  32000,    // Nothing
-  17914,    // 16Mb IBM Token Ring
-  8166,     // IEEE 802.4
-  // 4464   // IEEE 802.5 (4Mb max)
-  4352,     // FDDI
-  // 2048,  // Wideband Network
-  2002,     // IEEE 802.5 (4Mb recommended)
-  // 1536,  // Expermental Ethernet Networks
-  // 1500,  // Ethernet, Point-to-Point (default)
-  1492,     // IEEE 802.3
-  1006,     // SLIP, ARPANET
-  // 576,   // X.25 Networks
-  // 544,   // DEC IP Portal
-  // 512,   // NETBIOS
-  508,      // IEEE 802/Source-Rt Bridge, ARCNET
-  296,      // Point-to-Point (low delay)
-  68,       // Official minimum
-  0,        // End of list marker
+static const uint16_t PACKET_MAXIMUMS[] = {
+    65535,  // Theoretical maximum, Hyperchannel
+    32000,  // Nothing
+    17914,  // 16Mb IBM Token Ring
+    8166,   // IEEE 802.4
+    // 4464   // IEEE 802.5 (4Mb max)
+    4352,   // FDDI
+    // 2048,  // Wideband Network
+    2002,   // IEEE 802.5 (4Mb recommended)
+    // 1536,  // Expermental Ethernet Networks
+    // 1500,  // Ethernet, Point-to-Point (default)
+    1492,   // IEEE 802.3
+    1006,   // SLIP, ARPANET
+    // 576,   // X.25 Networks
+    // 544,   // DEC IP Portal
+    // 512,   // NETBIOS
+    508,    // IEEE 802/Source-Rt Bridge, ARCNET
+    296,    // Point-to-Point (low delay)
+    68,     // Official minimum
+    0,      // End of list marker
 };
 
 static const int IP_HEADER_SIZE = 20u;
 static const int ICMP_HEADER_SIZE = 8u;
 static const int ICMP_PING_TIMEOUT_MILLIS = 10000u;
 
 // TODO: Enable for production builds also? Use FormatMessage?
 #ifdef _DEBUG
 LPCSTR WSAErrorToString(int error, LPCSTR *description_result) {
   LPCSTR string = "Unspecified";
@@ skipping 75 matching lines @@
 
 /////////////////////////////////////////////////////////////////////////////
 // Win32Socket::EventSink
 /////////////////////////////////////////////////////////////////////////////
 
 #define WM_SOCKETNOTIFY  (WM_USER + 50)
 #define WM_DNSNOTIFY     (WM_USER + 51)
 
 struct Win32Socket::DnsLookup {
   HANDLE handle;
-  uint16 port;
+  uint16_t port;
   char buffer[MAXGETHOSTSTRUCT];
 };
 
 class Win32Socket::EventSink : public Win32Window {
  public:
   explicit EventSink(Win32Socket * parent) : parent_(parent) { }
 
   void Dispose();
 
   virtual bool OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
@@ skipping 348 matching lines @@
   }
   if (sink_) {
     sink_->Dispose();
     sink_ = NULL;
   }
   addr_.Clear();
   state_ = CS_CLOSED;
   return err;
 }
 
-int Win32Socket::EstimateMTU(uint16* mtu) {
+int Win32Socket::EstimateMTU(uint16_t* mtu) {
   SocketAddress addr = GetRemoteAddress();
   if (addr.IsAny()) {
     error_ = ENOTCONN;
     return -1;
   }
 
   WinPing ping;
   if (!ping.IsValid()) {
     error_ = EINVAL;  // can't think of a better error ID
     return -1;
   }
 
   for (int level = 0; PACKET_MAXIMUMS[level + 1] > 0; ++level) {
-    int32 size = PACKET_MAXIMUMS[level] - IP_HEADER_SIZE - ICMP_HEADER_SIZE;
+    int32_t size = PACKET_MAXIMUMS[level] - IP_HEADER_SIZE - ICMP_HEADER_SIZE;
     WinPing::PingResult result = ping.Ping(addr.ipaddr(), size,
                                            ICMP_PING_TIMEOUT_MILLIS, 1, false);
     if (result == WinPing::PING_FAIL) {
       error_ = EINVAL;  // can't think of a better error ID
       return -1;
     }
     if (result != WinPing::PING_TOO_LARGE) {
       *mtu = PACKET_MAXIMUMS[level];
       return 0;
     }
@@ skipping 80 matching lines @@
   // Ignore events if we're already closed.
   if (socket != socket_)
     return;
 
   error_ = error;
   switch (event) {
     case FD_CONNECT:
       if (error != ERROR_SUCCESS) {
         ReportWSAError("WSAAsync:connect notify", error, addr_);
 #ifdef _DEBUG
-        int32 duration = TimeSince(connect_time_);
+        int32_t duration = TimeSince(connect_time_);
         LOG(LS_INFO) << "WSAAsync:connect error (" << duration
                      << " ms), faking close";
 #endif
         state_ = CS_CLOSED;
         // If you get an error connecting, close doesn't really do anything
         // and it certainly doesn't send back any close notification, but
         // we really only maintain a few states, so it is easiest to get
         // back into a known state by pretending that a close happened, even
         // though the connect event never did occur.
         SignalCloseEvent(this, error);
       } else {
 #ifdef _DEBUG
-        int32 duration = TimeSince(connect_time_);
+        int32_t duration = TimeSince(connect_time_);
         LOG(LS_INFO) << "WSAAsync:connect (" << duration << " ms)";
 #endif
         state_ = CS_CONNECTED;
         SignalConnectEvent(this);
       }
       break;
 
     case FD_ACCEPT:
     case FD_READ:
       if (error != ERROR_SUCCESS) {
@@ skipping 18 matching lines @@
         SignalCloseEvent(this, error);
       }
       break;
   }
 }
 
 void Win32Socket::OnDnsNotify(HANDLE task, int error) {
   if (!dns_ || dns_->handle != task)
     return;
 
-  uint32 ip = 0;
+  uint32_t ip = 0;
   if (error == 0) {
     hostent* pHost = reinterpret_cast<hostent*>(dns_->buffer);
-    uint32 net_ip = *reinterpret_cast<uint32*>(pHost->h_addr_list[0]);
+    uint32_t net_ip = *reinterpret_cast<uint32_t*>(pHost->h_addr_list[0]);
     ip = NetworkToHost32(net_ip);
   }
 
   LOG_F(LS_INFO) << "(" << IPAddress(ip).ToSensitiveString()
                  << ", " << error << ")";
 
   if (error == 0) {
     SocketAddress address(ip, dns_->port);
     error = DoConnect(address);
   } else {
@@ skipping 59 matching lines @@
 
 void Win32SocketServer::SetMessageQueue(MessageQueue* queue) {
   message_queue_ = queue;
 }
 
 bool Win32SocketServer::Wait(int cms, bool process_io) {
   BOOL b;
   if (process_io) {
     // Spin the Win32 message pump at least once, and as long as requested.
     // This is the Thread::ProcessMessages case.
-    uint32 start = Time();
+    uint32_t start = Time();
     do {
       MSG msg;
       SetTimer(wnd_.handle(), 0, cms, NULL);
       // Get the next available message. If we have a modeless dialog, give
       // give the message to IsDialogMessage, which will return true if it
       // was a message for the dialog that it handled internally.
       // Otherwise, dispatch as usual via Translate/DispatchMessage.
       b = GetMessage(&msg, NULL, 0, 0);
       if (b == -1) {
         LOG_GLE(LS_ERROR) << "GetMessage failed.";
@@ skipping 69 matching lines @@
   bool handled = false;
   if (wm == s_wm_wakeup_id || (wm == WM_TIMER && wp == 1)) {
     ss_->Pump();
     lr = 0;
     handled = true;
   }
   return handled;
 }
 
 }  // namespace rtc