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

webrtc/base/helpers.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 134 matching lines @@
 // A test random generator, for predictable output.
 class TestRandomGenerator : public RandomGenerator {
  public:
   TestRandomGenerator() : seed_(7) {
   }
   ~TestRandomGenerator() override {
   }
   bool Init(const void* seed, size_t len) override { return true; }
   bool Generate(void* buf, size_t len) override {
     for (size_t i = 0; i < len; ++i) {
-      static_cast<uint8*>(buf)[i] = static_cast<uint8>(GetRandom());
+      static_cast<uint8_t*>(buf)[i] = static_cast<uint8_t>(GetRandom());
     }
     return true;
   }
 
  private:
   int GetRandom() {
     return ((seed_ = seed_ * 214013L + 2531011L) >> 16) & 0x7fff;
   }
   int seed_;
 };
@@ skipping 46 matching lines @@
 std::string CreateRandomString(size_t len) {
   std::string str;
   CreateRandomString(len, &str);
   return str;
 }
 
 bool CreateRandomString(size_t len,
                         const char* table, int table_size,
                         std::string* str) {
   str->clear();
-  scoped_ptr<uint8[]> bytes(new uint8[len]);
+  scoped_ptr<uint8_t[]> bytes(new uint8_t[len]);
   if (!Rng().Generate(bytes.get(), len)) {
     LOG(LS_ERROR) << "Failed to generate random string!";
     return false;
   }
   str->reserve(len);
   for (size_t i = 0; i < len; ++i) {
     str->push_back(table[bytes[i] % table_size]);
   }
   return true;
 }
 
 bool CreateRandomString(size_t len, std::string* str) {
   return CreateRandomString(len, BASE64, 64, str);
 }
 
 bool CreateRandomString(size_t len, const std::string& table,
                         std::string* str) {
   return CreateRandomString(len, table.c_str(),
                             static_cast<int>(table.size()), str);
 }
 
-uint32 CreateRandomId() {
-  uint32 id;
+uint32_t CreateRandomId() {
+  uint32_t id;
   if (!Rng().Generate(&id, sizeof(id))) {
     LOG(LS_ERROR) << "Failed to generate random id!";
   }
   return id;
 }
 
-uint64 CreateRandomId64() {
-  return static_cast<uint64>(CreateRandomId()) << 32 | CreateRandomId();
+uint64_t CreateRandomId64() {
+  return static_cast<uint64_t>(CreateRandomId()) << 32 | CreateRandomId();
 }
 
-uint32 CreateRandomNonZeroId() {
-  uint32 id;
+uint32_t CreateRandomNonZeroId() {
+  uint32_t id;
   do {
     id = CreateRandomId();
   } while (id == 0);
   return id;
 }
 
 double CreateRandomDouble() {
-  return CreateRandomId() / (std::numeric_limits<uint32>::max() +
-      std::numeric_limits<double>::epsilon());
+  return CreateRandomId() / (std::numeric_limits<uint32_t>::max() +
+                             std::numeric_limits<double>::epsilon());
 }
 
 }  // namespace rtc