commit 07e22e6a16ed7247a38bef451002b2331e1c6233
author Peter Boström <pbos@webrtc.org> Wed Oct 07 10:23:21 2015
committer Peter Boström <pbos@webrtc.org> Wed Oct 07 10:23:32 2015
tree 2c0e6d1ffeb1c5e5660a67198daa2c13e8fd43a2
parent f8533e86cbecf89ba1075840fcd431f7a38d2446

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

Removes the use of uint8, etc. in favor of uint8_t.

BUG=webrtc:5024
R=henrik.lundin@webrtc.org, henrikg@webrtc.org, perkj@webrtc.org, solenberg@webrtc.org, stefan@webrtc.org, tina.legrand@webrtc.org

Review URL: https://codereview.webrtc.org/1362503003 .

Cr-Original-Commit-Position: refs/heads/master@{#10196}
Cr-Mirrored-From: https://chromium.googlesource.com/external/webrtc
Cr-Mirrored-Commit: 0c4e06b4c6107a1b94f764e279e4fb4161e905b0

base/timeutils.cc

diff --git a/base/timeutils.cc b/base/timeutils.cc
index ffaf326..fac5b66 100644
--- a/base/timeutils.cc
+++ b/base/timeutils.cc
@@ -32,10 +32,10 @@
 
 namespace rtc {
 
-const uint32 HALF = 0x80000000;
+const uint32_t HALF = 0x80000000;
 
-uint64 TimeNanos() {
-  int64 ticks = 0;
+uint64_t TimeNanos() {
+  int64_t ticks = 0;
 #if defined(WEBRTC_MAC)
   static mach_timebase_info_data_t timebase;
   if (timebase.denom == 0) {
@@ -52,11 +52,11 @@
   // TODO: Do we need to handle the case when CLOCK_MONOTONIC
   // is not supported?
   clock_gettime(CLOCK_MONOTONIC, &ts);
-  ticks = kNumNanosecsPerSec * static_cast<int64>(ts.tv_sec) +
-      static_cast<int64>(ts.tv_nsec);
+  ticks = kNumNanosecsPerSec * static_cast<int64_t>(ts.tv_sec) +
+          static_cast<int64_t>(ts.tv_nsec);
 #elif defined(WEBRTC_WIN)
   static volatile LONG last_timegettime = 0;
-  static volatile int64 num_wrap_timegettime = 0;
+  static volatile int64_t num_wrap_timegettime = 0;
   volatile LONG* last_timegettime_ptr = &last_timegettime;
   DWORD now = timeGetTime();
   // Atomically update the last gotten time
@@ -78,16 +78,16 @@
   return ticks;
 }
 
-uint32 Time() {
-  return static_cast<uint32>(TimeNanos() / kNumNanosecsPerMillisec);
+uint32_t Time() {
+  return static_cast<uint32_t>(TimeNanos() / kNumNanosecsPerMillisec);
 }
 
-uint64 TimeMicros() {
-  return static_cast<uint64>(TimeNanos() / kNumNanosecsPerMicrosec);
+uint64_t TimeMicros() {
+  return static_cast<uint64_t>(TimeNanos() / kNumNanosecsPerMicrosec);
 }
 
 #if defined(WEBRTC_WIN)
-static const uint64 kFileTimeToUnixTimeEpochOffset = 116444736000000000ULL;
+static const uint64_t kFileTimeToUnixTimeEpochOffset = 116444736000000000ULL;
 
 struct timeval {
   long tv_sec, tv_usec;  // NOLINT
@@ -105,7 +105,7 @@
   li.HighPart = ft.dwHighDateTime;
 
   // Convert to seconds and microseconds since Unix time Epoch.
-  int64 micros = (li.QuadPart - kFileTimeToUnixTimeEpochOffset) / 10;
+  int64_t micros = (li.QuadPart - kFileTimeToUnixTimeEpochOffset) / 10;
   tv->tv_sec = static_cast<long>(micros / kNumMicrosecsPerSec);  // NOLINT
   tv->tv_usec = static_cast<long>(micros % kNumMicrosecsPerSec); // NOLINT
 
@@ -135,13 +135,13 @@
   *microseconds = timeval.tv_usec;
 }
 
-uint32 TimeAfter(int32 elapsed) {
+uint32_t TimeAfter(int32_t elapsed) {
   RTC_DCHECK_GE(elapsed, 0);
-  RTC_DCHECK_LT(static_cast<uint32>(elapsed), HALF);
+  RTC_DCHECK_LT(static_cast<uint32_t>(elapsed), HALF);
   return Time() + elapsed;
 }
 
-bool TimeIsBetween(uint32 earlier, uint32 middle, uint32 later) {
+bool TimeIsBetween(uint32_t earlier, uint32_t middle, uint32_t later) {
   if (earlier <= later) {
     return ((earlier <= middle) && (middle <= later));
   } else {
@@ -149,27 +149,27 @@
   }
 }
 
-bool TimeIsLaterOrEqual(uint32 earlier, uint32 later) {
+bool TimeIsLaterOrEqual(uint32_t earlier, uint32_t later) {
 #if EFFICIENT_IMPLEMENTATION
-  int32 diff = later - earlier;
-  return (diff >= 0 && static_cast<uint32>(diff) < HALF);
+  int32_t diff = later - earlier;
+  return (diff >= 0 && static_cast<uint32_t>(diff) < HALF);
 #else
   const bool later_or_equal = TimeIsBetween(earlier, later, earlier + HALF);
   return later_or_equal;
 #endif
 }
 
-bool TimeIsLater(uint32 earlier, uint32 later) {
+bool TimeIsLater(uint32_t earlier, uint32_t later) {
 #if EFFICIENT_IMPLEMENTATION
-  int32 diff = later - earlier;
-  return (diff > 0 && static_cast<uint32>(diff) < HALF);
+  int32_t diff = later - earlier;
+  return (diff > 0 && static_cast<uint32_t>(diff) < HALF);
 #else
   const bool earlier_or_equal = TimeIsBetween(later, earlier, later + HALF);
   return !earlier_or_equal;
 #endif
 }
 
-int32 TimeDiff(uint32 later, uint32 earlier) {
+int32_t TimeDiff(uint32_t later, uint32_t earlier) {
 #if EFFICIENT_IMPLEMENTATION
   return later - earlier;
 #else
@@ -193,7 +193,7 @@
 TimestampWrapAroundHandler::TimestampWrapAroundHandler()
     : last_ts_(0), num_wrap_(0) {}
 
-int64 TimestampWrapAroundHandler::Unwrap(uint32 ts) {
+int64_t TimestampWrapAroundHandler::Unwrap(uint32_t ts) {
   if (ts < last_ts_) {
     if (last_ts_ > 0xf0000000 && ts < 0x0fffffff) {
       ++num_wrap_;