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

talk/media/base/fakenetworkinterface.h

 /*
  * libjingle
  * Copyright 2004 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 43 matching lines @@
         sendbuf_size_(-1),
         recvbuf_size_(-1),
         dscp_(rtc::DSCP_NO_CHANGE) {
   }
 
   void SetDestination(MediaChannel* dest) { dest_ = dest; }
 
   // Conference mode is a mode where instead of simply forwarding the packets,
   // the transport will send multiple copies of the packet with the specified
   // SSRCs. This allows us to simulate receiving media from multiple sources.
-  void SetConferenceMode(bool conf, const std::vector<uint32>& ssrcs) {
+  void SetConferenceMode(bool conf, const std::vector<uint32_t>& ssrcs) {
     rtc::CritScope cs(&crit_);
     conf_ = conf;
     conf_sent_ssrcs_ = ssrcs;
   }
 
   int NumRtpBytes() {
     rtc::CritScope cs(&crit_);
     int bytes = 0;
     for (size_t i = 0; i < rtp_packets_.size(); ++i) {
       bytes += static_cast<int>(rtp_packets_[i].size());
     }
     return bytes;
   }
 
-  int NumRtpBytes(uint32 ssrc) {
+  int NumRtpBytes(uint32_t ssrc) {
     rtc::CritScope cs(&crit_);
     int bytes = 0;
     GetNumRtpBytesAndPackets(ssrc, &bytes, NULL);
     return bytes;
   }
 
   int NumRtpPackets() {
     rtc::CritScope cs(&crit_);
     return static_cast<int>(rtp_packets_.size());
   }
 
-  int NumRtpPackets(uint32 ssrc) {
+  int NumRtpPackets(uint32_t ssrc) {
     rtc::CritScope cs(&crit_);
     int packets = 0;
     GetNumRtpBytesAndPackets(ssrc, NULL, &packets);
     return packets;
   }
 
   int NumSentSsrcs() {
     rtc::CritScope cs(&crit_);
     return static_cast<int>(sent_ssrcs_.size());
   }
@@ skipping 23 matching lines @@
 
   int sendbuf_size() const { return sendbuf_size_; }
   int recvbuf_size() const { return recvbuf_size_; }
   rtc::DiffServCodePoint dscp() const { return dscp_; }
 
  protected:
   virtual bool SendPacket(rtc::Buffer* packet,
                           rtc::DiffServCodePoint dscp) {
     rtc::CritScope cs(&crit_);
 
-    uint32 cur_ssrc = 0;
+    uint32_t cur_ssrc = 0;
     if (!GetRtpSsrc(packet->data(), packet->size(), &cur_ssrc)) {
       return false;
     }
     sent_ssrcs_[cur_ssrc]++;
 
     rtp_packets_.push_back(*packet);
     if (conf_) {
       rtc::Buffer buffer_copy(*packet);
       for (size_t i = 0; i < conf_sent_ssrcs_.size(); ++i) {
         if (!SetRtpSsrc(buffer_copy.data(), buffer_copy.size(),
@@ skipping 45 matching lines @@
                                 rtc::CreatePacketTime(0));
       } else {
         dest_->OnRtcpReceived(&msg_data->data(),
                               rtc::CreatePacketTime(0));
       }
     }
     delete msg_data;
   }
 
  private:
-  void GetNumRtpBytesAndPackets(uint32 ssrc, int* bytes, int* packets) {
+  void GetNumRtpBytesAndPackets(uint32_t ssrc, int* bytes, int* packets) {
     if (bytes) {
       *bytes = 0;
     }
     if (packets) {
       *packets = 0;
     }
-    uint32 cur_ssrc = 0;
+    uint32_t cur_ssrc = 0;
     for (size_t i = 0; i < rtp_packets_.size(); ++i) {
       if (!GetRtpSsrc(rtp_packets_[i].data(), rtp_packets_[i].size(),
                       &cur_ssrc)) {
         return;
       }
       if (ssrc == cur_ssrc) {
         if (bytes) {
           *bytes += static_cast<int>(rtp_packets_[i].size());
         }
         if (packets) {
           ++(*packets);
         }
       }
     }
   }
 
   rtc::Thread* thread_;
   MediaChannel* dest_;
   bool conf_;
   // The ssrcs used in sending out packets in conference mode.
-  std::vector<uint32> conf_sent_ssrcs_;
+  std::vector<uint32_t> conf_sent_ssrcs_;
   // Map to track counts of packets that have been sent per ssrc.
   // This includes packets that are dropped.
-  std::map<uint32, uint32> sent_ssrcs_;
+  std::map<uint32_t, uint32_t> sent_ssrcs_;
   // Map to track packet-number that needs to be dropped per ssrc.
-  std::map<uint32, std::set<uint32> > drop_map_;
+  std::map<uint32_t, std::set<uint32_t> > drop_map_;
   rtc::CriticalSection crit_;
   std::vector<rtc::Buffer> rtp_packets_;
   std::vector<rtc::Buffer> rtcp_packets_;
   int sendbuf_size_;
   int recvbuf_size_;
   rtc::DiffServCodePoint dscp_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_FAKENETWORKINTERFACE_H_