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

talk/app/webrtc/webrtcsession.cc

 /*
  * libjingle
  * Copyright 2012 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 247 matching lines @@
     if (cricket::IsMediaContent(&*iter)) {
       MediaContentDescription* mdesc =
           static_cast<MediaContentDescription*> (iter->description);
       if (mdesc) {
         mdesc->set_crypto_required(type);
       }
     }
   }
 }
 
-static bool GetAudioSsrcByTrackId(
-    const SessionDescription* session_description,
-    const std::string& track_id, uint32 *ssrc) {
+static bool GetAudioSsrcByTrackId(const SessionDescription* session_description,
+                                  const std::string& track_id,
+                                  uint32_t* ssrc) {
   const cricket::ContentInfo* audio_info =
       cricket::GetFirstAudioContent(session_description);
   if (!audio_info) {
     LOG(LS_ERROR) << "Audio not used in this call";
     return false;
   }
 
   const cricket::MediaContentDescription* audio_content =
       static_cast<const cricket::MediaContentDescription*>(
           audio_info->description);
   const cricket::StreamParams* stream =
       cricket::GetStreamByIds(audio_content->streams(), "", track_id);
   if (!stream) {
     return false;
   }
 
   *ssrc = stream->first_ssrc();
   return true;
 }
 
 static bool GetTrackIdBySsrc(const SessionDescription* session_description,
-                             uint32 ssrc, std::string* track_id) {
+                             uint32_t ssrc,
+                             std::string* track_id) {
   ASSERT(track_id != NULL);
 
   const cricket::ContentInfo* audio_info =
       cricket::GetFirstAudioContent(session_description);
   if (audio_info) {
     const cricket::MediaContentDescription* audio_content =
         static_cast<const cricket::MediaContentDescription*>(
             audio_info->description);
 
     const auto* found =
@@ skipping 151 matching lines @@
   }
   std::string string_value;
   T value;
   if (constraints->GetOptional().FindFirst(key, &string_value)) {
     if (rtc::FromString(string_value, &value)) {
       option->Set(value);
     }
   }
 }
 
-uint32 ConvertIceTransportTypeToCandidateFilter(
+uint32_t ConvertIceTransportTypeToCandidateFilter(
     PeerConnectionInterface::IceTransportsType type) {
   switch (type) {
     case PeerConnectionInterface::kNone:
         return cricket::CF_NONE;
     case PeerConnectionInterface::kRelay:
         return cricket::CF_RELAY;
     case PeerConnectionInterface::kNoHost:
         return (cricket::CF_ALL & ~cricket::CF_HOST);
     case PeerConnectionInterface::kAll:
         return cricket::CF_ALL;
@@ skipping 730 matching lines @@
 
   return UseCandidate(candidate);
 }
 
 bool WebRtcSession::SetIceTransports(
     PeerConnectionInterface::IceTransportsType type) {
   return port_allocator()->set_candidate_filter(
         ConvertIceTransportTypeToCandidateFilter(type));
 }
 
-bool WebRtcSession::GetLocalTrackIdBySsrc(uint32 ssrc, std::string* track_id) {
+bool WebRtcSession::GetLocalTrackIdBySsrc(uint32_t ssrc,
+                                          std::string* track_id) {
   if (!base_local_description())
     return false;
   return webrtc::GetTrackIdBySsrc(base_local_description(), ssrc, track_id);
 }
 
-bool WebRtcSession::GetRemoteTrackIdBySsrc(uint32 ssrc, std::string* track_id) {
+bool WebRtcSession::GetRemoteTrackIdBySsrc(uint32_t ssrc,
+                                           std::string* track_id) {
   if (!base_remote_description())
     return false;
   return webrtc::GetTrackIdBySsrc(base_remote_description(), ssrc, track_id);
 }
 
 std::string WebRtcSession::BadStateErrMsg(State state) {
   std::ostringstream desc;
   desc << "Called in wrong state: " << GetStateString(state);
   return desc.str();
 }
 
-void WebRtcSession::SetAudioPlayout(uint32 ssrc, bool enable,
+void WebRtcSession::SetAudioPlayout(uint32_t ssrc,
+                                    bool enable,
                                     cricket::AudioRenderer* renderer) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!voice_channel_) {
     LOG(LS_ERROR) << "SetAudioPlayout: No audio channel exists.";
     return;
   }
   if (!voice_channel_->SetRemoteRenderer(ssrc, renderer)) {
     // SetRenderer() can fail if the ssrc does not match any playout channel.
     LOG(LS_ERROR) << "SetAudioPlayout: ssrc is incorrect: " << ssrc;
     return;
   }
   if (!voice_channel_->SetOutputScaling(ssrc, enable ? 1 : 0, enable ? 1 : 0)) {
     // Allow that SetOutputScaling fail if |enable| is false but assert
     // otherwise. This in the normal case when the underlying media channel has
     // already been deleted.
     ASSERT(enable == false);
   }
 }
 
-void WebRtcSession::SetAudioSend(uint32 ssrc, bool enable,
+void WebRtcSession::SetAudioSend(uint32_t ssrc,
+                                 bool enable,
                                  const cricket::AudioOptions& options,
                                  cricket::AudioRenderer* renderer) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!voice_channel_) {
     LOG(LS_ERROR) << "SetAudioSend: No audio channel exists.";
     return;
   }
   if (!voice_channel_->SetAudioSend(ssrc, enable, &options, renderer)) {
     LOG(LS_ERROR) << "SetAudioSend: ssrc is incorrect: " << ssrc;
   }
 }
 
-void WebRtcSession::SetAudioPlayoutVolume(uint32 ssrc, double volume) {
+void WebRtcSession::SetAudioPlayoutVolume(uint32_t ssrc, double volume) {
   ASSERT(signaling_thread()->IsCurrent());
   ASSERT(volume >= 0 && volume <= 10);
   if (!voice_channel_) {
     LOG(LS_ERROR) << "SetAudioPlayoutVolume: No audio channel exists.";
     return;
   }
 
   if (!voice_channel_->SetOutputScaling(ssrc, volume, volume)) {
     ASSERT(false);
   }
 }
 
-bool WebRtcSession::SetCaptureDevice(uint32 ssrc,
+bool WebRtcSession::SetCaptureDevice(uint32_t ssrc,
                                      cricket::VideoCapturer* camera) {
   ASSERT(signaling_thread()->IsCurrent());
 
   if (!video_channel_) {
     // |video_channel_| doesnt't exist. Probably because the remote end doesnt't
     // support video.
     LOG(LS_WARNING) << "Video not used in this call.";
     return false;
   }
   if (!video_channel_->SetCapturer(ssrc, camera)) {
     // Allow that SetCapturer fail if |camera| is NULL but assert otherwise.
     // This in the normal case when the underlying media channel has already
     // been deleted.
     ASSERT(camera == NULL);
     return false;
   }
   return true;
 }
 
-void WebRtcSession::SetVideoPlayout(uint32 ssrc,
+void WebRtcSession::SetVideoPlayout(uint32_t ssrc,
                                     bool enable,
                                     cricket::VideoRenderer* renderer) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!video_channel_) {
     LOG(LS_WARNING) << "SetVideoPlayout: No video channel exists.";
     return;
   }
   if (!video_channel_->SetRenderer(ssrc, enable ? renderer : NULL)) {
     // Allow that SetRenderer fail if |renderer| is NULL but assert otherwise.
     // This in the normal case when the underlying media channel has already
     // been deleted.
     ASSERT(renderer == NULL);
   }
 }
 
-void WebRtcSession::SetVideoSend(uint32 ssrc, bool enable,
+void WebRtcSession::SetVideoSend(uint32_t ssrc,
+                                 bool enable,
                                  const cricket::VideoOptions* options) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!video_channel_) {
     LOG(LS_WARNING) << "SetVideoSend: No video channel exists.";
     return;
   }
   if (!video_channel_->SetVideoSend(ssrc, enable, options)) {
     // Allow that MuteStream fail if |enable| is false but assert otherwise.
     // This in the normal case when the underlying media channel has already
     // been deleted.
     ASSERT(enable == false);
   }
 }
 
 bool WebRtcSession::CanInsertDtmf(const std::string& track_id) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!voice_channel_) {
     LOG(LS_ERROR) << "CanInsertDtmf: No audio channel exists.";
     return false;
   }
-  uint32 send_ssrc = 0;
+  uint32_t send_ssrc = 0;
   // The Dtmf is negotiated per channel not ssrc, so we only check if the ssrc
   // exists.
   if (!GetAudioSsrcByTrackId(base_local_description(), track_id,
                              &send_ssrc)) {
     LOG(LS_ERROR) << "CanInsertDtmf: Track does not exist: " << track_id;
     return false;
   }
   return voice_channel_->CanInsertDtmf();
 }
 
 bool WebRtcSession::InsertDtmf(const std::string& track_id,
                                int code, int duration) {
   ASSERT(signaling_thread()->IsCurrent());
   if (!voice_channel_) {
     LOG(LS_ERROR) << "InsertDtmf: No audio channel exists.";
     return false;
   }
-  uint32 send_ssrc = 0;
+  uint32_t send_ssrc = 0;
   if (!VERIFY(GetAudioSsrcByTrackId(base_local_description(),
                                     track_id, &send_ssrc))) {
     LOG(LS_ERROR) << "InsertDtmf: Track does not exist: " << track_id;
     return false;
   }
   if (!voice_channel_->InsertDtmf(send_ssrc, code, duration,
                                   cricket::DF_SEND)) {
     LOG(LS_ERROR) << "Failed to insert DTMF to channel.";
     return false;
   }
@@ skipping 808 matching lines @@
   if (!srtp_cipher.empty()) {
     metrics_observer_->IncrementSparseEnumCounter(
         srtp_counter_type, rtc::GetSrtpCryptoSuiteFromName(srtp_cipher));
   }
   if (ssl_cipher) {
     metrics_observer_->IncrementSparseEnumCounter(ssl_counter_type, ssl_cipher);
   }
 }
 
 }  // namespace webrtc