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

webrtc/base/logging.h

 /*
  *  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 113 matching lines @@
 // Virtual sink interface that can receive log messages.
 class LogSink {
  public:
   LogSink() {}
   virtual ~LogSink() {}
   virtual void OnLogMessage(const std::string& message) = 0;
 };
 
 class LogMessage {
  public:
-  static const uint32 WARN_SLOW_LOGS_DELAY = 50;  // ms
+  static const uint32_t WARN_SLOW_LOGS_DELAY = 50;  // ms
 
   LogMessage(const char* file, int line, LoggingSeverity sev,
              LogErrorContext err_ctx = ERRCTX_NONE, int err = 0,
              const char* module = NULL);
 
   LogMessage(const char* file,
              int line,
              LoggingSeverity sev,
              const std::string& tag);
 
   ~LogMessage();
 
   static inline bool Loggable(LoggingSeverity sev) { return (sev >= min_sev_); }
   std::ostream& stream() { return print_stream_; }
 
   // Returns the time at which this function was called for the first time.
   // The time will be used as the logging start time.
   // If this is not called externally, the LogMessage ctor also calls it, in
   // which case the logging start time will be the time of the first LogMessage
   // instance is created.
-  static uint32 LogStartTime();
+  static uint32_t LogStartTime();
 
   // Returns the wall clock equivalent of |LogStartTime|, in seconds from the
   // epoch.
-  static uint32 WallClockStartTime();
+  static uint32_t WallClockStartTime();
 
   //  LogThreads: Display the thread identifier of the current thread
   static void LogThreads(bool on = true);
 
   //  LogTimestamps: Display the elapsed time of the program
   static void LogTimestamps(bool on = true);
 
   // These are the available logging channels
   //  Debug: Debug console on Windows, otherwise stderr
   static void LogToDebug(LoggingSeverity min_sev);
@@ skipping 41 matching lines @@
 
   // The Android debug output tag.
   std::string tag_;
 
   // String data generated in the constructor, that should be appended to
   // the message before output.
   std::string extra_;
 
   // If time it takes to write to stream is more than this, log one
   // additional warning about it.
-  uint32 warn_slow_logs_delay_;
+  uint32_t warn_slow_logs_delay_;
 
   // Global lock for the logging subsystem
   static CriticalSection crit_;
 
   // dbg_sev_ is the thresholds for those output targets
   // min_sev_ is the minimum (most verbose) of those levels, and is used
   //  as a short-circuit in the logging macros to identify messages that won't
   //  be logged.
   // ctx_sev_ is the minimum level at which file context is displayed
   static LoggingSeverity min_sev_, dbg_sev_, ctx_sev_;
@@ skipping 127 matching lines @@
 #define PLOG(sev, err) \
   LOG_ERR_EX(sev, err)
 
 // TODO(?): Add an "assert" wrapper that logs in the same manner.
 
 #endif  // LOG
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_LOGGING_H_