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

talk/session/media/channel.cc

Index: talk/session/media/channel.cc
diff --git a/talk/session/media/channel.cc b/talk/session/media/channel.cc
index 294681ef1449aa94033112e8e5315cec5048a0f7..500a2351fdc06f3e1553dbb326d20a92ff00949e 100644
--- a/talk/session/media/channel.cc
+++ b/talk/session/media/channel.cc
@@ -71,49 +71,41 @@ struct PacketMessageData : public rtc::MessageData {
 };
 
 struct ScreencastEventMessageData : public rtc::MessageData {
-  ScreencastEventMessageData(uint32 s, rtc::WindowEvent we)
-      : ssrc(s),
-        event(we) {
-  }
-  uint32 ssrc;
+  ScreencastEventMessageData(uint32_t s, rtc::WindowEvent we)
+      : ssrc(s), event(we) {}
+  uint32_t ssrc;
   rtc::WindowEvent event;
 };
 
 struct VoiceChannelErrorMessageData : public rtc::MessageData {
-  VoiceChannelErrorMessageData(uint32 in_ssrc,
+  VoiceChannelErrorMessageData(uint32_t in_ssrc,
                                VoiceMediaChannel::Error in_error)
-      : ssrc(in_ssrc),
-        error(in_error) {
-  }
-  uint32 ssrc;
+      : ssrc(in_ssrc), error(in_error) {}
+  uint32_t ssrc;
   VoiceMediaChannel::Error error;
 };
 
 struct VideoChannelErrorMessageData : public rtc::MessageData {
-  VideoChannelErrorMessageData(uint32 in_ssrc,
+  VideoChannelErrorMessageData(uint32_t in_ssrc,
                                VideoMediaChannel::Error in_error)
-      : ssrc(in_ssrc),
-        error(in_error) {
-  }
-  uint32 ssrc;
+      : ssrc(in_ssrc), error(in_error) {}
+  uint32_t ssrc;
   VideoMediaChannel::Error error;
 };
 
 struct DataChannelErrorMessageData : public rtc::MessageData {
-  DataChannelErrorMessageData(uint32 in_ssrc,
+  DataChannelErrorMessageData(uint32_t in_ssrc,
                               DataMediaChannel::Error in_error)
-      : ssrc(in_ssrc),
-        error(in_error) {}
-  uint32 ssrc;
+      : ssrc(in_ssrc), error(in_error) {}
+  uint32_t ssrc;
   DataMediaChannel::Error error;
 };
 
 
 struct VideoChannel::ScreencastDetailsData {
-  explicit ScreencastDetailsData(uint32 s)
-      : ssrc(s), fps(0), screencast_max_pixels(0) {
-  }
-  uint32 ssrc;
+  explicit ScreencastDetailsData(uint32_t s)
+      : ssrc(s), fps(0), screencast_max_pixels(0) {}
+  uint32_t ssrc;
   int fps;
   int screencast_max_pixels;
 };
@@ -326,7 +318,7 @@ bool BaseChannel::AddRecvStream(const StreamParams& sp) {
   return InvokeOnWorker(Bind(&BaseChannel::AddRecvStream_w, this, sp));
 }
 
-bool BaseChannel::RemoveRecvStream(uint32 ssrc) {
+bool BaseChannel::RemoveRecvStream(uint32_t ssrc) {
   return InvokeOnWorker(Bind(&BaseChannel::RemoveRecvStream_w, this, ssrc));
 }
 
@@ -335,7 +327,7 @@ bool BaseChannel::AddSendStream(const StreamParams& sp) {
       Bind(&MediaChannel::AddSendStream, media_channel(), sp));
 }
 
-bool BaseChannel::RemoveSendStream(uint32 ssrc) {
+bool BaseChannel::RemoveSendStream(uint32_t ssrc) {
   return InvokeOnWorker(
       Bind(&MediaChannel::RemoveSendStream, media_channel(), ssrc));
 }
@@ -529,7 +521,7 @@ bool BaseChannel::SendPacket(bool rtcp, rtc::Buffer* packet,
           &options.packet_time_params.srtp_packet_index);
       // If protection succeeds, let's get auth params from srtp.
       if (res) {
-        uint8* auth_key = NULL;
+        uint8_t* auth_key = NULL;
         int key_len;
         res = srtp_filter_.GetRtpAuthParams(
             &auth_key, &key_len, &options.packet_time_params.srtp_auth_tag_len);
@@ -542,7 +534,7 @@ bool BaseChannel::SendPacket(bool rtcp, rtc::Buffer* packet,
 #endif
       if (!res) {
         int seq_num = -1;
-        uint32 ssrc = 0;
+        uint32_t ssrc = 0;
         GetRtpSeqNum(data, len, &seq_num);
         GetRtpSsrc(data, len, &ssrc);
         LOG(LS_ERROR) << "Failed to protect " << content_name_
@@ -623,7 +615,7 @@ void BaseChannel::HandlePacket(bool rtcp, rtc::Buffer* packet,
       res = srtp_filter_.UnprotectRtp(data, len, &len);
       if (!res) {
         int seq_num = -1;
-        uint32 ssrc = 0;
+        uint32_t ssrc = 0;
         GetRtpSeqNum(data, len, &seq_num);
         GetRtpSsrc(data, len, &ssrc);
         LOG(LS_ERROR) << "Failed to unprotect " << content_name_
@@ -1039,7 +1031,7 @@ bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
   return bundle_filter_.AddStream(sp);
 }
 
-bool BaseChannel::RemoveRecvStream_w(uint32 ssrc) {
+bool BaseChannel::RemoveRecvStream_w(uint32_t ssrc) {
   ASSERT(worker_thread() == rtc::Thread::Current());
   bundle_filter_.RemoveStream(ssrc);
   return media_channel()->RemoveRecvStream(ssrc);
@@ -1259,12 +1251,13 @@ bool VoiceChannel::Init() {
   return true;
 }
 
-bool VoiceChannel::SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer) {
+bool VoiceChannel::SetRemoteRenderer(uint32_t ssrc, AudioRenderer* renderer) {
   return InvokeOnWorker(Bind(&VoiceMediaChannel::SetRemoteRenderer,
                              media_channel(), ssrc, renderer));
 }
 
-bool VoiceChannel::SetAudioSend(uint32 ssrc, bool mute,
+bool VoiceChannel::SetAudioSend(uint32_t ssrc,
+                                bool mute,
                                 const AudioOptions* options,
                                 AudioRenderer* renderer) {
   return InvokeOnWorker(Bind(&VoiceMediaChannel::SetAudioSend,
@@ -1291,7 +1284,7 @@ void VoiceChannel::SetEarlyMedia(bool enable) {
   }
 }
 
-bool VoiceChannel::PlayRingbackTone(uint32 ssrc, bool play, bool loop) {
+bool VoiceChannel::PlayRingbackTone(uint32_t ssrc, bool play, bool loop) {
   return InvokeOnWorker(Bind(&VoiceChannel::PlayRingbackTone_w,
                              this, ssrc, play, loop));
 }
@@ -1310,13 +1303,15 @@ bool VoiceChannel::CanInsertDtmf() {
                              media_channel()));
 }
 
-bool VoiceChannel::InsertDtmf(uint32 ssrc, int event_code, int duration,
+bool VoiceChannel::InsertDtmf(uint32_t ssrc,
+                              int event_code,
+                              int duration,
                               int flags) {
   return InvokeOnWorker(Bind(&VoiceChannel::InsertDtmf_w, this,
                              ssrc, event_code, duration, flags));
 }
 
-bool VoiceChannel::SetOutputScaling(uint32 ssrc, double left, double right) {
+bool VoiceChannel::SetOutputScaling(uint32_t ssrc, double left, double right) {
   return InvokeOnWorker(Bind(&VoiceMediaChannel::SetOutputScaling,
                              media_channel(), ssrc, left, right));
 }
@@ -1510,7 +1505,7 @@ bool VoiceChannel::SetRingbackTone_w(const void* buf, int len) {
   return media_channel()->SetRingbackTone(static_cast<const char*>(buf), len);
 }
 
-bool VoiceChannel::PlayRingbackTone_w(uint32 ssrc, bool play, bool loop) {
+bool VoiceChannel::PlayRingbackTone_w(uint32_t ssrc, bool play, bool loop) {
   ASSERT(worker_thread() == rtc::Thread::Current());
   if (play) {
     LOG(LS_INFO) << "Playing ringback tone, loop=" << loop;
@@ -1528,7 +1523,9 @@ void VoiceChannel::HandleEarlyMediaTimeout() {
   }
 }
 
-bool VoiceChannel::InsertDtmf_w(uint32 ssrc, int event, int duration,
+bool VoiceChannel::InsertDtmf_w(uint32_t ssrc,
+                                int event,
+                                int duration,
                                 int flags) {
   if (!enabled()) {
     return false;
@@ -1571,14 +1568,15 @@ void VoiceChannel::OnAudioMonitorUpdate(AudioMonitor* monitor,
   SignalAudioMonitor(this, info);
 }
 
-void VoiceChannel::OnVoiceChannelError(
-    uint32 ssrc, VoiceMediaChannel::Error err) {
+void VoiceChannel::OnVoiceChannelError(uint32_t ssrc,
+                                       VoiceMediaChannel::Error err) {
   VoiceChannelErrorMessageData* data = new VoiceChannelErrorMessageData(
       ssrc, err);
   signaling_thread()->Post(this, MSG_CHANNEL_ERROR, data);
 }
 
-void VoiceChannel::OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode,
+void VoiceChannel::OnSrtpError(uint32_t ssrc,
+                               SrtpFilter::Mode mode,
                                SrtpFilter::Error error) {
   switch (error) {
     case SrtpFilter::ERROR_FAIL:
@@ -1628,14 +1626,14 @@ bool VideoChannel::Init() {
 }
 
 void VoiceChannel::SendLastMediaError() {
-  uint32 ssrc;
+  uint32_t ssrc;
   VoiceMediaChannel::Error error;
   media_channel()->GetLastMediaError(&ssrc, &error);
   SignalMediaError(this, ssrc, error);
 }
 
 VideoChannel::~VideoChannel() {
-  std::vector<uint32> screencast_ssrcs;
+  std::vector<uint32_t> screencast_ssrcs;
   ScreencastMap::iterator iter;
   while (!screencast_capturers_.empty()) {
     if (!RemoveScreencast(screencast_capturers_.begin()->first)) {
@@ -1653,7 +1651,7 @@ VideoChannel::~VideoChannel() {
   Deinit();
 }
 
-bool VideoChannel::SetRenderer(uint32 ssrc, VideoRenderer* renderer) {
+bool VideoChannel::SetRenderer(uint32_t ssrc, VideoRenderer* renderer) {
   worker_thread()->Invoke<void>(Bind(
       &VideoMediaChannel::SetRenderer, media_channel(), ssrc, renderer));
   return true;
@@ -1663,17 +1661,17 @@ bool VideoChannel::ApplyViewRequest(const ViewRequest& request) {
   return InvokeOnWorker(Bind(&VideoChannel::ApplyViewRequest_w, this, request));
 }
 
-bool VideoChannel::AddScreencast(uint32 ssrc, VideoCapturer* capturer) {
+bool VideoChannel::AddScreencast(uint32_t ssrc, VideoCapturer* capturer) {
   return worker_thread()->Invoke<bool>(Bind(
       &VideoChannel::AddScreencast_w, this, ssrc, capturer));
 }
 
-bool VideoChannel::SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
+bool VideoChannel::SetCapturer(uint32_t ssrc, VideoCapturer* capturer) {
   return InvokeOnWorker(Bind(&VideoMediaChannel::SetCapturer,
                              media_channel(), ssrc, capturer));
 }
 
-bool VideoChannel::RemoveScreencast(uint32 ssrc) {
+bool VideoChannel::RemoveScreencast(uint32_t ssrc) {
   return InvokeOnWorker(Bind(&VideoChannel::RemoveScreencast_w, this, ssrc));
 }
 
@@ -1681,14 +1679,14 @@ bool VideoChannel::IsScreencasting() {
   return InvokeOnWorker(Bind(&VideoChannel::IsScreencasting_w, this));
 }
 
-int VideoChannel::GetScreencastFps(uint32 ssrc) {
+int VideoChannel::GetScreencastFps(uint32_t ssrc) {
   ScreencastDetailsData data(ssrc);
   worker_thread()->Invoke<void>(Bind(
       &VideoChannel::GetScreencastDetails_w, this, &data));
   return data.fps;
 }
 
-int VideoChannel::GetScreencastMaxPixels(uint32 ssrc) {
+int VideoChannel::GetScreencastMaxPixels(uint32_t ssrc) {
   ScreencastDetailsData data(ssrc);
   worker_thread()->Invoke<void>(Bind(
       &VideoChannel::GetScreencastDetails_w, this, &data));
@@ -1707,7 +1705,8 @@ bool VideoChannel::RequestIntraFrame() {
   return true;
 }
 
-bool VideoChannel::SetVideoSend(uint32 ssrc, bool mute,
+bool VideoChannel::SetVideoSend(uint32_t ssrc,
+                                bool mute,
                                 const VideoOptions* options) {
   return InvokeOnWorker(Bind(&VideoMediaChannel::SetVideoSend,
                              media_channel(), ssrc, mute, options));
@@ -1888,7 +1887,7 @@ bool VideoChannel::ApplyViewRequest_w(const ViewRequest& request) {
   return ret;
 }
 
-bool VideoChannel::AddScreencast_w(uint32 ssrc, VideoCapturer* capturer) {
+bool VideoChannel::AddScreencast_w(uint32_t ssrc, VideoCapturer* capturer) {
   if (screencast_capturers_.find(ssrc) != screencast_capturers_.end()) {
     return false;
   }
@@ -1897,7 +1896,7 @@ bool VideoChannel::AddScreencast_w(uint32 ssrc, VideoCapturer* capturer) {
   return true;
 }
 
-bool VideoChannel::RemoveScreencast_w(uint32 ssrc) {
+bool VideoChannel::RemoveScreencast_w(uint32_t ssrc) {
   ScreencastMap::iterator iter = screencast_capturers_.find(ssrc);
   if (iter  == screencast_capturers_.end()) {
     return false;
@@ -1924,7 +1923,7 @@ void VideoChannel::GetScreencastDetails_w(
   data->screencast_max_pixels = capturer->screencast_max_pixels();
 }
 
-void VideoChannel::OnScreencastWindowEvent_s(uint32 ssrc,
+void VideoChannel::OnScreencastWindowEvent_s(uint32_t ssrc,
                                              rtc::WindowEvent we) {
   ASSERT(signaling_thread() == rtc::Thread::Current());
   SignalScreencastWindowEvent(ssrc, we);
@@ -1965,7 +1964,7 @@ void VideoChannel::OnMediaMonitorUpdate(
   SignalMediaMonitor(this, info);
 }
 
-void VideoChannel::OnScreencastWindowEvent(uint32 ssrc,
+void VideoChannel::OnScreencastWindowEvent(uint32_t ssrc,
                                            rtc::WindowEvent event) {
   ScreencastEventMessageData* pdata =
       new ScreencastEventMessageData(ssrc, event);
@@ -1987,7 +1986,7 @@ void VideoChannel::OnStateChange(VideoCapturer* capturer, CaptureState ev) {
   }
   previous_we_ = we;
 
-  uint32 ssrc = 0;
+  uint32_t ssrc = 0;
   if (!GetLocalSsrc(capturer, &ssrc)) {
     return;
   }
@@ -1995,7 +1994,7 @@ void VideoChannel::OnStateChange(VideoCapturer* capturer, CaptureState ev) {
   OnScreencastWindowEvent(ssrc, we);
 }
 
-bool VideoChannel::GetLocalSsrc(const VideoCapturer* capturer, uint32* ssrc) {
+bool VideoChannel::GetLocalSsrc(const VideoCapturer* capturer, uint32_t* ssrc) {
   *ssrc = 0;
   for (ScreencastMap::iterator iter = screencast_capturers_.begin();
        iter != screencast_capturers_.end(); ++iter) {
@@ -2007,14 +2006,15 @@ bool VideoChannel::GetLocalSsrc(const VideoCapturer* capturer, uint32* ssrc) {
   return false;
 }
 
-void VideoChannel::OnVideoChannelError(uint32 ssrc,
+void VideoChannel::OnVideoChannelError(uint32_t ssrc,
                                        VideoMediaChannel::Error error) {
   VideoChannelErrorMessageData* data = new VideoChannelErrorMessageData(
       ssrc, error);
   signaling_thread()->Post(this, MSG_CHANNEL_ERROR, data);
 }
 
-void VideoChannel::OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode,
+void VideoChannel::OnSrtpError(uint32_t ssrc,
+                               SrtpFilter::Mode mode,
                                SrtpFilter::Error error) {
   switch (error) {
     case SrtpFilter::ERROR_FAIL:
@@ -2287,8 +2287,8 @@ void DataChannel::OnMessage(rtc::Message *pmsg) {
       break;
     }
     case MSG_STREAMCLOSEDREMOTELY: {
-      rtc::TypedMessageData<uint32>* data =
-          static_cast<rtc::TypedMessageData<uint32>*>(pmsg->pdata);
+      rtc::TypedMessageData<uint32_t>* data =
+          static_cast<rtc::TypedMessageData<uint32_t>*>(pmsg->pdata);
       SignalStreamClosedRemotely(data->data());
       delete data;
       break;
@@ -2333,8 +2333,8 @@ void DataChannel::OnDataReceived(
   signaling_thread()->Post(this, MSG_DATARECEIVED, msg);
 }
 
-void DataChannel::OnDataChannelError(
-    uint32 ssrc, DataMediaChannel::Error err) {
+void DataChannel::OnDataChannelError(uint32_t ssrc,
+                                     DataMediaChannel::Error err) {
   DataChannelErrorMessageData* data = new DataChannelErrorMessageData(
       ssrc, err);
   signaling_thread()->Post(this, MSG_CHANNEL_ERROR, data);
@@ -2348,7 +2348,8 @@ void DataChannel::OnDataChannelReadyToSend(bool writable) {
                            new DataChannelReadyToSendMessageData(writable));
 }
 
-void DataChannel::OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode,
+void DataChannel::OnSrtpError(uint32_t ssrc,
+                              SrtpFilter::Mode mode,
                               SrtpFilter::Error error) {
   switch (error) {
     case SrtpFilter::ERROR_FAIL:
@@ -2379,9 +2380,9 @@ bool DataChannel::ShouldSetupDtlsSrtp() const {
   return (data_channel_type_ == DCT_RTP);
 }
 
-void DataChannel::OnStreamClosedRemotely(uint32 sid) {
-  rtc::TypedMessageData<uint32>* message =
-      new rtc::TypedMessageData<uint32>(sid);
+void DataChannel::OnStreamClosedRemotely(uint32_t sid) {
+  rtc::TypedMessageData<uint32_t>* message =
+      new rtc::TypedMessageData<uint32_t>(sid);
   signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message);
 }