WebRtc_Word32 -> int32_t in system_wrappers

BUG=314

Review URL: https://webrtc-codereview.appspot.com/1301004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@3791 4adac7df-926f-26a2-2b94-8c16560cd09d

17 files changed, 237 insertions, 246 deletions

diff --git a/webrtc/system_wrappers/source/atomic32_mac.cc b/webrtc/system_wrappers/source/atomic32_mac.cc
index d816e19b39..9c350581fa 100644
--- a/webrtc/system_wrappers/source/atomic32_mac.cc
+++ b/webrtc/system_wrappers/source/atomic32_mac.cc
@@ -18,7 +18,7 @@
 
 namespace webrtc {
 
-Atomic32::Atomic32(WebRtc_Word32 initial_value)
+Atomic32::Atomic32(int32_t initial_value)
     : value_(initial_value) {
   assert(Is32bitAligned());
 }
@@ -26,28 +26,27 @@ Atomic32::Atomic32(WebRtc_Word32 initial_value)
 Atomic32::~Atomic32() {
 }
 
-WebRtc_Word32 Atomic32::operator++() {
+int32_t Atomic32::operator++() {
   return OSAtomicIncrement32Barrier(&value_);
 }
 
-WebRtc_Word32 Atomic32::operator--() {
+int32_t Atomic32::operator--() {
   return OSAtomicDecrement32Barrier(&value_);
 }
 
-WebRtc_Word32 Atomic32::operator+=(WebRtc_Word32 value) {
+int32_t Atomic32::operator+=(int32_t value) {
   return OSAtomicAdd32Barrier(value, &value_);
 }
 
-WebRtc_Word32 Atomic32::operator-=(WebRtc_Word32 value) {
+int32_t Atomic32::operator-=(int32_t value) {
   return OSAtomicAdd32Barrier(-value, &value_);
 }
 
-bool Atomic32::CompareExchange(WebRtc_Word32 new_value,
-                               WebRtc_Word32 compare_value) {
+bool Atomic32::CompareExchange(int32_t new_value, int32_t compare_value) {
   return OSAtomicCompareAndSwap32Barrier(compare_value, new_value, &value_);
 }
 
-WebRtc_Word32 Atomic32::Value() const {
+int32_t Atomic32::Value() const {
   return value_;
 }
 
diff --git a/webrtc/system_wrappers/source/atomic32_posix.cc b/webrtc/system_wrappers/source/atomic32_posix.cc
index 8a52617efe..ebfe19fe54 100644
--- a/webrtc/system_wrappers/source/atomic32_posix.cc
+++ b/webrtc/system_wrappers/source/atomic32_posix.cc
@@ -18,7 +18,7 @@
 
 namespace webrtc {
 
-Atomic32::Atomic32(WebRtc_Word32 initial_value)
+Atomic32::Atomic32(int32_t initial_value)
     : value_(initial_value) {
   assert(Is32bitAligned());
 }
@@ -26,32 +26,31 @@ Atomic32::Atomic32(WebRtc_Word32 initial_value)
 Atomic32::~Atomic32() {
 }
 
-WebRtc_Word32 Atomic32::operator++() {
+int32_t Atomic32::operator++() {
   return __sync_fetch_and_add(&value_, 1) + 1;
 }
 
-WebRtc_Word32 Atomic32::operator--() {
+int32_t Atomic32::operator--() {
   return __sync_fetch_and_sub(&value_, 1) - 1;
 }
 
-WebRtc_Word32 Atomic32::operator+=(WebRtc_Word32 value) {
-  WebRtc_Word32 return_value = __sync_fetch_and_add(&value_, value);
+int32_t Atomic32::operator+=(int32_t value) {
+  int32_t return_value = __sync_fetch_and_add(&value_, value);
   return_value += value;
   return return_value;
 }
 
-WebRtc_Word32 Atomic32::operator-=(WebRtc_Word32 value) {
-  WebRtc_Word32 return_value = __sync_fetch_and_sub(&value_, value);
+int32_t Atomic32::operator-=(int32_t value) {
+  int32_t return_value = __sync_fetch_and_sub(&value_, value);
   return_value -= value;
   return return_value;
 }
 
-bool Atomic32::CompareExchange(WebRtc_Word32 new_value,
-                               WebRtc_Word32 compare_value) {
+bool Atomic32::CompareExchange(int32_t new_value, int32_t compare_value) {
   return __sync_bool_compare_and_swap(&value_, compare_value, new_value);
 }
 
-WebRtc_Word32 Atomic32::Value() const {
+int32_t Atomic32::Value() const {
   return value_;
 }
 
diff --git a/webrtc/system_wrappers/source/atomic32_win.cc b/webrtc/system_wrappers/source/atomic32_win.cc
index db16bbd919..dd61035003 100644
--- a/webrtc/system_wrappers/source/atomic32_win.cc
+++ b/webrtc/system_wrappers/source/atomic32_win.cc
@@ -18,7 +18,7 @@
 
 namespace webrtc {
 
-Atomic32::Atomic32(WebRtc_Word32 initial_value)
+Atomic32::Atomic32(int32_t initial_value)
     : value_(initial_value) {
   // Make sure that the counter variable we're using is of the same size
   // as what the API expects.
@@ -29,28 +29,27 @@ Atomic32::Atomic32(WebRtc_Word32 initial_value)
 Atomic32::~Atomic32() {
 }
 
-WebRtc_Word32 Atomic32::operator++() {
-  return static_cast<WebRtc_Word32>(InterlockedIncrement(
+int32_t Atomic32::operator++() {
+  return static_cast<int32_t>(InterlockedIncrement(
       reinterpret_cast<volatile LONG*>(&value_)));
 }
 
-WebRtc_Word32 Atomic32::operator--() {
-  return static_cast<WebRtc_Word32>(InterlockedDecrement(
+int32_t Atomic32::operator--() {
+  return static_cast<int32_t>(InterlockedDecrement(
       reinterpret_cast<volatile LONG*>(&value_)));
 }
 
-WebRtc_Word32 Atomic32::operator+=(WebRtc_Word32 value) {
+int32_t Atomic32::operator+=(int32_t value) {
   return InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(&value_),
                                 value);
 }
 
-WebRtc_Word32 Atomic32::operator-=(WebRtc_Word32 value) {
+int32_t Atomic32::operator-=(int32_t value) {
   return InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(&value_),
                                 -value);
 }
 
-bool Atomic32::CompareExchange(WebRtc_Word32 new_value,
-                               WebRtc_Word32 compare_value) {
+bool Atomic32::CompareExchange(int32_t new_value, int32_t compare_value) {
   const LONG old_value = InterlockedCompareExchange(
       reinterpret_cast<volatile LONG*>(&value_),
       new_value,
@@ -60,7 +59,7 @@ bool Atomic32::CompareExchange(WebRtc_Word32 new_value,
   return (old_value == compare_value);
 }
 
-WebRtc_Word32 Atomic32::Value() const {
+int32_t Atomic32::Value() const {
   return value_;
 }
 
diff --git a/webrtc/system_wrappers/source/clock.cc b/webrtc/system_wrappers/source/clock.cc
index 5fd7e7ebfa..8085e56d42 100644
--- a/webrtc/system_wrappers/source/clock.cc
+++ b/webrtc/system_wrappers/source/clock.cc
@@ -140,24 +140,24 @@ class WindowsRealTimeClock : public RealTimeClock {
 
   // Retrieve an NTP absolute timestamp.
   virtual void CurrentNtp(uint32_t& seconds, uint32_t& fractions) {
-    const WebRtc_UWord64 FILETIME_1970 = 0x019db1ded53e8000;
+    const uint64_t FILETIME_1970 = 0x019db1ded53e8000;
 
     FILETIME StartTime;
-    WebRtc_UWord64 Time;
+    uint64_t Time;
     struct timeval tv;
 
     // We can't use query performance counter since they can change depending on
     // speed steping
     get_time(_helpTimer, StartTime);
 
-    Time = (((WebRtc_UWord64) StartTime.dwHighDateTime) << 32) +
-           (WebRtc_UWord64) StartTime.dwLowDateTime;
+    Time = (((uint64_t) StartTime.dwHighDateTime) << 32) +
+           (uint64_t) StartTime.dwLowDateTime;
 
     // Convert the hecto-nano second time to tv format
     Time -= FILETIME_1970;
 
-    tv.tv_sec = (WebRtc_UWord32)(Time / (WebRtc_UWord64)10000000);
-    tv.tv_usec = (WebRtc_UWord32)((Time % (WebRtc_UWord64)10000000) / 10);
+    tv.tv_sec = (uint32_t)(Time / (uint64_t)10000000);
+    tv.tv_usec = (uint32_t)((Time % (uint64_t)10000000) / 10);
 
     double dtemp;
 
@@ -172,7 +172,7 @@ class WindowsRealTimeClock : public RealTimeClock {
       seconds--;
     }
     dtemp *= kMagicNtpFractionalUnit;
-    fractions = (WebRtc_UWord32)dtemp;
+    fractions = (uint32_t)dtemp;
   }
 
  private:
@@ -205,7 +205,7 @@ class UnixRealTimeClock : public RealTimeClock {
       seconds--;
     }
     dtemp *= kMagicNtpFractionalUnit;
-    fractions = (WebRtc_UWord32)dtemp;
+    fractions = (uint32_t)dtemp;
   }
 };
 #endif
diff --git a/webrtc/system_wrappers/source/condition_variable_unittest.cc b/webrtc/system_wrappers/source/condition_variable_unittest.cc
index be3bfc6eda..08491fe5f5 100644
--- a/webrtc/system_wrappers/source/condition_variable_unittest.cc
+++ b/webrtc/system_wrappers/source/condition_variable_unittest.cc
@@ -50,7 +50,7 @@ class Baton {
   // Pass the baton. Returns false if baton is not picked up in |max_msecs|.
   // Only one process can pass at the same time; this property is
   // ensured by the |giver_sect_| lock.
-  bool Pass(WebRtc_UWord32 max_msecs) {
+  bool Pass(uint32_t max_msecs) {
     CriticalSectionScoped cs_giver(giver_sect_);
     CriticalSectionScoped cs(crit_sect_);
     SignalBatonAvailable();
@@ -62,7 +62,7 @@ class Baton {
   }
 
   // Grab the baton. Returns false if baton is not passed.
-  bool Grab(WebRtc_UWord32 max_msecs) {
+  bool Grab(uint32_t max_msecs) {
     CriticalSectionScoped cs(crit_sect_);
     return WaitUntilBatonOffered(max_msecs);
   }
diff --git a/webrtc/system_wrappers/source/cpu_info.cc b/webrtc/system_wrappers/source/cpu_info.cc
index 514f41f025..d858ad54ca 100644
--- a/webrtc/system_wrappers/source/cpu_info.cc
+++ b/webrtc/system_wrappers/source/cpu_info.cc
@@ -26,14 +26,14 @@
 
 namespace webrtc {
 
-WebRtc_UWord32 CpuInfo::number_of_cores_ = 0;
+uint32_t CpuInfo::number_of_cores_ = 0;
 
-WebRtc_UWord32 CpuInfo::DetectNumberOfCores() {
+uint32_t CpuInfo::DetectNumberOfCores() {
   if (!number_of_cores_) {
 #if defined(_WIN32)
     SYSTEM_INFO si;
     GetSystemInfo(&si);
-    number_of_cores_ = static_cast<WebRtc_UWord32>(si.dwNumberOfProcessors);
+    number_of_cores_ = static_cast<uint32_t>(si.dwNumberOfProcessors);
     WEBRTC_TRACE(kTraceStateInfo, kTraceUtility, -1,
                  "Available number of cores:%d", number_of_cores_);
 
@@ -47,7 +47,7 @@ WebRtc_UWord32 CpuInfo::DetectNumberOfCores() {
     int ncpu;
     size_t size = sizeof(ncpu);
     if (0 == sysctl(name, 2, &ncpu, &size, NULL, 0)) {
-      number_of_cores_ = static_cast<WebRtc_UWord32>(ncpu);
+      number_of_cores_ = static_cast<uint32_t>(ncpu);
       WEBRTC_TRACE(kTraceStateInfo, kTraceUtility, -1,
                    "Available number of cores:%d", number_of_cores_);
     } else {
diff --git a/webrtc/system_wrappers/source/data_log_unittest.cc b/webrtc/system_wrappers/source/data_log_unittest.cc
index ddd00360f7..fd61e7921d 100644
--- a/webrtc/system_wrappers/source/data_log_unittest.cc
+++ b/webrtc/system_wrappers/source/data_log_unittest.cc
@@ -133,12 +133,12 @@ TEST(TestDataLog, VerifySingleTable) {
   DataLog::AddColumn(DataLog::Combine("table", 1), "arrival", 1);
   DataLog::AddColumn(DataLog::Combine("table", 1), "timestamp", 1);
   DataLog::AddColumn(DataLog::Combine("table", 1), "size", 5);
-  WebRtc_UWord32 sizes[5] = {1400, 1500, 1600, 1700, 1800};
+  uint32_t sizes[5] = {1400, 1500, 1600, 1700, 1800};
   for (int i = 0; i < 10; ++i) {
     DataLog::InsertCell(DataLog::Combine("table", 1), "arrival",
                         static_cast<double>(i));
     DataLog::InsertCell(DataLog::Combine("table", 1), "timestamp",
-                        static_cast<WebRtc_Word64>(4354 + i));
+                        static_cast<int64_t>(4354 + i));
     DataLog::InsertCell(DataLog::Combine("table", 1), "size", sizes, 5);
     DataLog::NextRow(DataLog::Combine("table", 1));
   }
@@ -188,19 +188,19 @@ TEST(TestDataLog, VerifyMultipleTables) {
   DataLog::AddColumn(DataLog::Combine("table", 3), "timestamp", 1);
   DataLog::AddColumn(DataLog::Combine("table", 3), "arrival", 1);
   DataLog::AddColumn(DataLog::Combine("table", 4), "size", 1);
-  for (WebRtc_Word32 i = 0; i < 10; ++i) {
+  for (int32_t i = 0; i < 10; ++i) {
     DataLog::InsertCell(DataLog::Combine("table", 2), "arrival",
-                        static_cast<WebRtc_Word32>(i));
+                        static_cast<int32_t>(i));
     DataLog::InsertCell(DataLog::Combine("table", 2), "timestamp",
-                        static_cast<WebRtc_Word32>(4354 + i));
+                        static_cast<int32_t>(4354 + i));
     DataLog::InsertCell(DataLog::Combine("table", 2), "size",
-                        static_cast<WebRtc_Word32>(1200 + 10 * i));
+                        static_cast<int32_t>(1200 + 10 * i));
     DataLog::InsertCell(DataLog::Combine("table", 3), "timestamp",
-                        static_cast<WebRtc_Word32>(4354 + i));
+                        static_cast<int32_t>(4354 + i));
     DataLog::InsertCell(DataLog::Combine("table", 3), "arrival",
-                        static_cast<WebRtc_Word32>(i));
+                        static_cast<int32_t>(i));
     DataLog::InsertCell(DataLog::Combine("table", 4), "size",
-                        static_cast<WebRtc_Word32>(1200 + 10 * i));
+                        static_cast<int32_t>(1200 + 10 * i));
     DataLog::NextRow(DataLog::Combine("table", 4));
     DataLog::NextRow(DataLog::Combine("table", 2));
     DataLog::NextRow(DataLog::Combine("table", 3));
diff --git a/webrtc/system_wrappers/source/event_win.h b/webrtc/system_wrappers/source/event_win.h
index 5fec374646..55ed8ebb0c 100644
--- a/webrtc/system_wrappers/source/event_win.h
+++ b/webrtc/system_wrappers/source/event_win.h
@@ -33,7 +33,7 @@ class EventWindows : public EventWrapper {
 
  private:
   HANDLE  event_;
-  WebRtc_UWord32 timerID_;
+  uint32_t timerID_;
 };
 
 }  // namespace webrtc
diff --git a/webrtc/system_wrappers/source/sort.cc b/webrtc/system_wrappers/source/sort.cc
index 0bf8007276..4aa181fd29 100644
--- a/webrtc/system_wrappers/source/sort.cc
+++ b/webrtc/system_wrappers/source/sort.cc
@@ -59,7 +59,7 @@
 #define KEY_QSORT(SORT_KEY, KEY, NUM_OF_ELEMENTS, KEY_TYPE, COMPARE_FUNC)     \
   do {                                                                        \
     KEY_TYPE* key_type = (KEY_TYPE*)(key);                                    \
-    for (WebRtc_UWord32 i = 0; i < (NUM_OF_ELEMENTS); ++i) {                  \
+    for (uint32_t i = 0; i < (NUM_OF_ELEMENTS); ++i) {                  \
       ptr_sort_key[i].key_ = &key_type[i];                                    \
       ptr_sort_key[i].index_ = i;                                             \
     }                                                                         \
@@ -72,13 +72,13 @@ namespace webrtc {
 #ifdef NO_STL
 struct SortKey {
   void* key_;
-  WebRtc_UWord32 index_;
+  uint32_t index_;
 };
 #else
 template<typename KeyType>
 struct SortKey {
   KeyType key_;
-  WebRtc_UWord32 index_;
+  uint32_t index_;
 };
 #endif
 
@@ -86,35 +86,35 @@ namespace {  // Unnamed namespace provides internal linkage.
 
 #ifdef NO_STL
 int CompareWord8(const void* x, const void* y) {
-  COMPARE_FOR_QSORT(x, y, WebRtc_Word8);
+  COMPARE_FOR_QSORT(x, y, int8_t);
 }
 
 int CompareUWord8(const void* x, const void* y) {
-  COMPARE_FOR_QSORT(x, y, WebRtc_UWord8);
+  COMPARE_FOR_QSORT(x, y, uint8_t);
 }
 
 int CompareWord16(const void* x, const void* y) {
-  COMPARE_FOR_QSORT(x, y, WebRtc_Word16);
+  COMPARE_FOR_QSORT(x, y, int16_t);
 }
 
 int CompareUWord16(const void* x, const void* y) {
-  COMPARE_FOR_QSORT(x, y, WebRtc_UWord16);
+  COMPARE_FOR_QSORT(x, y, uint16_t);
 }
 
 int CompareWord32(const void* x, const void* y) {
-  COMPARE_FOR_QSORT(x, y, WebRtc_Word32);
+  COMPARE_FOR_QSORT(x, y, int32_t);
 }
 
 int CompareUWord32(const void* x, const void* y) {
-  COMPARE_FOR_QSORT(x, y, WebRtc_UWord32);
+  COMPARE_FOR_QSORT(x, y, uint32_t);
 }
 
 int CompareWord64(const void* x, const void* y) {
-  COMPARE_FOR_QSORT(x, y, WebRtc_Word64);
+  COMPARE_FOR_QSORT(x, y, int64_t);
 }
 
 int CompareUWord64(const void* x, const void* y) {
-  COMPARE_FOR_QSORT(x, y, WebRtc_UWord64);
+  COMPARE_FOR_QSORT(x, y, uint64_t);
 }
 
 int CompareFloat32(const void* x, const void* y) {
@@ -126,35 +126,35 @@ int CompareFloat64(const void* x, const void* y) {
 }
 
 int CompareKeyWord8(const void* sort_key_x, const void* sort_key_y) {
-  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_Word8);
+  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, int8_t);
 }
 
 int CompareKeyUWord8(const void* sort_key_x, const void* sort_key_y) {
-  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_UWord8);
+  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, uint8_t);
 }
 
 int CompareKeyWord16(const void* sort_key_x, const void* sort_key_y) {
-  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_Word16);
+  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, int16_t);
 }
 
 int CompareKeyUWord16(const void* sort_key_x, const void* sort_key_y) {
-  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_UWord16);
+  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, uint16_t);
 }
 
 int CompareKeyWord32(const void* sort_key_x, const void* sort_key_y) {
-  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_Word32);
+  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, int32_t);
 }
 
 int CompareKeyUWord32(const void* sort_key_x, const void* sort_key_y) {
-  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_UWord32);
+  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, uint32_t);
 }
 
 int CompareKeyWord64(const void* sort_key_x, const void* sort_key_y) {
-  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_Word64);
+  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, int64_t);
 }
 
 int CompareKeyUWord64(const void* sort_key_x, const void* sort_key_y) {
-  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_UWord64);
+  COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, uint64_t);
 }
 
 int CompareKeyFloat32(const void* sort_key_x, const void* sort_key_y) {
@@ -182,35 +182,35 @@ struct KeyRightShift {
 };
 
 template <typename DataType>
-inline void IntegerSort(void* data, WebRtc_UWord32 num_of_elements) {
+inline void IntegerSort(void* data, uint32_t num_of_elements) {
   DataType* data_type = static_cast<DataType*>(data);
   boost::integer_sort(data_type, data_type + num_of_elements);
 }
 
 template <typename DataType, typename IntegerType>
-inline void FloatSort(void* data, WebRtc_UWord32 num_of_elements) {
+inline void FloatSort(void* data, uint32_t num_of_elements) {
   DataType* data_type = static_cast<DataType*>(data);
   IntegerType c_val = 0;
   boost::float_sort_cast(data_type, data_type + num_of_elements, c_val);
 }
 
 template <typename DataType>
-inline void StdSort(void* data, WebRtc_UWord32 num_of_elements) {
+inline void StdSort(void* data, uint32_t num_of_elements) {
   DataType* data_type = static_cast<DataType*>(data);
   std::sort(data_type, data_type + num_of_elements);
 }
 
 template<typename KeyType>
-inline WebRtc_Word32 SetupKeySort(void* key,
-                                  SortKey<KeyType>*& ptr_sort_key,
-                                  WebRtc_UWord32 num_of_elements) {
+inline int32_t SetupKeySort(void* key,
+                            SortKey<KeyType>*& ptr_sort_key,
+                            uint32_t num_of_elements) {
   ptr_sort_key = new(std::nothrow) SortKey<KeyType>[num_of_elements];
   if (ptr_sort_key == NULL) {
     return -1;
   }
 
   KeyType* key_type = static_cast<KeyType*>(key);
-  for (WebRtc_UWord32 i = 0; i < num_of_elements; i++) {
+  for (uint32_t i = 0; i < num_of_elements; i++) {
     ptr_sort_key[i].key_ = key_type[i];
     ptr_sort_key[i].index_ = i;
   }
@@ -219,18 +219,18 @@ inline WebRtc_Word32 SetupKeySort(void* key,
 }
 
 template<typename KeyType>
-inline WebRtc_Word32 TeardownKeySort(void* data,
-                                     SortKey<KeyType>* ptr_sort_key,
-                                     WebRtc_UWord32 num_of_elements,
-                                     WebRtc_UWord32 size_of_element) {
-  WebRtc_UWord8* ptr_data = static_cast<WebRtc_UWord8*>(data);
-  WebRtc_UWord8* ptr_data_sorted =
-      new(std::nothrow) WebRtc_UWord8[num_of_elements * size_of_element];
+inline int32_t TeardownKeySort(void* data,
+                               SortKey<KeyType>* ptr_sort_key,
+                               uint32_t num_of_elements,
+                               uint32_t size_of_element) {
+  uint8_t* ptr_data = static_cast<uint8_t*>(data);
+  uint8_t* ptr_data_sorted =
+      new(std::nothrow) uint8_t[num_of_elements * size_of_element];
   if (ptr_data_sorted == NULL) {
     return -1;
   }
 
-  for (WebRtc_UWord32 i = 0; i < num_of_elements; i++) {
+  for (uint32_t i = 0; i < num_of_elements; i++) {
     memcpy(ptr_data_sorted + i * size_of_element, ptr_data +
            ptr_sort_key[i].index_ * size_of_element, size_of_element);
   }
@@ -241,9 +241,9 @@ inline WebRtc_Word32 TeardownKeySort(void* data,
 }
 
 template<typename KeyType>
-inline WebRtc_Word32 IntegerKeySort(void* data, void* key,
-                                    WebRtc_UWord32 num_of_elements,
-                                    WebRtc_UWord32 size_of_element) {
+inline int32_t IntegerKeySort(void* data, void* key,
+                              uint32_t num_of_elements,
+                              uint32_t size_of_element) {
   SortKey<KeyType>* ptr_sort_key;
   if (SetupKeySort<KeyType>(key, ptr_sort_key, num_of_elements) != 0) {
     return -1;
@@ -261,9 +261,9 @@ inline WebRtc_Word32 IntegerKeySort(void* data, void* key,
 }
 
 template<typename KeyType>
-inline WebRtc_Word32 StdKeySort(void* data, void* key,
-                                WebRtc_UWord32 num_of_elements,
-                                WebRtc_UWord32 size_of_element) {
+inline int32_t StdKeySort(void* data, void* key,
+                          uint32_t num_of_elements,
+                          uint32_t size_of_element) {
   SortKey<KeyType>* ptr_sort_key;
   if (SetupKeySort<KeyType>(key, ptr_sort_key, num_of_elements) != 0) {
     return -1;
@@ -282,7 +282,7 @@ inline WebRtc_Word32 StdKeySort(void* data, void* key,
 #endif
 }
 
-WebRtc_Word32 Sort(void* data, WebRtc_UWord32 num_of_elements, Type type) {
+int32_t Sort(void* data, uint32_t num_of_elements, Type type) {
   if (data == NULL) {
     return -1;
   }
@@ -290,28 +290,28 @@ WebRtc_Word32 Sort(void* data, WebRtc_UWord32 num_of_elements, Type type) {
 #ifdef NO_STL
   switch (type) {
     case TYPE_Word8:
-      qsort(data, num_of_elements, sizeof(WebRtc_Word8), CompareWord8);
+      qsort(data, num_of_elements, sizeof(int8_t), CompareWord8);
       break;
     case TYPE_UWord8:
-      qsort(data, num_of_elements, sizeof(WebRtc_UWord8), CompareUWord8);
+      qsort(data, num_of_elements, sizeof(uint8_t), CompareUWord8);
       break;
     case TYPE_Word16:
-      qsort(data, num_of_elements, sizeof(WebRtc_Word16), CompareWord16);
+      qsort(data, num_of_elements, sizeof(int16_t), CompareWord16);
       break;
     case TYPE_UWord16:
-      qsort(data, num_of_elements, sizeof(WebRtc_UWord16), CompareUWord16);
+      qsort(data, num_of_elements, sizeof(uint16_t), CompareUWord16);
       break;
     case TYPE_Word32:
-      qsort(data, num_of_elements, sizeof(WebRtc_Word32), CompareWord32);
+      qsort(data, num_of_elements, sizeof(int32_t), CompareWord32);
       break;
     case TYPE_UWord32:
-      qsort(data, num_of_elements, sizeof(WebRtc_UWord32), CompareUWord32);
+      qsort(data, num_of_elements, sizeof(uint32_t), CompareUWord32);
       break;
     case TYPE_Word64:
-      qsort(data, num_of_elements, sizeof(WebRtc_Word64), CompareWord64);
+      qsort(data, num_of_elements, sizeof(int64_t), CompareWord64);
       break;
     case TYPE_UWord64:
-      qsort(data, num_of_elements, sizeof(WebRtc_UWord64), CompareUWord64);
+      qsort(data, num_of_elements, sizeof(uint64_t), CompareUWord64);
       break;
     case TYPE_Float32:
       qsort(data, num_of_elements, sizeof(float), CompareFloat32);
@@ -327,28 +327,28 @@ WebRtc_Word32 Sort(void* data, WebRtc_UWord32 num_of_elements, Type type) {
   // warnings and VS 2003 build crashes respectively with spreadsort.
   switch (type) {
     case TYPE_Word8:
-      IntegerSort<WebRtc_Word8>(data, num_of_elements);
+      IntegerSort<int8_t>(data, num_of_elements);
       break;
     case TYPE_UWord8:
-      IntegerSort<WebRtc_UWord8>(data, num_of_elements);
+      IntegerSort<uint8_t>(data, num_of_elements);
       break;
     case TYPE_Word16:
-      IntegerSort<WebRtc_Word16>(data, num_of_elements);
+      IntegerSort<int16_t>(data, num_of_elements);
       break;
     case TYPE_UWord16:
-      IntegerSort<WebRtc_UWord16>(data, num_of_elements);
+      IntegerSort<uint16_t>(data, num_of_elements);
       break;
     case TYPE_Word32:
-      IntegerSort<WebRtc_Word32>(data, num_of_elements);
+      IntegerSort<int32_t>(data, num_of_elements);
       break;
     case TYPE_UWord32:
-      IntegerSort<WebRtc_UWord32>(data, num_of_elements);
+      IntegerSort<uint32_t>(data, num_of_elements);
       break;
     case TYPE_Word64:
-      StdSort<WebRtc_Word64>(data, num_of_elements);
+      StdSort<int64_t>(data, num_of_elements);
       break;
     case TYPE_UWord64:
-      StdSort<WebRtc_UWord64>(data, num_of_elements);
+      StdSort<uint64_t>(data, num_of_elements);
       break;
     case TYPE_Float32:
       StdSort<float>(data, num_of_elements);
@@ -361,8 +361,8 @@ WebRtc_Word32 Sort(void* data, WebRtc_UWord32 num_of_elements, Type type) {
   return 0;
 }
 
-WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements,
-                      WebRtc_UWord32 size_of_element, Type key_type) {
+int32_t KeySort(void* data, void* key, uint32_t num_of_elements,
+                uint32_t size_of_element, Type key_type) {
   if (data == NULL) {
     return -1;
   }
@@ -371,7 +371,7 @@ WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements,
     return -1;
   }
 
-  if ((WebRtc_UWord64)num_of_elements * size_of_element > 0xffffffff) {
+  if ((uint64_t)num_of_elements * size_of_element > 0xffffffff) {
     return -1;
   }
 
@@ -383,35 +383,35 @@ WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements,
 
   switch (key_type) {
     case TYPE_Word8:
-      KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_Word8,
+      KEY_QSORT(ptr_sort_key, key, num_of_elements, int8_t,
                 CompareKeyWord8);
       break;
     case TYPE_UWord8:
-      KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_UWord8,
+      KEY_QSORT(ptr_sort_key, key, num_of_elements, uint8_t,
                 CompareKeyUWord8);
       break;
     case TYPE_Word16:
-      KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_Word16,
+      KEY_QSORT(ptr_sort_key, key, num_of_elements, int16_t,
                 CompareKeyWord16);
       break;
     case TYPE_UWord16:
-      KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_UWord16,
+      KEY_QSORT(ptr_sort_key, key, num_of_elements, uint16_t,
                 CompareKeyUWord16);
       break;
     case TYPE_Word32:
-      KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_Word32,
+      KEY_QSORT(ptr_sort_key, key, num_of_elements, int32_t,
                 CompareKeyWord32);
       break;
     case TYPE_UWord32:
-      KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_UWord32,
+      KEY_QSORT(ptr_sort_key, key, num_of_elements, uint32_t,
                 CompareKeyUWord32);
       break;
     case TYPE_Word64:
-      KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_Word64,
+      KEY_QSORT(ptr_sort_key, key, num_of_elements, int64_t,
                 CompareKeyWord64);
       break;
     case TYPE_UWord64:
-      KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_UWord64,
+      KEY_QSORT(ptr_sort_key, key, num_of_elements, uint64_t,
                 CompareKeyUWord64);
       break;
     case TYPE_Float32:
@@ -427,14 +427,14 @@ WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements,
   }
 
   // Shuffle into sorted position based on index map.
-  WebRtc_UWord8* ptr_data = static_cast<WebRtc_UWord8*>(data);
-  WebRtc_UWord8* ptr_data_sorted =
-      new(std::nothrow) WebRtc_UWord8[num_of_elements * size_of_element];
+  uint8_t* ptr_data = static_cast<uint8_t*>(data);
+  uint8_t* ptr_data_sorted =
+      new(std::nothrow) uint8_t[num_of_elements * size_of_element];
   if (ptr_data_sorted == NULL) {
     return -1;
   }
 
-  for (WebRtc_UWord32 i = 0; i < num_of_elements; i++) {
+  for (uint32_t i = 0; i < num_of_elements; i++) {
     memcpy(ptr_data_sorted + i * size_of_element, ptr_data +
            ptr_sort_key[i].index_ * size_of_element, size_of_element);
   }
@@ -449,29 +449,29 @@ WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements,
   // warnings and errors respectively with spreadsort.
   switch (key_type) {
     case TYPE_Word8:
-      return IntegerKeySort<WebRtc_Word8>(data, key, num_of_elements,
-                                          size_of_element);
+      return IntegerKeySort<int8_t>(data, key, num_of_elements,
+                                    size_of_element);
     case TYPE_UWord8:
-      return IntegerKeySort<WebRtc_UWord8>(data, key, num_of_elements,
-                                           size_of_element);
+      return IntegerKeySort<uint8_t>(data, key, num_of_elements,
+                                     size_of_element);
     case TYPE_Word16:
-      return IntegerKeySort<WebRtc_Word16>(data, key, num_of_elements,
-                                           size_of_element);
+      return IntegerKeySort<int16_t>(data, key, num_of_elements,
+                                     size_of_element);
     case TYPE_UWord16:
-      return IntegerKeySort<WebRtc_UWord16>(data, key, num_of_elements,
-                                            size_of_element);
+      return IntegerKeySort<uint16_t>(data, key, num_of_elements,
+                                      size_of_element);
     case TYPE_Word32:
-      return IntegerKeySort<WebRtc_Word32>(data, key, num_of_elements,
-                                           size_of_element);
+      return IntegerKeySort<int32_t>(data, key, num_of_elements,
+                                     size_of_element);
     case TYPE_UWord32:
-      return IntegerKeySort<WebRtc_UWord32>(data, key, num_of_elements,
-                                            size_of_element);
+      return IntegerKeySort<uint32_t>(data, key, num_of_elements,
+                                      size_of_element);
     case TYPE_Word64:
-      return StdKeySort<WebRtc_Word64>(data, key, num_of_elements,
-                                       size_of_element);
+      return StdKeySort<int64_t>(data, key, num_of_elements,
+                                 size_of_element);
     case TYPE_UWord64:
-      return StdKeySort<WebRtc_UWord64>(data, key, num_of_elements,
-                                        size_of_element);
+      return StdKeySort<uint64_t>(data, key, num_of_elements,
+                                  size_of_element);
     case TYPE_Float32:
       return StdKeySort<float>(data, key, num_of_elements, size_of_element);
     case TYPE_Float64:
diff --git a/webrtc/system_wrappers/source/tick_util.cc b/webrtc/system_wrappers/source/tick_util.cc
index a9957568c6..17c135b079 100644
--- a/webrtc/system_wrappers/source/tick_util.cc
+++ b/webrtc/system_wrappers/source/tick_util.cc
@@ -15,14 +15,14 @@
 namespace webrtc {
 
 bool TickTime::use_fake_clock_ = false;
-WebRtc_Word64 TickTime::fake_ticks_ = 0;
+int64_t TickTime::fake_ticks_ = 0;
 
-void TickTime::UseFakeClock(WebRtc_Word64 start_millisecond) {
+void TickTime::UseFakeClock(int64_t start_millisecond) {
   use_fake_clock_ = true;
   fake_ticks_ = MillisecondsToTicks(start_millisecond);
 }
 
-void TickTime::AdvanceFakeClock(WebRtc_Word64 milliseconds) {
+void TickTime::AdvanceFakeClock(int64_t milliseconds) {
   assert(use_fake_clock_);
   fake_ticks_ += MillisecondsToTicks(milliseconds);
 }
diff --git a/webrtc/system_wrappers/source/trace_impl.cc b/webrtc/system_wrappers/source/trace_impl.cc
index de7c58c439..4272b40256 100644
--- a/webrtc/system_wrappers/source/trace_impl.cc
+++ b/webrtc/system_wrappers/source/trace_impl.cc
@@ -35,7 +35,7 @@ const int Trace::kBoilerplateLength = 71;
 const int Trace::kTimestampPosition = 13;
 const int Trace::kTimestampLength = 12;
 
-static WebRtc_UWord32 level_filter = kTraceDefault;
+static uint32_t level_filter = kTraceDefault;
 
 // Construct On First Use idiom. Avoids "static initialization order fiasco".
 TraceImpl* TraceImpl::StaticInstance(CountOperation count_operation,
@@ -131,14 +131,13 @@ TraceImpl::~TraceImpl() {
   }
 }
 
-WebRtc_Word32 TraceImpl::AddThreadId(char* trace_message) const {
-  WebRtc_UWord32 thread_id = ThreadWrapper::GetThreadId();
+int32_t TraceImpl::AddThreadId(char* trace_message) const {
+  uint32_t thread_id = ThreadWrapper::GetThreadId();
   // Messages is 12 characters.
   return sprintf(trace_message, "%10u; ", thread_id);
 }
 
-WebRtc_Word32 TraceImpl::AddLevel(char* sz_message,
-                                  const TraceLevel level) const {
+int32_t TraceImpl::AddLevel(char* sz_message, const TraceLevel level) const {
   const int kMessageLength = 12;
   switch (level) {
     case kTraceTerseInfo:
@@ -187,13 +186,13 @@ WebRtc_Word32 TraceImpl::AddLevel(char* sz_message,
   return kMessageLength;
 }
 
-WebRtc_Word32 TraceImpl::AddModuleAndId(char* trace_message,
-                                        const TraceModule module,
-                                        const WebRtc_Word32 id) const {
+int32_t TraceImpl::AddModuleAndId(char* trace_message,
+                                  const TraceModule module,
+                                  const int32_t id) const {
   // Use long int to prevent problems with different definitions of
-  // WebRtc_Word32.
+  // int32_t.
   // TODO(hellner): is this actually a problem? If so, it should be better to
-  //                clean up WebRtc_Word32
+  //                clean up int32_t
   const long int idl = id;
   const int kMessageLength = 25;
   if (idl != -1) {
@@ -339,8 +338,8 @@ WebRtc_Word32 TraceImpl::AddModuleAndId(char* trace_message,
   return kMessageLength;
 }
 
-WebRtc_Word32 TraceImpl::SetTraceFileImpl(const char* file_name_utf8,
-                                          const bool add_file_counter) {
+int32_t TraceImpl::SetTraceFileImpl(const char* file_name_utf8,
+                                    const bool add_file_counter) {
   CriticalSectionScoped lock(critsect_interface_);
 
   trace_file_.Flush();
@@ -368,22 +367,22 @@ WebRtc_Word32 TraceImpl::SetTraceFileImpl(const char* file_name_utf8,
   return 0;
 }
 
-WebRtc_Word32 TraceImpl::TraceFileImpl(
+int32_t TraceImpl::TraceFileImpl(
     char file_name_utf8[FileWrapper::kMaxFileNameSize]) {
   CriticalSectionScoped lock(critsect_interface_);
   return trace_file_.FileName(file_name_utf8, FileWrapper::kMaxFileNameSize);
 }
 
-WebRtc_Word32 TraceImpl::SetTraceCallbackImpl(TraceCallback* callback) {
+int32_t TraceImpl::SetTraceCallbackImpl(TraceCallback* callback) {
   CriticalSectionScoped lock(critsect_interface_);
   callback_ = callback;
   return 0;
 }
 
-WebRtc_Word32 TraceImpl::AddMessage(
+int32_t TraceImpl::AddMessage(
     char* trace_message,
     const char msg[WEBRTC_TRACE_MAX_MESSAGE_SIZE],
-    const WebRtc_UWord16 written_so_far) const {
+    const uint16_t written_so_far) const {
   int length = 0;
   if (written_so_far >= WEBRTC_TRACE_MAX_MESSAGE_SIZE) {
     return -1;
@@ -413,7 +412,7 @@ WebRtc_Word32 TraceImpl::AddMessage(
 
 void TraceImpl::AddMessageToList(
     const char trace_message[WEBRTC_TRACE_MAX_MESSAGE_SIZE],
-    const WebRtc_UWord16 length,
+    const uint16_t length,
     const TraceLevel level) {
   CriticalSectionScoped lock(critsect_array_);
 
@@ -442,7 +441,7 @@ void TraceImpl::AddMessageToList(
     }
   }
 
-  WebRtc_UWord16 idx = next_free_idx_[active_queue_];
+  uint16_t idx = next_free_idx_[active_queue_];
   next_free_idx_[active_queue_]++;
 
   level_[active_queue_][idx] = level;
@@ -482,8 +481,8 @@ bool TraceImpl::Process() {
 }
 
 void TraceImpl::WriteToFile() {
-  WebRtc_UWord8 local_queue_active = 0;
-  WebRtc_UWord16 local_next_free_idx = 0;
+  uint8_t local_queue_active = 0;
+  uint16_t local_next_free_idx = 0;
 
   // There are two buffers. One for reading (for writing to file) and one for
   // writing (for storing new messages). Let new messages be posted to the
@@ -505,7 +504,7 @@ void TraceImpl::WriteToFile() {
 
   CriticalSectionScoped lock(critsect_interface_);
 
-  for (WebRtc_UWord16 idx = 0; idx < local_next_free_idx; ++idx) {
+  for (uint16_t idx = 0; idx < local_next_free_idx; ++idx) {
     TraceLevel local_level = level_[local_queue_active][idx];
     if (callback_) {
       callback_->Print(local_level, message_queue_[local_queue_active][idx],
@@ -540,7 +539,7 @@ void TraceImpl::WriteToFile() {
       }
       if (row_count_text_ ==  0) {
         char message[WEBRTC_TRACE_MAX_MESSAGE_SIZE + 1];
-        WebRtc_Word32 length = AddDateTimeInfo(message);
+        int32_t length = AddDateTimeInfo(message);
         if (length != -1) {
           message[length] = 0;
           message[length - 1] = '\n';
@@ -557,7 +556,7 @@ void TraceImpl::WriteToFile() {
           row_count_text_++;
         }
       }
-      WebRtc_UWord16 length = length_[local_queue_active][idx];
+      uint16_t length = length_[local_queue_active][idx];
       message_queue_[local_queue_active][idx][length] = 0;
       message_queue_[local_queue_active][idx][length - 1] = '\n';
       trace_file_.Write(message_queue_[local_queue_active][idx], length);
@@ -567,14 +566,14 @@ void TraceImpl::WriteToFile() {
 }
 
 void TraceImpl::AddImpl(const TraceLevel level, const TraceModule module,
-                        const WebRtc_Word32 id,
+                        const int32_t id,
                         const char msg[WEBRTC_TRACE_MAX_MESSAGE_SIZE]) {
   if (TraceCheck(level)) {
     char trace_message[WEBRTC_TRACE_MAX_MESSAGE_SIZE];
     char* message_ptr = trace_message;
 
-    WebRtc_Word32 len = 0;
-    WebRtc_Word32 ack_len = 0;
+    int32_t len = 0;
+    int32_t ack_len = 0;
 
     len = AddLevel(message_ptr, level);
     if (len == -1) {
@@ -604,12 +603,12 @@ void TraceImpl::AddImpl(const TraceLevel level, const TraceModule module,
     message_ptr += len;
     ack_len += len;
 
-    len = AddMessage(message_ptr, msg, (WebRtc_UWord16)ack_len);
+    len = AddMessage(message_ptr, msg, (uint16_t)ack_len);
     if (len == -1) {
       return;
     }
     ack_len += len;
-    AddMessageToList(trace_message, (WebRtc_UWord16)ack_len, level);
+    AddMessageToList(trace_message, (uint16_t)ack_len, level);
 
     // Make sure that messages are written as soon as possible.
     event_.Set();
@@ -623,13 +622,13 @@ bool TraceImpl::TraceCheck(const TraceLevel level) const {
 bool TraceImpl::UpdateFileName(
     const char file_name_utf8[FileWrapper::kMaxFileNameSize],
     char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize],
-    const WebRtc_UWord32 new_count) const {
-  WebRtc_Word32 length = (WebRtc_Word32)strlen(file_name_utf8);
+    const uint32_t new_count) const {
+  int32_t length = (int32_t)strlen(file_name_utf8);
   if (length < 0) {
     return false;
   }
 
-  WebRtc_Word32 length_without_file_ending = length - 1;
+  int32_t length_without_file_ending = length - 1;
   while (length_without_file_ending > 0) {
     if (file_name_utf8[length_without_file_ending] == '.') {
       break;
@@ -640,7 +639,7 @@ bool TraceImpl::UpdateFileName(
   if (length_without_file_ending == 0) {
     length_without_file_ending = length;
   }
-  WebRtc_Word32 length_to_ = length_without_file_ending - 1;
+  int32_t length_to_ = length_without_file_ending - 1;
   while (length_to_ > 0) {
     if (file_name_utf8[length_to_] == '_') {
       break;
@@ -659,13 +658,13 @@ bool TraceImpl::UpdateFileName(
 bool TraceImpl::CreateFileName(
     const char file_name_utf8[FileWrapper::kMaxFileNameSize],
     char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize],
-    const WebRtc_UWord32 new_count) const {
-  WebRtc_Word32 length = (WebRtc_Word32)strlen(file_name_utf8);
+    const uint32_t new_count) const {
+  int32_t length = (int32_t)strlen(file_name_utf8);
   if (length < 0) {
     return false;
   }
 
-  WebRtc_Word32 length_without_file_ending = length - 1;
+  int32_t length_without_file_ending = length - 1;
   while (length_without_file_ending > 0) {
     if (file_name_utf8[length_without_file_ending] == '.') {
       break;
@@ -692,17 +691,17 @@ void Trace::ReturnTrace() {
   TraceImpl::StaticInstance(kRelease);
 }
 
-WebRtc_Word32 Trace::SetLevelFilter(WebRtc_UWord32 filter) {
+int32_t Trace::SetLevelFilter(uint32_t filter) {
   level_filter = filter;
   return 0;
 }
 
-WebRtc_Word32 Trace::LevelFilter(WebRtc_UWord32& filter) {
+int32_t Trace::LevelFilter(uint32_t& filter) {
   filter = level_filter;
   return 0;
 }
 
-WebRtc_Word32 Trace::TraceFile(char file_name[FileWrapper::kMaxFileNameSize]) {
+int32_t Trace::TraceFile(char file_name[FileWrapper::kMaxFileNameSize]) {
   TraceImpl* trace = TraceImpl::GetTrace();
   if (trace) {
     int ret_val = trace->TraceFileImpl(file_name);
@@ -712,8 +711,8 @@ WebRtc_Word32 Trace::TraceFile(char file_name[FileWrapper::kMaxFileNameSize]) {
   return -1;
 }
 
-WebRtc_Word32 Trace::SetTraceFile(const char* file_name,
-                                  const bool add_file_counter) {
+int32_t Trace::SetTraceFile(const char* file_name,
+                            const bool add_file_counter) {
   TraceImpl* trace = TraceImpl::GetTrace();
   if (trace) {
     int ret_val = trace->SetTraceFileImpl(file_name, add_file_counter);
@@ -723,7 +722,7 @@ WebRtc_Word32 Trace::SetTraceFile(const char* file_name,
   return -1;
 }
 
-WebRtc_Word32 Trace::SetTraceCallback(TraceCallback* callback) {
+int32_t Trace::SetTraceCallback(TraceCallback* callback) {
   TraceImpl* trace = TraceImpl::GetTrace();
   if (trace) {
     int ret_val = trace->SetTraceCallbackImpl(callback);
@@ -734,7 +733,7 @@ WebRtc_Word32 Trace::SetTraceCallback(TraceCallback* callback) {
 }
 
 void Trace::Add(const TraceLevel level, const TraceModule module,
-                const WebRtc_Word32 id, const char* msg, ...) {
+                const int32_t id, const char* msg, ...) {
   TraceImpl* trace = TraceImpl::GetTrace(level);
   if (trace) {
     if (trace->TraceCheck(level)) {
diff --git a/webrtc/system_wrappers/source/trace_impl.h b/webrtc/system_wrappers/source/trace_impl.h
index 797161557a..9e6e0a2d53 100644
--- a/webrtc/system_wrappers/source/trace_impl.h
+++ b/webrtc/system_wrappers/source/trace_impl.h
@@ -48,15 +48,13 @@ class TraceImpl : public Trace {
   static TraceImpl* CreateInstance();
   static TraceImpl* GetTrace(const TraceLevel level = kTraceAll);
 
-  WebRtc_Word32 SetTraceFileImpl(const char* file_name,
-                                 const bool add_file_counter);
-  WebRtc_Word32 TraceFileImpl(
-    char file_name[FileWrapper::kMaxFileNameSize]);
+  int32_t SetTraceFileImpl(const char* file_name, const bool add_file_counter);
+  int32_t TraceFileImpl(char file_name[FileWrapper::kMaxFileNameSize]);
 
-  WebRtc_Word32 SetTraceCallbackImpl(TraceCallback* callback);
+  int32_t SetTraceCallbackImpl(TraceCallback* callback);
 
   void AddImpl(const TraceLevel level, const TraceModule module,
-               const WebRtc_Word32 id, const char* msg);
+               const int32_t id, const char* msg);
 
   bool StopThread();
 
@@ -68,14 +66,14 @@ class TraceImpl : public Trace {
   static TraceImpl* StaticInstance(CountOperation count_operation,
                                    const TraceLevel level = kTraceAll);
 
-  WebRtc_Word32 AddThreadId(char* trace_message) const;
+  int32_t AddThreadId(char* trace_message) const;
 
   // OS specific implementations.
-  virtual WebRtc_Word32 AddTime(char* trace_message,
-                                const TraceLevel level) const = 0;
+  virtual int32_t AddTime(char* trace_message,
+                          const TraceLevel level) const = 0;
 
-  virtual WebRtc_Word32 AddBuildInfo(char* trace_message) const = 0;
-  virtual WebRtc_Word32 AddDateTimeInfo(char* trace_message) const = 0;
+  virtual int32_t AddBuildInfo(char* trace_message) const = 0;
+  virtual int32_t AddDateTimeInfo(char* trace_message) const = 0;
 
   static bool Run(void* obj);
   bool Process();
@@ -83,36 +81,36 @@ class TraceImpl : public Trace {
  private:
   friend class Trace;
 
-  WebRtc_Word32 AddLevel(char* sz_message, const TraceLevel level) const;
+  int32_t AddLevel(char* sz_message, const TraceLevel level) const;
 
-  WebRtc_Word32 AddModuleAndId(char* trace_message, const TraceModule module,
-                               const WebRtc_Word32 id) const;
+  int32_t AddModuleAndId(char* trace_message, const TraceModule module,
+                         const int32_t id) const;
 
-  WebRtc_Word32 AddMessage(char* trace_message,
-                           const char msg[WEBRTC_TRACE_MAX_MESSAGE_SIZE],
-                           const WebRtc_UWord16 written_so_far) const;
+  int32_t AddMessage(char* trace_message,
+                     const char msg[WEBRTC_TRACE_MAX_MESSAGE_SIZE],
+                     const uint16_t written_so_far) const;
 
   void AddMessageToList(
     const char trace_message[WEBRTC_TRACE_MAX_MESSAGE_SIZE],
-    const WebRtc_UWord16 length,
+    const uint16_t length,
     const TraceLevel level);
 
   bool UpdateFileName(
     const char file_name_utf8[FileWrapper::kMaxFileNameSize],
     char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize],
-    const WebRtc_UWord32 new_count) const;
+    const uint32_t new_count) const;
 
   bool CreateFileName(
     const char file_name_utf8[FileWrapper::kMaxFileNameSize],
     char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize],
-    const WebRtc_UWord32 new_count) const;
+    const uint32_t new_count) const;
 
   void WriteToFile();
 
   CriticalSectionWrapper* critsect_interface_;
   TraceCallback* callback_;
-  WebRtc_UWord32 row_count_text_;
-  WebRtc_UWord32 file_count_text_;
+  uint32_t row_count_text_;
+  uint32_t file_count_text_;
 
   FileWrapper& trace_file_;
   ThreadWrapper& thread_;
@@ -120,11 +118,11 @@ class TraceImpl : public Trace {
 
   // critsect_array_ protects active_queue_.
   CriticalSectionWrapper* critsect_array_;
-  WebRtc_UWord16 next_free_idx_[WEBRTC_TRACE_NUM_ARRAY];
+  uint16_t next_free_idx_[WEBRTC_TRACE_NUM_ARRAY];
   TraceLevel level_[WEBRTC_TRACE_NUM_ARRAY][WEBRTC_TRACE_MAX_QUEUE];
-  WebRtc_UWord16 length_[WEBRTC_TRACE_NUM_ARRAY][WEBRTC_TRACE_MAX_QUEUE];
+  uint16_t length_[WEBRTC_TRACE_NUM_ARRAY][WEBRTC_TRACE_MAX_QUEUE];
   char* message_queue_[WEBRTC_TRACE_NUM_ARRAY][WEBRTC_TRACE_MAX_QUEUE];
-  WebRtc_UWord8 active_queue_;
+  uint8_t active_queue_;
 };
 
 }  // namespace webrtc
diff --git a/webrtc/system_wrappers/source/trace_impl_no_op.cc b/webrtc/system_wrappers/source/trace_impl_no_op.cc
index efafebabba..74b322ebce 100644
--- a/webrtc/system_wrappers/source/trace_impl_no_op.cc
+++ b/webrtc/system_wrappers/source/trace_impl_no_op.cc
@@ -18,29 +18,29 @@ void Trace::CreateTrace() {
 void Trace::ReturnTrace() {
 }
 
-WebRtc_Word32 Trace::SetLevelFilter(WebRtc_UWord32 filter) {
+int32_t Trace::SetLevelFilter(uint32_t filter) {
   return 0;
 }
 
-WebRtc_Word32 Trace::LevelFilter(WebRtc_UWord32& filter) {
+int32_t Trace::LevelFilter(uint32_t& filter) {
   return 0;
 }
 
-WebRtc_Word32 Trace::TraceFile(char file_name[1024]) {
+int32_t Trace::TraceFile(char file_name[1024]) {
   return -1;
 }
 
-WebRtc_Word32 Trace::SetTraceFile(const char* file_name,
-                                  const bool add_file_counter) {
+int32_t Trace::SetTraceFile(const char* file_name,
+                            const bool add_file_counter) {
   return -1;
 }
 
-WebRtc_Word32 Trace::SetTraceCallback(TraceCallback* callback) {
+int32_t Trace::SetTraceCallback(TraceCallback* callback) {
   return -1;
 }
 
 void Trace::Add(const TraceLevel level, const TraceModule module,
-                const WebRtc_Word32 id, const char* msg, ...) {
+                const int32_t id, const char* msg, ...) {
 }
 
 }  // namespace webrtc
diff --git a/webrtc/system_wrappers/source/trace_posix.cc b/webrtc/system_wrappers/source/trace_posix.cc
index d0ab45b72d..664dfeb1ee 100644
--- a/webrtc/system_wrappers/source/trace_posix.cc
+++ b/webrtc/system_wrappers/source/trace_posix.cc
@@ -50,8 +50,7 @@ TracePosix::~TracePosix() {
   StopThread();
 }
 
-WebRtc_Word32 TracePosix::AddTime(char* trace_message,
-                                  const TraceLevel level) const {
+int32_t TracePosix::AddTime(char* trace_message, const TraceLevel level) const {
   struct timeval system_time_high_res;
   if (gettimeofday(&system_time_high_res, 0) == -1) {
     return -1;
@@ -60,8 +59,8 @@ WebRtc_Word32 TracePosix::AddTime(char* trace_message,
   const struct tm* system_time =
     localtime_r(&system_time_high_res.tv_sec, &buffer);
 
-  const WebRtc_UWord32 ms_time = system_time_high_res.tv_usec / 1000;
-  WebRtc_UWord32 prev_tickCount = 0;
+  const uint32_t ms_time = system_time_high_res.tv_usec / 1000;
+  uint32_t prev_tickCount = 0;
   {
     CriticalSectionScoped lock(&crit_sect_);
     if (level == kTraceApiCall) {
@@ -73,7 +72,7 @@ WebRtc_Word32 TracePosix::AddTime(char* trace_message,
     }
   }
 
-  WebRtc_UWord32 dw_delta_time = ms_time - prev_tickCount;
+  uint32_t dw_delta_time = ms_time - prev_tickCount;
   if (prev_tickCount == 0) {
     dw_delta_time = 0;
   }
@@ -92,18 +91,18 @@ WebRtc_Word32 TracePosix::AddTime(char* trace_message,
   return 22;
 }
 
-WebRtc_Word32 TracePosix::AddBuildInfo(char* trace_message) const {
+int32_t TracePosix::AddBuildInfo(char* trace_message) const {
   sprintf(trace_message, "Build info: %s", BUILDINFO);
   // Include NULL termination (hence + 1).
   return strlen(trace_message) + 1;
 }
 
-WebRtc_Word32 TracePosix::AddDateTimeInfo(char* trace_message) const {
+int32_t TracePosix::AddDateTimeInfo(char* trace_message) const {
   time_t t;
   time(&t);
   char buffer[26];  // man ctime says buffer should have room for >=26 bytes.
   sprintf(trace_message, "Local Date: %s", ctime_r(&t, buffer));
-  WebRtc_Word32 len = static_cast<WebRtc_Word32>(strlen(trace_message));
+  int32_t len = static_cast<int32_t>(strlen(trace_message));
 
   if ('\n' == trace_message[len - 1]) {
     trace_message[len - 1] = '\0';
diff --git a/webrtc/system_wrappers/source/trace_posix.h b/webrtc/system_wrappers/source/trace_posix.h
index 1c446b1f0f..ece936adf9 100644
--- a/webrtc/system_wrappers/source/trace_posix.h
+++ b/webrtc/system_wrappers/source/trace_posix.h
@@ -23,15 +23,14 @@ class TracePosix : public TraceImpl {
 
   // This method can be called on several different threads different from
   // the creating thread.
-  virtual WebRtc_Word32 AddTime(char* trace_message,
-                                const TraceLevel level) const;
+  virtual int32_t AddTime(char* trace_message, const TraceLevel level) const;
 
-  virtual WebRtc_Word32 AddBuildInfo(char* trace_message) const;
-  virtual WebRtc_Word32 AddDateTimeInfo(char* trace_message) const;
+  virtual int32_t AddBuildInfo(char* trace_message) const;
+  virtual int32_t AddDateTimeInfo(char* trace_message) const;
 
  private:
-  volatile mutable WebRtc_UWord32  prev_api_tick_count_;
-  volatile mutable WebRtc_UWord32  prev_tick_count_;
+  volatile mutable uint32_t  prev_api_tick_count_;
+  volatile mutable uint32_t  prev_tick_count_;
 
   CriticalSectionWrapper& crit_sect_;
 };
diff --git a/webrtc/system_wrappers/source/trace_win.cc b/webrtc/system_wrappers/source/trace_win.cc
index 04479483f8..6b82d66bfd 100644
--- a/webrtc/system_wrappers/source/trace_win.cc
+++ b/webrtc/system_wrappers/source/trace_win.cc
@@ -39,14 +39,14 @@ TraceWindows::~TraceWindows() {
   StopThread();
 }
 
-WebRtc_Word32 TraceWindows::AddTime(char* trace_message,
-                                    const TraceLevel level) const {
-  WebRtc_UWord32 dw_current_time = timeGetTime();
+int32_t TraceWindows::AddTime(char* trace_message,
+                              const TraceLevel level) const {
+  uint32_t dw_current_time = timeGetTime();
   SYSTEMTIME system_time;
   GetSystemTime(&system_time);
 
   if (level == kTraceApiCall) {
-    WebRtc_UWord32 dw_delta_time = dw_current_time - prev_tick_count_;
+    uint32_t dw_delta_time = dw_current_time - prev_tick_count_;
     prev_tick_count_ = dw_current_time;
 
     if (prev_tick_count_ == 0) {
@@ -64,7 +64,7 @@ WebRtc_Word32 TraceWindows::AddTime(char* trace_message,
             system_time.wMinute, system_time.wSecond,
             system_time.wMilliseconds, dw_delta_time);
   } else {
-    WebRtc_UWord32 dw_delta_time = dw_current_time - prev_api_tick_count_;
+    uint32_t dw_delta_time = dw_current_time - prev_api_tick_count_;
     prev_api_tick_count_ = dw_current_time;
 
     if (prev_api_tick_count_ == 0) {
@@ -84,14 +84,14 @@ WebRtc_Word32 TraceWindows::AddTime(char* trace_message,
   return 22;
 }
 
-WebRtc_Word32 TraceWindows::AddBuildInfo(char* trace_message) const {
+int32_t TraceWindows::AddBuildInfo(char* trace_message) const {
   // write data and time to text file
   sprintf(trace_message, "Build info: %s", BUILDINFO);
   // Include NULL termination (hence + 1).
-  return static_cast<WebRtc_Word32>(strlen(trace_message) + 1);
+  return static_cast<int32_t>(strlen(trace_message) + 1);
 }
 
-WebRtc_Word32 TraceWindows::AddDateTimeInfo(char* trace_message) const {
+int32_t TraceWindows::AddDateTimeInfo(char* trace_message) const {
   prev_api_tick_count_ = timeGetTime();
   prev_tick_count_ = prev_api_tick_count_;
 
@@ -113,7 +113,7 @@ WebRtc_Word32 TraceWindows::AddDateTimeInfo(char* trace_message) const {
           sz_time_str);
 
   // Include NULL termination (hence + 1).
-  return static_cast<WebRtc_Word32>(strlen(trace_message) + 1);
+  return static_cast<int32_t>(strlen(trace_message) + 1);
 }
 
 }  // namespace webrtc
diff --git a/webrtc/system_wrappers/source/trace_win.h b/webrtc/system_wrappers/source/trace_win.h
index 5d599f014a..1a871074a7 100644
--- a/webrtc/system_wrappers/source/trace_win.h
+++ b/webrtc/system_wrappers/source/trace_win.h
@@ -23,14 +23,13 @@ class TraceWindows : public TraceImpl {
   TraceWindows();
   virtual ~TraceWindows();
 
-  virtual WebRtc_Word32 AddTime(char* trace_message,
-                                const TraceLevel level) const;
+  virtual int32_t AddTime(char* trace_message, const TraceLevel level) const;
 
-  virtual WebRtc_Word32 AddBuildInfo(char* trace_message) const;
-  virtual WebRtc_Word32 AddDateTimeInfo(char* trace_message) const;
+  virtual int32_t AddBuildInfo(char* trace_message) const;
+  virtual int32_t AddDateTimeInfo(char* trace_message) const;
  private:
-  volatile mutable WebRtc_UWord32 prev_api_tick_count_;
-  volatile mutable WebRtc_UWord32 prev_tick_count_;
+  volatile mutable uint32_t prev_api_tick_count_;
+  volatile mutable uint32_t prev_tick_count_;
 };
 
 }  // namespace webrtc