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

talk/session/media/channel.cc

 /*
  * libjingle
  * Copyright 2004 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 53 matching lines @@
     *error_desc = message;
   }
 }
 
 struct PacketMessageData : public rtc::MessageData {
   rtc::Buffer packet;
   rtc::DiffServCodePoint dscp;
 };
 
 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;
 };
 
 static const char* PacketType(bool rtcp) {
   return (!rtcp) ? "RTP" : "RTCP";
 }
 
 static bool ValidPacket(bool rtcp, const rtc::Buffer* packet) {
   // Check the packet size. We could check the header too if needed.
@@ skipping 231 matching lines @@
   worker_thread_->Invoke<void>(Bind(
       enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w,
       this));
   return true;
 }
 
 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));
 }
 
 bool BaseChannel::AddSendStream(const StreamParams& sp) {
   return InvokeOnWorker(
       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));
 }
 
 bool BaseChannel::SetLocalContent(const MediaContentDescription* content,
                                   ContentAction action,
                                   std::string* error_desc) {
   return InvokeOnWorker(Bind(&BaseChannel::SetLocalContent_w,
                              this, content, action, error_desc));
 }
@@ skipping 171 matching lines @@
       res = srtp_filter_.ProtectRtp(
           data, len, static_cast<int>(packet->capacity()), &len);
 #else
       options.packet_time_params.rtp_sendtime_extension_id =
           rtp_abs_sendtime_extn_id_;
       res = srtp_filter_.ProtectRtp(
           data, len, static_cast<int>(packet->capacity()), &len,
           &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);
         if (res) {
           options.packet_time_params.srtp_auth_key.resize(key_len);
           options.packet_time_params.srtp_auth_key.assign(auth_key,
                                                           auth_key + key_len);
         }
       }
 #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_
                       << " RTP packet: size=" << len
                       << ", seqnum=" << seq_num << ", SSRC=" << ssrc;
         return false;
       }
     } else {
       res = srtp_filter_.ProtectRtcp(data, len,
                                      static_cast<int>(packet->capacity()),
@@ skipping 60 matching lines @@
 
   // Unprotect the packet, if needed.
   if (srtp_filter_.IsActive()) {
     char* data = packet->data<char>();
     int len = static_cast<int>(packet->size());
     bool res;
     if (!rtcp) {
       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_
                       << " RTP packet: size=" << len
                       << ", seqnum=" << seq_num << ", SSRC=" << ssrc;
         return;
       }
     } else {
       res = srtp_filter_.UnprotectRtcp(data, len, &len);
       if (!res) {
@@ skipping 405 matching lines @@
 }
 
 bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
   ASSERT(worker_thread() == rtc::Thread::Current());
   if (!media_channel()->AddRecvStream(sp))
     return false;
 
   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);
 }
 
 bool BaseChannel::UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
                                        ContentAction action,
                                        std::string* error_desc) {
   if (!VERIFY(action == CA_OFFER || action == CA_ANSWER ||
               action == CA_PRANSWER || action == CA_UPDATE))
@@ skipping 197 matching lines @@
   Deinit();
 }
 
 bool VoiceChannel::Init() {
   if (!BaseChannel::Init()) {
     return false;
   }
   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 VoiceChannel::SetAudioSend(uint32_t ssrc,
                                 bool enable,
                                 const AudioOptions* options,
                                 AudioRenderer* renderer) {
   return InvokeOnWorker(Bind(&VoiceMediaChannel::SetAudioSend, media_channel(),
                              ssrc, enable, options, renderer));
 }
 
 // TODO(juberti): Handle early media the right way. We should get an explicit
 // ringing message telling us to start playing local ringback, which we cancel
 // if any early media actually arrives. For now, we do the opposite, which is
@@ skipping 17 matching lines @@
   }
   int duration_ms = 160;
   return InsertDtmf(0, digit, duration_ms, flags);
 }
 
 bool VoiceChannel::CanInsertDtmf() {
   return InvokeOnWorker(Bind(&VoiceMediaChannel::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));
 }
 
 bool VoiceChannel::GetStats(VoiceMediaInfo* stats) {
   return InvokeOnWorker(Bind(&VoiceMediaChannel::GetStats,
                              media_channel(), stats));
 }
 
 void VoiceChannel::StartMediaMonitor(int cms) {
@@ skipping 173 matching lines @@
 }
 
 void VoiceChannel::HandleEarlyMediaTimeout() {
   // This occurs on the main thread, not the worker thread.
   if (!received_media_) {
     LOG(LS_INFO) << "No early media received before timeout";
     SignalEarlyMediaTimeout(this);
   }
 }
 
-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;
   }
 
   return media_channel()->InsertDtmf(ssrc, event, duration, flags);
 }
 
 void VoiceChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
@@ skipping 47 matching lines @@
       previous_we_(rtc::WE_CLOSE) {}
 
 bool VideoChannel::Init() {
   if (!BaseChannel::Init()) {
     return false;
   }
   return true;
 }
 
 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)) {
       LOG(LS_ERROR) << "Unable to delete screencast with ssrc "
                     << screencast_capturers_.begin()->first;
       ASSERT(false);
       break;
     }
   }
 
   StopMediaMonitor();
   // this can't be done in the base class, since it calls a virtual
   DisableMedia_w();
 
   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;
 }
 
 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));
 }
 
 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));
   return data.screencast_max_pixels;
 }
 
 bool VideoChannel::SendIntraFrame() {
   worker_thread()->Invoke<void>(Bind(
       &VideoMediaChannel::SendIntraFrame, media_channel()));
   return true;
 }
 
 bool VideoChannel::RequestIntraFrame() {
   worker_thread()->Invoke<void>(Bind(
       &VideoMediaChannel::RequestIntraFrame, media_channel()));
   return true;
 }
 
-bool VideoChannel::SetVideoSend(uint32 ssrc,
+bool VideoChannel::SetVideoSend(uint32_t ssrc,
                                 bool mute,
                                 const VideoOptions* options) {
   return InvokeOnWorker(Bind(&VideoMediaChannel::SetVideoSend, media_channel(),
                              ssrc, mute, options));
 }
 
 void VideoChannel::ChangeState() {
   // Send outgoing data if we're the active call, we have the remote content,
   // and we have had some form of connectivity.
   bool send = IsReadyToSend();
@@ skipping 153 matching lines @@
                       << it->selector.ssrc << ", '"
                       << it->selector.groupid << "', '"
                       << it->selector.streamid << "'"
                       << ") is not in the local streams.";
     }
   }
 
   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;
   }
   capturer->SignalStateChange.connect(this, &VideoChannel::OnStateChange);
   screencast_capturers_[ssrc] = 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;
   }
   // Clean up VideoCapturer.
   delete iter->second;
   screencast_capturers_.erase(iter);
   return true;
 }
 
 bool VideoChannel::IsScreencasting_w() const {
   return !screencast_capturers_.empty();
 }
 
 void VideoChannel::GetScreencastDetails_w(
     ScreencastDetailsData* data) const {
   ScreencastMap::const_iterator iter = screencast_capturers_.find(data->ssrc);
   if (iter == screencast_capturers_.end()) {
     return;
   }
   VideoCapturer* capturer = iter->second;
   const VideoFormat* video_format = capturer->GetCaptureFormat();
   data->fps = VideoFormat::IntervalToFps(video_format->interval);
   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);
 }
 
 void VideoChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_SCREENCASTWINDOWEVENT: {
       const ScreencastEventMessageData* data =
           static_cast<ScreencastEventMessageData*>(pmsg->pdata);
@@ skipping 19 matching lines @@
 }
 
 // TODO(pthatcher): Look into removing duplicate code between
 // audio, video, and data, perhaps by using templates.
 void VideoChannel::OnMediaMonitorUpdate(
     VideoMediaChannel* media_channel, const VideoMediaInfo &info) {
   ASSERT(media_channel == this->media_channel());
   SignalMediaMonitor(this, info);
 }
 
-void VideoChannel::OnScreencastWindowEvent(uint32 ssrc,
+void VideoChannel::OnScreencastWindowEvent(uint32_t ssrc,
                                            rtc::WindowEvent event) {
   ScreencastEventMessageData* pdata =
       new ScreencastEventMessageData(ssrc, event);
   signaling_thread()->Post(this, MSG_SCREENCASTWINDOWEVENT, pdata);
 }
 
 void VideoChannel::OnStateChange(VideoCapturer* capturer, CaptureState ev) {
   // Map capturer events to window events. In the future we may want to simply
   // pass these events up directly.
   rtc::WindowEvent we;
   if (ev == CS_STOPPED) {
     we = rtc::WE_CLOSE;
   } else if (ev == CS_PAUSED) {
     we = rtc::WE_MINIMIZE;
   } else if (ev == CS_RUNNING && previous_we_ == rtc::WE_MINIMIZE) {
     we = rtc::WE_RESTORE;
   } else {
     return;
   }
   previous_we_ = we;
 
-  uint32 ssrc = 0;
+  uint32_t ssrc = 0;
   if (!GetLocalSsrc(capturer, &ssrc)) {
     return;
   }
 
   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) {
     if (iter->second == capturer) {
       *ssrc = iter->first;
       return true;
     }
   }
   return false;
 }
@@ skipping 238 matching lines @@
       delete data;
       break;
     }
     case MSG_CHANNEL_ERROR: {
       const DataChannelErrorMessageData* data =
           static_cast<DataChannelErrorMessageData*>(pmsg->pdata);
       delete data;
       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;
     }
     default:
       BaseChannel::OnMessage(pmsg);
       break;
   }
 }
 
@@ skipping 24 matching lines @@
   SignalMediaMonitor(this, info);
 }
 
 void DataChannel::OnDataReceived(
     const ReceiveDataParams& params, const char* data, size_t len) {
   DataReceivedMessageData* msg = new DataReceivedMessageData(
       params, data, len);
   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);
 }
 
 void DataChannel::OnDataChannelReadyToSend(bool writable) {
   // This is usded for congestion control to indicate that the stream is ready
   // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates
   // that the transport channel is ready.
   signaling_thread()->Post(this, MSG_READYTOSENDDATA,
                            new DataChannelReadyToSendMessageData(writable));
 }
 
 void DataChannel::GetSrtpCryptoSuiteNames(
     std::vector<std::string>* ciphers) const {
   GetSupportedDataCryptoSuites(ciphers);
 }
 
 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);
 }
 
 }  // namespace cricket