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

webrtc/base/bytebuffer.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 48 matching lines @@
     memcpy(bytes_, bytes, end_);
   } else {
     end_ = 0;
   }
 }
 
 ByteBuffer::~ByteBuffer() {
   delete[] bytes_;
 }
 
-bool ByteBuffer::ReadUInt8(uint8* val) {
+bool ByteBuffer::ReadUInt8(uint8_t* val) {
   if (!val) return false;
 
   return ReadBytes(reinterpret_cast<char*>(val), 1);
 }
 
-bool ByteBuffer::ReadUInt16(uint16* val) {
+bool ByteBuffer::ReadUInt16(uint16_t* val) {
   if (!val) return false;
 
-  uint16 v;
+  uint16_t v;
   if (!ReadBytes(reinterpret_cast<char*>(&v), 2)) {
     return false;
   } else {
     *val = (byte_order_ == ORDER_NETWORK) ? NetworkToHost16(v) : v;
     return true;
   }
 }
 
-bool ByteBuffer::ReadUInt24(uint32* val) {
+bool ByteBuffer::ReadUInt24(uint32_t* val) {
   if (!val) return false;
 
-  uint32 v = 0;
+  uint32_t v = 0;
   char* read_into = reinterpret_cast<char*>(&v);
   if (byte_order_ == ORDER_NETWORK || IsHostBigEndian()) {
     ++read_into;
   }
 
   if (!ReadBytes(read_into, 3)) {
     return false;
   } else {
     *val = (byte_order_ == ORDER_NETWORK) ? NetworkToHost32(v) : v;
     return true;
   }
 }
 
-bool ByteBuffer::ReadUInt32(uint32* val) {
+bool ByteBuffer::ReadUInt32(uint32_t* val) {
   if (!val) return false;
 
-  uint32 v;
+  uint32_t v;
   if (!ReadBytes(reinterpret_cast<char*>(&v), 4)) {
     return false;
   } else {
     *val = (byte_order_ == ORDER_NETWORK) ? NetworkToHost32(v) : v;
     return true;
   }
 }
 
-bool ByteBuffer::ReadUInt64(uint64* val) {
+bool ByteBuffer::ReadUInt64(uint64_t* val) {
   if (!val) return false;
 
-  uint64 v;
+  uint64_t v;
   if (!ReadBytes(reinterpret_cast<char*>(&v), 8)) {
     return false;
   } else {
     *val = (byte_order_ == ORDER_NETWORK) ? NetworkToHost64(v) : v;
     return true;
   }
 }
 
 bool ByteBuffer::ReadString(std::string* val, size_t len) {
   if (!val) return false;
@@ skipping 10 matching lines @@
 bool ByteBuffer::ReadBytes(char* val, size_t len) {
   if (len > Length()) {
     return false;
   } else {
     memcpy(val, bytes_ + start_, len);
     start_ += len;
     return true;
   }
 }
 
-void ByteBuffer::WriteUInt8(uint8 val) {
+void ByteBuffer::WriteUInt8(uint8_t val) {
   WriteBytes(reinterpret_cast<const char*>(&val), 1);
 }
 
-void ByteBuffer::WriteUInt16(uint16 val) {
-  uint16 v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork16(val) : val;
+void ByteBuffer::WriteUInt16(uint16_t val) {
+  uint16_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork16(val) : val;
   WriteBytes(reinterpret_cast<const char*>(&v), 2);
 }
 
-void ByteBuffer::WriteUInt24(uint32 val) {
-  uint32 v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
+void ByteBuffer::WriteUInt24(uint32_t val) {
+  uint32_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
   char* start = reinterpret_cast<char*>(&v);
   if (byte_order_ == ORDER_NETWORK || IsHostBigEndian()) {
     ++start;
   }
   WriteBytes(start, 3);
 }
 
-void ByteBuffer::WriteUInt32(uint32 val) {
-  uint32 v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
+void ByteBuffer::WriteUInt32(uint32_t val) {
+  uint32_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork32(val) : val;
   WriteBytes(reinterpret_cast<const char*>(&v), 4);
 }
 
-void ByteBuffer::WriteUInt64(uint64 val) {
-  uint64 v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork64(val) : val;
+void ByteBuffer::WriteUInt64(uint64_t val) {
+  uint64_t v = (byte_order_ == ORDER_NETWORK) ? HostToNetwork64(val) : val;
   WriteBytes(reinterpret_cast<const char*>(&v), 8);
 }
 
 void ByteBuffer::WriteString(const std::string& val) {
   WriteBytes(val.c_str(), val.size());
 }
 
 void ByteBuffer::WriteBytes(const char* val, size_t len) {
   memcpy(ReserveWriteBuffer(len), val, len);
 }
@@ skipping 44 matching lines @@
   return true;
 }
 
 void ByteBuffer::Clear() {
   memset(bytes_, 0, size_);
   start_ = end_ = 0;
   ++version_;
 }
 
 }  // namespace rtc