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

webrtc/base/logging.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 100 matching lines @@
 
 // Boolean options default to false (0)
 bool LogMessage::thread_, LogMessage::timestamp_;
 
 LogMessage::LogMessage(const char* file, int line, LoggingSeverity sev,
                        LogErrorContext err_ctx, int err, const char* module)
     : severity_(sev),
       tag_(kLibjingle),
       warn_slow_logs_delay_(WARN_SLOW_LOGS_DELAY) {
   if (timestamp_) {
-    uint32 time = TimeSince(LogStartTime());
+    uint32_t time = TimeSince(LogStartTime());
     // Also ensure WallClockStartTime is initialized, so that it matches
     // LogStartTime.
     WallClockStartTime();
     print_stream_ << "[" << std::setfill('0') << std::setw(3) << (time / 1000)
                   << ":" << std::setw(3) << (time % 1000) << std::setfill(' ')
                   << "] ";
   }
 
   if (thread_) {
     PlatformThreadId id = CurrentThreadId();
@@ skipping 58 matching lines @@
 LogMessage::~LogMessage() {
   if (!extra_.empty())
     print_stream_ << " : " << extra_;
   print_stream_ << std::endl;
 
   const std::string& str = print_stream_.str();
   if (severity_ >= dbg_sev_) {
     OutputToDebug(str, severity_, tag_);
   }
 
-  uint32 before = Time();
+  uint32_t before = Time();
   // Must lock streams_ before accessing
   CritScope cs(&crit_);
   for (StreamList::iterator it = streams_.begin(); it != streams_.end(); ++it) {
     if (severity_ >= it->second) {
       it->first->OnLogMessage(str);
     }
   }
-  uint32 delay = TimeSince(before);
+  uint32_t delay = TimeSince(before);
   if (delay >= warn_slow_logs_delay_) {
     rtc::LogMessage slow_log_warning(__FILE__, __LINE__, LS_WARNING);
     // If our warning is slow, we don't want to warn about it, because
     // that would lead to inifinite recursion.  So, give a really big
     // number for the delay threshold.
     slow_log_warning.warn_slow_logs_delay_ = UINT_MAX;
     slow_log_warning.stream() << "Slow log: took " << delay << "ms to write "
                               << str.size() << " bytes.";
   }
 }
 
-uint32 LogMessage::LogStartTime() {
-  static const uint32 g_start = Time();
+uint32_t LogMessage::LogStartTime() {
+  static const uint32_t g_start = Time();
   return g_start;
 }
 
-uint32 LogMessage::WallClockStartTime() {
-  static const uint32 g_start_wallclock = time(NULL);
+uint32_t LogMessage::WallClockStartTime() {
+  static const uint32_t g_start_wallclock = time(NULL);
   return g_start_wallclock;
 }
 
 void LogMessage::LogThreads(bool on) {
   thread_ = on;
 }
 
 void LogMessage::LogTimestamps(bool on) {
   timestamp_ = on;
 }
@@ skipping 317 matching lines @@
   }
 
   if (state) {
     state->unprintable_count_[input] = consecutive_unprintable;
   }
 }
 
 //////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc