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

talk/app/webrtc/mediastreamsignaling_unittest.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 293 matching lines @@
   // Remote stream is no longer available.
   virtual void OnRemoveRemoteStream(MediaStreamInterface* remote_stream) {
     remote_media_streams_->RemoveStream(remote_stream);
   }
 
   virtual void OnAddDataChannel(DataChannelInterface* data_channel) {
   }
 
   virtual void OnAddLocalAudioTrack(MediaStreamInterface* stream,
                                     AudioTrackInterface* audio_track,
-                                    uint32 ssrc) {
+                                    uint32_t ssrc) {
     AddTrack(&local_audio_tracks_, stream, audio_track, ssrc);
   }
 
   virtual void OnAddLocalVideoTrack(MediaStreamInterface* stream,
                                     VideoTrackInterface* video_track,
-                                    uint32 ssrc) {
+                                    uint32_t ssrc) {
     AddTrack(&local_video_tracks_, stream, video_track, ssrc);
   }
 
   virtual void OnRemoveLocalAudioTrack(MediaStreamInterface* stream,
                                        AudioTrackInterface* audio_track,
-                                       uint32 ssrc) {
+                                       uint32_t ssrc) {
     RemoveTrack(&local_audio_tracks_, stream, audio_track);
   }
 
   virtual void OnRemoveLocalVideoTrack(MediaStreamInterface* stream,
                                        VideoTrackInterface* video_track) {
     RemoveTrack(&local_video_tracks_, stream, video_track);
   }
 
   virtual void OnAddRemoteAudioTrack(MediaStreamInterface* stream,
                                      AudioTrackInterface* audio_track,
-                                     uint32 ssrc) {
+                                     uint32_t ssrc) {
     AddTrack(&remote_audio_tracks_, stream, audio_track, ssrc);
   }
 
   virtual void OnAddRemoteVideoTrack(MediaStreamInterface* stream,
                                      VideoTrackInterface* video_track,
-                                     uint32 ssrc) {
+                                     uint32_t ssrc) {
     AddTrack(&remote_video_tracks_, stream, video_track, ssrc);
   }
 
   virtual void OnRemoveRemoteAudioTrack(MediaStreamInterface* stream,
                                         AudioTrackInterface* audio_track) {
     RemoveTrack(&remote_audio_tracks_, stream, audio_track);
   }
 
   virtual void OnRemoveRemoteVideoTrack(MediaStreamInterface* stream,
                                         VideoTrackInterface* video_track) {
     RemoveTrack(&remote_video_tracks_, stream, video_track);
   }
 
   virtual void OnRemoveLocalStream(MediaStreamInterface* stream) {
   }
 
   MediaStreamInterface* RemoteStream(const std::string& label) {
     return remote_media_streams_->find(label);
   }
 
   StreamCollectionInterface* remote_streams() const {
     return remote_media_streams_;
   }
 
   size_t NumberOfRemoteAudioTracks() { return remote_audio_tracks_.size(); }
 
   void VerifyRemoteAudioTrack(const std::string& stream_label,
                               const std::string& track_id,
-                              uint32 ssrc) {
+                              uint32_t ssrc) {
     VerifyTrack(remote_audio_tracks_, stream_label, track_id, ssrc);
   }
 
   size_t NumberOfRemoteVideoTracks() { return remote_video_tracks_.size(); }
 
   void VerifyRemoteVideoTrack(const std::string& stream_label,
                               const std::string& track_id,
-                              uint32 ssrc) {
+                              uint32_t ssrc) {
     VerifyTrack(remote_video_tracks_, stream_label, track_id, ssrc);
   }
 
   size_t NumberOfLocalAudioTracks() { return local_audio_tracks_.size(); }
   void VerifyLocalAudioTrack(const std::string& stream_label,
                              const std::string& track_id,
-                             uint32 ssrc) {
+                             uint32_t ssrc) {
     VerifyTrack(local_audio_tracks_, stream_label, track_id, ssrc);
   }
 
   size_t NumberOfLocalVideoTracks() { return local_video_tracks_.size(); }
 
   void VerifyLocalVideoTrack(const std::string& stream_label,
                              const std::string& track_id,
-                             uint32 ssrc) {
+                             uint32_t ssrc) {
     VerifyTrack(local_video_tracks_, stream_label, track_id, ssrc);
   }
 
  private:
   struct TrackInfo {
     TrackInfo() {}
     TrackInfo(const std::string& stream_label,
               const std::string track_id,
-              uint32 ssrc)
+              uint32_t ssrc)
         : stream_label(stream_label), track_id(track_id), ssrc(ssrc) {}
     std::string stream_label;
     std::string track_id;
-    uint32 ssrc;
+    uint32_t ssrc;
   };
   typedef std::vector<TrackInfo> TrackInfos;
 
   void AddTrack(TrackInfos* track_infos,
                 MediaStreamInterface* stream,
                 MediaStreamTrackInterface* track,
-                uint32 ssrc) {
+                uint32_t ssrc) {
     (*track_infos).push_back(TrackInfo(stream->label(), track->id(), ssrc));
   }
 
   void RemoveTrack(TrackInfos* track_infos, MediaStreamInterface* stream,
                    MediaStreamTrackInterface* track) {
     for (TrackInfos::iterator it = track_infos->begin();
          it != track_infos->end(); ++it) {
       if (it->stream_label == stream->label() && it->track_id == track->id()) {
         track_infos->erase(it);
         return;
       }
     }
     ADD_FAILURE();
   }
 
   const TrackInfo* FindTrackInfo(const TrackInfos& infos,
                                  const std::string& stream_label,
                                  const std::string track_id) const {
     for (TrackInfos::const_iterator it = infos.begin();
         it != infos.end(); ++it) {
       if (it->stream_label == stream_label && it->track_id == track_id)
         return &*it;
     }
     return NULL;
   }
 
   void VerifyTrack(const TrackInfos& track_infos,
                    const std::string& stream_label,
                    const std::string& track_id,
-                   uint32 ssrc) {
+                   uint32_t ssrc) {
     const TrackInfo* track_info = FindTrackInfo(track_infos,
                                                 stream_label,
                                                 track_id);
     ASSERT_TRUE(track_info != NULL);
     EXPECT_EQ(ssrc, track_info->ssrc);
   }
 
   TrackInfos remote_audio_tracks_;
   TrackInfos remote_video_tracks_;
   TrackInfos local_audio_tracks_;
@@ skipping 876 matching lines @@
   webrtc::WriteDataChannelOpenMessage("a", config, &payload);
   cricket::ReceiveDataParams params;
   params.ssrc = config.id;
   EXPECT_TRUE(signaling_->AddDataChannelFromOpenMessage(params, payload));
   EXPECT_TRUE(signaling_->HasDataChannels());
 
   // Removes the DataChannel and verifies that no DataChannel is left.
   signaling_->RemoveSctpDataChannel(config.id);
   EXPECT_FALSE(signaling_->HasDataChannels());
 }