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

webrtc/base/messagequeue.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 105 matching lines @@
 
 template<class T>
 class DisposeData : public MessageData {
  public:
   explicit DisposeData(T* data) : data_(data) { }
   virtual ~DisposeData() { delete data_; }
  private:
   T* data_;
 };
 
-const uint32 MQID_ANY = static_cast<uint32>(-1);
-const uint32 MQID_DISPOSE = static_cast<uint32>(-2);
+const uint32_t MQID_ANY = static_cast<uint32_t>(-1);
+const uint32_t MQID_DISPOSE = static_cast<uint32_t>(-2);
 
 // No destructor
 
 struct Message {
   Message() {
     memset(this, 0, sizeof(*this));
   }
-  inline bool Match(MessageHandler* handler, uint32 id) const {
+  inline bool Match(MessageHandler* handler, uint32_t id) const {
     return (handler == NULL || handler == phandler)
            && (id == MQID_ANY || id == message_id);
   }
   MessageHandler *phandler;
-  uint32 message_id;
+  uint32_t message_id;
   MessageData *pdata;
-  uint32 ts_sensitive;
+  uint32_t ts_sensitive;
 };
 
 typedef std::list<Message> MessageList;
 
 // DelayedMessage goes into a priority queue, sorted by trigger time.  Messages
 // with the same trigger time are processed in num_ (FIFO) order.
 
 class DelayedMessage {
  public:
-  DelayedMessage(int delay, uint32 trigger, uint32 num, const Message& msg)
-  : cmsDelay_(delay), msTrigger_(trigger), num_(num), msg_(msg) { }
+  DelayedMessage(int delay, uint32_t trigger, uint32_t num, const Message& msg)
+      : cmsDelay_(delay), msTrigger_(trigger), num_(num), msg_(msg) {}
 
   bool operator< (const DelayedMessage& dmsg) const {
     return (dmsg.msTrigger_ < msTrigger_)
            || ((dmsg.msTrigger_ == msTrigger_) && (dmsg.num_ < num_));
   }
 
   int cmsDelay_;  // for debugging
-  uint32 msTrigger_;
-  uint32 num_;
+  uint32_t msTrigger_;
+  uint32_t num_;
   Message msg_;
 };
 
 class MessageQueue {
  public:
   static const int kForever = -1;
 
   explicit MessageQueue(SocketServer* ss = NULL);
   virtual ~MessageQueue();
 
@@ skipping 10 matching lines @@
   virtual bool IsQuitting();
   virtual void Restart();
 
   // Get() will process I/O until:
   //  1) A message is available (returns true)
   //  2) cmsWait seconds have elapsed (returns false)
   //  3) Stop() is called (returns false)
   virtual bool Get(Message *pmsg, int cmsWait = kForever,
                    bool process_io = true);
   virtual bool Peek(Message *pmsg, int cmsWait = 0);
-  virtual void Post(MessageHandler *phandler, uint32 id = 0,
-                    MessageData *pdata = NULL, bool time_sensitive = false);
+  virtual void Post(MessageHandler* phandler,
+                    uint32_t id = 0,
+                    MessageData* pdata = NULL,
+                    bool time_sensitive = false);
   virtual void PostDelayed(int cmsDelay,
                            MessageHandler* phandler,
-                           uint32 id = 0,
+                           uint32_t id = 0,
                            MessageData* pdata = NULL);
-  virtual void PostAt(uint32 tstamp,
+  virtual void PostAt(uint32_t tstamp,
                       MessageHandler* phandler,
-                      uint32 id = 0,
+                      uint32_t id = 0,
                       MessageData* pdata = NULL);
-  virtual void Clear(MessageHandler *phandler, uint32 id = MQID_ANY,
+  virtual void Clear(MessageHandler* phandler,
+                     uint32_t id = MQID_ANY,
                      MessageList* removed = NULL);
   virtual void Dispatch(Message *pmsg);
   virtual void ReceiveSends();
 
   // Amount of time until the next message can be retrieved
   virtual int GetDelay();
 
   bool empty() const { return size() == 0u; }
   size_t size() const {
     CritScope cs(&crit_);  // msgq_.size() is not thread safe.
@@ skipping 11 matching lines @@
   // no longer be used.
   sigslot::signal0<> SignalQueueDestroyed;
 
  protected:
   class PriorityQueue : public std::priority_queue<DelayedMessage> {
    public:
     container_type& container() { return c; }
     void reheap() { make_heap(c.begin(), c.end(), comp); }
   };
 
-  void DoDelayPost(int cmsDelay, uint32 tstamp, MessageHandler *phandler,
-                   uint32 id, MessageData* pdata);
+  void DoDelayPost(int cmsDelay,
+                   uint32_t tstamp,
+                   MessageHandler* phandler,
+                   uint32_t id,
+                   MessageData* pdata);
 
   // The SocketServer is not owned by MessageQueue.
   SocketServer* ss_;
   // If a server isn't supplied in the constructor, use this one.
   scoped_ptr<SocketServer> default_ss_;
   bool fStop_;
   bool fPeekKeep_;
   Message msgPeek_;
   MessageList msgq_;
   PriorityQueue dmsgq_;
-  uint32 dmsgq_next_num_;
+  uint32_t dmsgq_next_num_;
   mutable CriticalSection crit_;
 
  private:
   RTC_DISALLOW_COPY_AND_ASSIGN(MessageQueue);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_MESSAGEQUEUE_H_