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

webrtc/p2p/base/asyncstuntcpsocket.cc

 /*
  *  Copyright 2013 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.
  */
 
 #include "webrtc/p2p/base/asyncstuntcpsocket.h"
 
 #include <string.h>
 
 #include "webrtc/p2p/base/stun.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 
 namespace cricket {
 
 static const size_t kMaxPacketSize = 64 * 1024;
 
-typedef uint16 PacketLength;
+typedef uint16_t PacketLength;
 static const size_t kPacketLenSize = sizeof(PacketLength);
 static const size_t kPacketLenOffset = 2;
 static const size_t kBufSize = kMaxPacketSize + kStunHeaderSize;
 static const size_t kTurnChannelDataHdrSize = 4;
 
-inline bool IsStunMessage(uint16 msg_type) {
+inline bool IsStunMessage(uint16_t msg_type) {
   // The first two bits of a channel data message are 0b01.
   return (msg_type & 0xC000) ? false : true;
 }
 
 // AsyncStunTCPSocket
 // Binds and connects |socket| and creates AsyncTCPSocket for
 // it. Takes ownership of |socket|. Returns NULL if bind() or
 // connect() fail (|socket| is destroyed in that case).
 AsyncStunTCPSocket* AsyncStunTCPSocket::Create(
     rtc::AsyncSocket* socket,
@@ skipping 82 matching lines @@
     rtc::AsyncSocket* socket) {
   SignalNewConnection(this, new AsyncStunTCPSocket(socket, false));
 }
 
 size_t AsyncStunTCPSocket::GetExpectedLength(const void* data, size_t len,
                                              int* pad_bytes) {
   *pad_bytes = 0;
   PacketLength pkt_len =
       rtc::GetBE16(static_cast<const char*>(data) + kPacketLenOffset);
   size_t expected_pkt_len;
-  uint16 msg_type = rtc::GetBE16(data);
+  uint16_t msg_type = rtc::GetBE16(data);
   if (IsStunMessage(msg_type)) {
     // STUN message.
     expected_pkt_len = kStunHeaderSize + pkt_len;
   } else {
     // TURN ChannelData message.
     expected_pkt_len = kTurnChannelDataHdrSize + pkt_len;
     // From RFC 5766 section 11.5
     // Over TCP and TLS-over-TCP, the ChannelData message MUST be padded to
     // a multiple of four bytes in order to ensure the alignment of
     // subsequent messages.  The padding is not reflected in the length
     // field of the ChannelData message, so the actual size of a ChannelData
     // message (including padding) is (4 + Length) rounded up to the nearest
     // multiple of 4.  Over UDP, the padding is not required but MAY be
     // included.
     if (expected_pkt_len % 4)
       *pad_bytes = 4 - (expected_pkt_len % 4);
   }
   return expected_pkt_len;
 }
 
 }  // namespace cricket