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

talk/app/webrtc/test/fakeaudiocapturemodule.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 22 matching lines @@
 #include "webrtc/base/timeutils.h"
 
 // Audio sample value that is high enough that it doesn't occur naturally when
 // frames are being faked. E.g. NetEq will not generate this large sample value
 // unless it has received an audio frame containing a sample of this value.
 // Even simpler buffers would likely just contain audio sample values of 0.
 static const int kHighSampleValue = 10000;
 
 // Same value as src/modules/audio_device/main/source/audio_device_config.h in
 // https://code.google.com/p/webrtc/
-static const uint32 kAdmMaxIdleTimeProcess = 1000;
+static const uint32_t kAdmMaxIdleTimeProcess = 1000;
 
 // Constants here are derived by running VoE using a real ADM.
 // The constants correspond to 10ms of mono audio at 44kHz.
 static const int kTimePerFrameMs = 10;
 static const uint8_t kNumberOfChannels = 1;
 static const int kSamplesPerSecond = 44000;
 static const int kTotalDelayMs = 0;
 static const int kClockDriftMs = 0;
 static const uint32_t kMaxVolume = 14392;
 
@@ skipping 29 matching lines @@
   }
   return capture_module;
 }
 
 int FakeAudioCaptureModule::frames_received() const {
   rtc::CritScope cs(&crit_);
   return frames_received_;
 }
 
 int64_t FakeAudioCaptureModule::TimeUntilNextProcess() {
-  const uint32 current_time = rtc::Time();
+  const uint32_t current_time = rtc::Time();
   if (current_time < last_process_time_ms_) {
     // TODO: wraparound could be handled more gracefully.
     return 0;
   }
-  const uint32 elapsed_time = current_time - last_process_time_ms_;
+  const uint32_t elapsed_time = current_time - last_process_time_ms_;
   if (kAdmMaxIdleTimeProcess < elapsed_time) {
     return 0;
   }
   return kAdmMaxIdleTimeProcess - elapsed_time;
 }
 
 int32_t FakeAudioCaptureModule::Process() {
   last_process_time_ms_ = rtc::Time();
   return 0;
 }
@@ skipping 568 matching lines @@
     // Receive and send frames every kTimePerFrameMs.
     if (playing_) {
       ReceiveFrameP();
     }
     if (recording_) {
       SendFrameP();
     }
   }
 
   next_frame_time_ += kTimePerFrameMs;
-  const uint32 current_time = rtc::Time();
-  const uint32 wait_time = (next_frame_time_ > current_time) ?
-      next_frame_time_ - current_time : 0;
+  const uint32_t current_time = rtc::Time();
+  const uint32_t wait_time =
+      (next_frame_time_ > current_time) ? next_frame_time_ - current_time : 0;
   process_thread_->PostDelayed(wait_time, this, MSG_RUN_PROCESS);
 }
 
 void FakeAudioCaptureModule::ReceiveFrameP() {
   ASSERT(process_thread_->IsCurrent());
   {
     rtc::CritScope cs(&crit_callback_);
     if (!audio_callback_) {
       return;
     }
@@ skipping 35 matching lines @@
                                               kNumberOfChannels,
                                               kSamplesPerSecond, kTotalDelayMs,
                                               kClockDriftMs, current_mic_level,
                                               key_pressed,
                                               current_mic_level) != 0) {
     ASSERT(false);
   }
   SetMicrophoneVolume(current_mic_level);
 }