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

talk/app/webrtc/mediastreamhandler.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 15 matching lines @@
  */
 
 #include "talk/app/webrtc/mediastreamhandler.h"
 
 #include "talk/app/webrtc/localaudiosource.h"
 #include "talk/app/webrtc/videosource.h"
 #include "talk/app/webrtc/videosourceinterface.h"
 
 namespace webrtc {
 
-TrackHandler::TrackHandler(MediaStreamTrackInterface* track, uint32 ssrc)
+TrackHandler::TrackHandler(MediaStreamTrackInterface* track, uint32_t ssrc)
     : track_(track),
       ssrc_(ssrc),
       state_(track->state()),
       enabled_(track->enabled()) {
   track_->RegisterObserver(this);
 }
 
 TrackHandler::~TrackHandler() {
   track_->UnregisterObserver(this);
 }
@@ skipping 28 matching lines @@
                   number_of_channels, number_of_frames);
   }
 }
 
 void LocalAudioSinkAdapter::SetSink(cricket::AudioRenderer::Sink* sink) {
   rtc::CritScope lock(&lock_);
   ASSERT(!sink || !sink_);
   sink_ = sink;
 }
 
-LocalAudioTrackHandler::LocalAudioTrackHandler(
-    AudioTrackInterface* track,
-    uint32 ssrc,
-    AudioProviderInterface* provider)
+LocalAudioTrackHandler::LocalAudioTrackHandler(AudioTrackInterface* track,
+                                               uint32_t ssrc,
+                                               AudioProviderInterface* provider)
     : TrackHandler(track, ssrc),
       audio_track_(track),
       provider_(provider),
       sink_adapter_(new LocalAudioSinkAdapter()) {
   OnEnabledChanged();
   track->AddSink(sink_adapter_.get());
 }
 
 LocalAudioTrackHandler::~LocalAudioTrackHandler() {
 }
@@ skipping 20 matching lines @@
   // Use the renderer if the audio track has one, otherwise use the sink
   // adapter owned by this class.
   cricket::AudioRenderer* renderer = audio_track_->GetRenderer() ?
       audio_track_->GetRenderer() : sink_adapter_.get();
   ASSERT(renderer != NULL);
   provider_->SetAudioSend(ssrc(), audio_track_->enabled(), options, renderer);
 }
 
 RemoteAudioTrackHandler::RemoteAudioTrackHandler(
     AudioTrackInterface* track,
-    uint32 ssrc,
+    uint32_t ssrc,
     AudioProviderInterface* provider)
-    : TrackHandler(track, ssrc),
-      audio_track_(track),
-      provider_(provider) {
+    : TrackHandler(track, ssrc), audio_track_(track), provider_(provider) {
   track->GetSource()->RegisterAudioObserver(this);
   OnEnabledChanged();
 }
 
 RemoteAudioTrackHandler::~RemoteAudioTrackHandler() {
   audio_track_->GetSource()->UnregisterAudioObserver(this);
 }
 
 void RemoteAudioTrackHandler::Stop() {
   provider_->SetAudioPlayout(ssrc(), false, NULL);
 }
 
 void RemoteAudioTrackHandler::OnStateChanged() {
 }
 
 void RemoteAudioTrackHandler::OnEnabledChanged() {
   provider_->SetAudioPlayout(ssrc(), audio_track_->enabled(),
                              audio_track_->GetRenderer());
 }
 
 void RemoteAudioTrackHandler::OnSetVolume(double volume) {
   // When the track is disabled, the volume of the source, which is the
   // corresponding WebRtc Voice Engine channel will be 0. So we do not allow
   // setting the volume to the source when the track is disabled.
   if (audio_track_->enabled())
     provider_->SetAudioPlayoutVolume(ssrc(), volume);
 }
 
-LocalVideoTrackHandler::LocalVideoTrackHandler(
-    VideoTrackInterface* track,
-    uint32 ssrc,
-    VideoProviderInterface* provider)
+LocalVideoTrackHandler::LocalVideoTrackHandler(VideoTrackInterface* track,
+                                               uint32_t ssrc,
+                                               VideoProviderInterface* provider)
     : TrackHandler(track, ssrc),
       local_video_track_(track),
       provider_(provider) {
   VideoSourceInterface* source = local_video_track_->GetSource();
   if (source)
     provider_->SetCaptureDevice(ssrc, source->GetVideoCapturer());
   OnEnabledChanged();
 }
 
 LocalVideoTrackHandler::~LocalVideoTrackHandler() {
@@ skipping 11 matching lines @@
   const cricket::VideoOptions* options = NULL;
   VideoSourceInterface* source = local_video_track_->GetSource();
   if (local_video_track_->enabled() && source) {
     options = source->options();
   }
   provider_->SetVideoSend(ssrc(), local_video_track_->enabled(), options);
 }
 
 RemoteVideoTrackHandler::RemoteVideoTrackHandler(
     VideoTrackInterface* track,
-    uint32 ssrc,
+    uint32_t ssrc,
     VideoProviderInterface* provider)
     : TrackHandler(track, ssrc),
       remote_video_track_(track),
       provider_(provider) {
   OnEnabledChanged();
   provider_->SetVideoPlayout(ssrc, true,
                              remote_video_track_->GetSource()->FrameInput());
 }
 
 RemoteVideoTrackHandler::~RemoteVideoTrackHandler() {
@@ skipping 69 matching lines @@
     MediaStreamInterface* stream,
     AudioProviderInterface* audio_provider,
     VideoProviderInterface* video_provider)
     : MediaStreamHandler(stream, audio_provider, video_provider) {
 }
 
 LocalMediaStreamHandler::~LocalMediaStreamHandler() {
 }
 
 void LocalMediaStreamHandler::AddAudioTrack(AudioTrackInterface* audio_track,
-                                            uint32 ssrc) {
+                                            uint32_t ssrc) {
   ASSERT(!FindTrackHandler(audio_track));
 
   TrackHandler* handler(new LocalAudioTrackHandler(audio_track, ssrc,
                                                    audio_provider_));
   track_handlers_.push_back(handler);
 }
 
 void LocalMediaStreamHandler::AddVideoTrack(VideoTrackInterface* video_track,
-                                            uint32 ssrc) {
+                                            uint32_t ssrc) {
   ASSERT(!FindTrackHandler(video_track));
 
   TrackHandler* handler(new LocalVideoTrackHandler(video_track, ssrc,
                                                    video_provider_));
   track_handlers_.push_back(handler);
 }
 
 RemoteMediaStreamHandler::RemoteMediaStreamHandler(
     MediaStreamInterface* stream,
     AudioProviderInterface* audio_provider,
     VideoProviderInterface* video_provider)
     : MediaStreamHandler(stream, audio_provider, video_provider) {
 }
 
 RemoteMediaStreamHandler::~RemoteMediaStreamHandler() {
 }
 
 void RemoteMediaStreamHandler::AddAudioTrack(AudioTrackInterface* audio_track,
-                                             uint32 ssrc) {
+                                             uint32_t ssrc) {
   ASSERT(!FindTrackHandler(audio_track));
   TrackHandler* handler(
       new RemoteAudioTrackHandler(audio_track, ssrc, audio_provider_));
   track_handlers_.push_back(handler);
 }
 
 void RemoteMediaStreamHandler::AddVideoTrack(VideoTrackInterface* video_track,
-                                             uint32 ssrc) {
+                                             uint32_t ssrc) {
   ASSERT(!FindTrackHandler(video_track));
   TrackHandler* handler(
       new RemoteVideoTrackHandler(video_track, ssrc, video_provider_));
   track_handlers_.push_back(handler);
 }
 
 MediaStreamHandlerContainer::MediaStreamHandlerContainer(
     AudioProviderInterface* audio_provider,
     VideoProviderInterface* video_provider)
     : audio_provider_(audio_provider),
@@ skipping 21 matching lines @@
 }
 
 void MediaStreamHandlerContainer::RemoveRemoteStream(
     MediaStreamInterface* stream) {
   DeleteStreamHandler(&remote_streams_handlers_, stream);
 }
 
 void MediaStreamHandlerContainer::AddRemoteAudioTrack(
     MediaStreamInterface* stream,
     AudioTrackInterface* audio_track,
-    uint32 ssrc) {
+    uint32_t ssrc) {
   MediaStreamHandler* handler = FindStreamHandler(remote_streams_handlers_,
                                                   stream);
   if (handler == NULL) {
     handler = CreateRemoteStreamHandler(stream);
   }
   handler->AddAudioTrack(audio_track, ssrc);
 }
 
 void MediaStreamHandlerContainer::AddRemoteVideoTrack(
     MediaStreamInterface* stream,
     VideoTrackInterface* video_track,
-    uint32 ssrc) {
+    uint32_t ssrc) {
   MediaStreamHandler* handler = FindStreamHandler(remote_streams_handlers_,
                                                   stream);
   if (handler == NULL) {
     handler = CreateRemoteStreamHandler(stream);
   }
   handler->AddVideoTrack(video_track, ssrc);
 }
 
 void MediaStreamHandlerContainer::RemoveRemoteTrack(
     MediaStreamInterface* stream,
     MediaStreamTrackInterface* track) {
   MediaStreamHandler* handler = FindStreamHandler(remote_streams_handlers_,
                                                   stream);
   if (!VERIFY(handler != NULL)) {
     LOG(LS_WARNING) << "Local MediaStreamHandler for stream  with id "
                     << stream->label() << "doesnt't exist.";
     return;
   }
   handler->RemoveTrack(track);
 }
 
 void MediaStreamHandlerContainer::RemoveLocalStream(
     MediaStreamInterface* stream) {
   DeleteStreamHandler(&local_streams_handlers_, stream);
 }
 
 void MediaStreamHandlerContainer::AddLocalAudioTrack(
     MediaStreamInterface* stream,
     AudioTrackInterface* audio_track,
-    uint32 ssrc) {
+    uint32_t ssrc) {
   MediaStreamHandler* handler = FindStreamHandler(local_streams_handlers_,
                                                   stream);
   if (handler == NULL) {
     handler = CreateLocalStreamHandler(stream);
   }
   handler->AddAudioTrack(audio_track, ssrc);
 }
 
 void MediaStreamHandlerContainer::AddLocalVideoTrack(
     MediaStreamInterface* stream,
     VideoTrackInterface* video_track,
-    uint32 ssrc) {
+    uint32_t ssrc) {
   MediaStreamHandler* handler = FindStreamHandler(local_streams_handlers_,
                                                   stream);
   if (handler == NULL) {
     handler = CreateLocalStreamHandler(stream);
   }
   handler->AddVideoTrack(video_track, ssrc);
 }
 
 void MediaStreamHandlerContainer::RemoveLocalTrack(
     MediaStreamInterface* stream,
@@ skipping 47 matching lines @@
     if ((*it)->stream() == stream) {
       (*it)->Stop();
       delete *it;
       streamhandlers->erase(it);
       break;
     }
   }
 }
 
 }  // namespace webrtc