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

talk/app/webrtc/mediastreamsignaling.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 594 matching lines @@
     }
   }
 
   // Find new and active tracks.
   for (cricket::StreamParamsVec::const_iterator it = streams.begin();
        it != streams.end(); ++it) {
     // The sync_label is the MediaStream label and the |stream.id| is the
     // track id.
     const std::string& stream_label = it->sync_label;
     const std::string& track_id = it->id;
-    uint32 ssrc = it->first_ssrc();
+    uint32_t ssrc = it->first_ssrc();
 
     rtc::scoped_refptr<MediaStreamInterface> stream =
         remote_streams_->find(stream_label);
     if (!stream) {
       // This is a new MediaStream. Create a new remote MediaStream.
       stream = remote_stream_factory_->CreateMediaStream(stream_label);
       remote_streams_->AddStream(stream);
       new_streams->AddStream(stream);
     }
 
     const TrackInfo* track_info = FindTrackInfo(*current_tracks, stream_label,
                                                 track_id);
     if (!track_info) {
       current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc));
       OnRemoteTrackSeen(stream_label, track_id, it->first_ssrc(), media_type);
     }
   }
 }
 
 void MediaStreamSignaling::OnRemoteTrackSeen(const std::string& stream_label,
                                              const std::string& track_id,
-                                             uint32 ssrc,
+                                             uint32_t ssrc,
                                              cricket::MediaType media_type) {
   MediaStreamInterface* stream = remote_streams_->find(stream_label);
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     AudioTrackInterface* audio_track =
         remote_stream_factory_->AddAudioTrack(stream, track_id);
     stream_observer_->OnAddRemoteAudioTrack(stream, audio_track, ssrc);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     VideoTrackInterface* video_track =
         remote_stream_factory_->AddVideoTrack(stream, track_id);
@@ skipping 146 matching lines @@
     }
   }
 
   // Find new and active tracks.
   for (cricket::StreamParamsVec::const_iterator it = streams.begin();
        it != streams.end(); ++it) {
     // The sync_label is the MediaStream label and the |stream.id| is the
     // track id.
     const std::string& stream_label = it->sync_label;
     const std::string& track_id = it->id;
-    uint32 ssrc = it->first_ssrc();
+    uint32_t ssrc = it->first_ssrc();
     const TrackInfo* track_info = FindTrackInfo(*current_tracks,
                                                 stream_label,
                                                 track_id);
     if (!track_info) {
       current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc));
       OnLocalTrackSeen(stream_label, track_id, it->first_ssrc(),
                        media_type);
     }
   }
 }
 
-void MediaStreamSignaling::OnLocalTrackSeen(
-    const std::string& stream_label,
-    const std::string& track_id,
-    uint32 ssrc,
-    cricket::MediaType media_type) {
+void MediaStreamSignaling::OnLocalTrackSeen(const std::string& stream_label,
+                                            const std::string& track_id,
+                                            uint32_t ssrc,
+                                            cricket::MediaType media_type) {
   MediaStreamInterface* stream = local_streams_->find(stream_label);
   if (!stream) {
     LOG(LS_WARNING) << "An unknown local MediaStream with label "
                     << stream_label <<  " has been configured.";
     return;
   }
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     AudioTrackInterface* audio_track = stream->FindAudioTrack(track_id);
     if (!audio_track) {
       LOG(LS_WARNING) << "An unknown local AudioTrack with id , "
                       << track_id <<  " has been configured.";
       return;
     }
     stream_observer_->OnAddLocalAudioTrack(stream, audio_track, ssrc);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     VideoTrackInterface* video_track = stream->FindVideoTrack(track_id);
     if (!video_track) {
       LOG(LS_WARNING) << "An unknown local VideoTrack with id , "
                       << track_id <<  " has been configured.";
       return;
     }
     stream_observer_->OnAddLocalVideoTrack(stream, video_track, ssrc);
   } else {
     ASSERT(false && "Invalid media type");
   }
 }
 
-void MediaStreamSignaling::OnLocalTrackRemoved(
-    const std::string& stream_label,
-    const std::string& track_id,
-    uint32 ssrc,
-    cricket::MediaType media_type) {
+void MediaStreamSignaling::OnLocalTrackRemoved(const std::string& stream_label,
+                                               const std::string& track_id,
+                                               uint32_t ssrc,
+                                               cricket::MediaType media_type) {
   MediaStreamInterface* stream = local_streams_->find(stream_label);
   if (!stream) {
     // This is the normal case. Ie RemoveLocalStream has been called and the
     // SessionDescriptions has been renegotiated.
     return;
   }
   // A track has been removed from the SessionDescription but the MediaStream
   // is still associated with MediaStreamSignaling. This only occurs if the SDP
   // doesn't match with the calls to AddLocalStream and RemoveLocalStream.
 
@@ skipping 84 matching lines @@
     if (data_channel->state() == DataChannel::kClosed) {
       rtp_data_channels_.erase(it);
       it = rtp_data_channels_.begin();
     } else {
       ++it;
     }
   }
 }
 
 void MediaStreamSignaling::CreateRemoteDataChannel(const std::string& label,
-                                                   uint32 remote_ssrc) {
+                                                   uint32_t remote_ssrc) {
   if (!data_channel_factory_) {
     LOG(LS_WARNING) << "Remote peer requested a DataChannel but DataChannels "
                     << "are not supported.";
     return;
   }
   scoped_refptr<DataChannel> channel(
       data_channel_factory_->CreateDataChannel(label, NULL));
   if (!channel.get()) {
     LOG(LS_WARNING) << "Remote peer requested a DataChannel but"
                     << "CreateDataChannel failed.";
@@ skipping 17 matching lines @@
       int sid;
       if (!AllocateSctpSid(role, &sid)) {
         LOG(LS_ERROR) << "Failed to allocate SCTP sid.";
         continue;
       }
       (*it)->SetSctpSid(sid);
     }
   }
 }
 
-
-void MediaStreamSignaling::OnRemoteSctpDataChannelClosed(uint32 sid) {
+void MediaStreamSignaling::OnRemoteSctpDataChannelClosed(uint32_t sid) {
   int index = FindDataChannelBySid(sid);
   if (index < 0) {
     LOG(LS_WARNING) << "Unexpected sid " << sid
                     << " of the remotely closed DataChannel.";
     return;
   }
   sctp_data_channels_[index]->Close();
 }
 
 const MediaStreamSignaling::TrackInfo*
@@ skipping 13 matching lines @@
 int MediaStreamSignaling::FindDataChannelBySid(int sid) const {
   for (size_t i = 0; i < sctp_data_channels_.size(); ++i) {
     if (sctp_data_channels_[i]->id() == sid) {
       return static_cast<int>(i);
     }
   }
   return -1;
 }
 
 }  // namespace webrtc