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

webrtc/base/messagequeue.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.
  */
 
 #if defined(WEBRTC_POSIX)
 #include <sys/time.h>
 #endif
 
 #include <algorithm>
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagequeue.h"
 #if defined(__native_client__)
 #include "webrtc/base/nullsocketserver.h"
 typedef rtc::NullSocketServer DefaultSocketServer;
 #else
 #include "webrtc/base/physicalsocketserver.h"
 typedef rtc::PhysicalSocketServer DefaultSocketServer;
 #endif
 
 namespace rtc {
 
-const uint32 kMaxMsgLatency = 150;  // 150 ms
+const uint32_t kMaxMsgLatency = 150;  // 150 ms
 
 //------------------------------------------------------------------
 // MessageQueueManager
 
 MessageQueueManager* MessageQueueManager::instance_ = NULL;
 
 MessageQueueManager* MessageQueueManager::Instance() {
   // Note: This is not thread safe, but it is first called before threads are
   // spawned.
   if (!instance_)
@@ skipping 140 matching lines @@
   if (fPeekKeep_) {
     *pmsg = msgPeek_;
     fPeekKeep_ = false;
     return true;
   }
 
   // Get w/wait + timer scan / dispatch + socket / event multiplexer dispatch
 
   int cmsTotal = cmsWait;
   int cmsElapsed = 0;
-  uint32 msStart = Time();
-  uint32 msCurrent = msStart;
+  uint32_t msStart = Time();
+  uint32_t msCurrent = msStart;
   while (true) {
     // Check for sent messages
     ReceiveSends();
 
     // Check for posted events
     int cmsDelayNext = kForever;
     bool first_pass = true;
     while (true) {
       // All queue operations need to be locked, but nothing else in this loop
       // (specifically handling disposed message) can happen inside the crit.
@@ skipping 17 matching lines @@
         if (msgq_.empty()) {
           break;
         } else {
           *pmsg = msgq_.front();
           msgq_.pop_front();
         }
       }  // crit_ is released here.
 
       // Log a warning for time-sensitive messages that we're late to deliver.
       if (pmsg->ts_sensitive) {
-        int32 delay = TimeDiff(msCurrent, pmsg->ts_sensitive);
+        int32_t delay = TimeDiff(msCurrent, pmsg->ts_sensitive);
         if (delay > 0) {
           LOG_F(LS_WARNING) << "id: " << pmsg->message_id << "  delay: "
                             << (delay + kMaxMsgLatency) << "ms";
         }
       }
       // If this was a dispose message, delete it and skip it.
       if (MQID_DISPOSE == pmsg->message_id) {
         ASSERT(NULL == pmsg->phandler);
         delete pmsg->pdata;
         *pmsg = Message();
@@ skipping 28 matching lines @@
       if (cmsElapsed >= cmsWait)
         return false;
     }
   }
   return false;
 }
 
 void MessageQueue::ReceiveSends() {
 }
 
-void MessageQueue::Post(MessageHandler *phandler, uint32 id,
-    MessageData *pdata, bool time_sensitive) {
+void MessageQueue::Post(MessageHandler* phandler,
+                        uint32_t id,
+                        MessageData* pdata,
+                        bool time_sensitive) {
   if (fStop_)
     return;
 
   // Keep thread safe
   // Add the message to the end of the queue
   // Signal for the multiplexer to return
 
   CritScope cs(&crit_);
   Message msg;
   msg.phandler = phandler;
   msg.message_id = id;
   msg.pdata = pdata;
   if (time_sensitive) {
     msg.ts_sensitive = Time() + kMaxMsgLatency;
   }
   msgq_.push_back(msg);
   ss_->WakeUp();
 }
 
 void MessageQueue::PostDelayed(int cmsDelay,
                                MessageHandler* phandler,
-                               uint32 id,
+                               uint32_t id,
                                MessageData* pdata) {
   return DoDelayPost(cmsDelay, TimeAfter(cmsDelay), phandler, id, pdata);
 }
 
-void MessageQueue::PostAt(uint32 tstamp,
+void MessageQueue::PostAt(uint32_t tstamp,
                           MessageHandler* phandler,
-                          uint32 id,
+                          uint32_t id,
                           MessageData* pdata) {
   return DoDelayPost(TimeUntil(tstamp), tstamp, phandler, id, pdata);
 }
 
-void MessageQueue::DoDelayPost(int cmsDelay, uint32 tstamp,
-    MessageHandler *phandler, uint32 id, MessageData* pdata) {
+void MessageQueue::DoDelayPost(int cmsDelay,
+                               uint32_t tstamp,
+                               MessageHandler* phandler,
+                               uint32_t id,
+                               MessageData* pdata) {
   if (fStop_)
     return;
 
   // Keep thread safe
   // Add to the priority queue. Gets sorted soonest first.
   // Signal for the multiplexer to return.
 
   CritScope cs(&crit_);
   Message msg;
   msg.phandler = phandler;
@@ skipping 17 matching lines @@
   if (!dmsgq_.empty()) {
     int delay = TimeUntil(dmsgq_.top().msTrigger_);
     if (delay < 0)
       delay = 0;
     return delay;
   }
 
   return kForever;
 }
 
-void MessageQueue::Clear(MessageHandler *phandler, uint32 id,
+void MessageQueue::Clear(MessageHandler* phandler,
+                         uint32_t id,
                          MessageList* removed) {
   CritScope cs(&crit_);
 
   // Remove messages with phandler
 
   if (fPeekKeep_ && msgPeek_.Match(phandler, id)) {
     if (removed) {
       removed->push_back(msgPeek_);
     } else {
       delete msgPeek_.pdata;
@@ skipping 33 matching lines @@
   }
   dmsgq_.container().erase(new_end, dmsgq_.container().end());
   dmsgq_.reheap();
 }
 
 void MessageQueue::Dispatch(Message *pmsg) {
   pmsg->phandler->OnMessage(pmsg);
 }
 
 }  // namespace rtc