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.
  */
 
 #include "webrtc/base/helpers.h"
 
 #include <limits>
 
 #if defined(FEATURE_ENABLE_SSL)
 #include "webrtc/base/sslconfig.h"
 #if defined(SSL_USE_OPENSSL)
 #include <openssl/rand.h>
 #elif defined(SSL_USE_NSS_RNG)
-// Hack: Define+undefine int64 and uint64 to avoid typedef conflict with NSS.
+// Hack: Define+undefine int64_t and uint64_t to avoid typedef conflict with
+// NSS.
 // TODO(kjellander): Remove when webrtc:4497 is completed.
-#define uint64 foo_uint64
-#define int64 foo_int64
+#define uint64_t foo_uint64
+#define int64_t foo_int64
 #include "pk11func.h"
-#undef uint64
-#undef int64
+#undef uint64_t
+#undef int64_t
 #else
 #if defined(WEBRTC_WIN)
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <ntsecapi.h>
 #endif  // WEBRTC_WIN
 #endif  // else
 #endif  // FEATURE_ENABLED_SSL
 
 #include "webrtc/base/base64.h"
@@ skipping 116 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