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

talk/media/webrtc/webrtcvideoengine2.cc

 /*
  * libjingle
  * Copyright 2014 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 200 matching lines @@
   }
   return true;
 }
 
 static bool ValidateStreamParams(const StreamParams& sp) {
   if (sp.ssrcs.empty()) {
     LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString();
     return false;
   }
 
-  std::vector<uint32> primary_ssrcs;
+  std::vector<uint32_t> primary_ssrcs;
   sp.GetPrimarySsrcs(&primary_ssrcs);
-  std::vector<uint32> rtx_ssrcs;
+  std::vector<uint32_t> rtx_ssrcs;
   sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs);
   for (uint32_t rtx_ssrc : rtx_ssrcs) {
     bool rtx_ssrc_present = false;
     for (uint32_t sp_ssrc : sp.ssrcs) {
       if (sp_ssrc == rtx_ssrc) {
         rtx_ssrc_present = true;
         break;
       }
     }
     if (!rtx_ssrc_present) {
@@ skipping 681 matching lines @@
         << "Ignoring call to SetRecvCodecs because codecs haven't changed.";
     return true;
   }
 
   LOG(LS_INFO) << "Changing recv codecs from "
                << CodecSettingsVectorToString(recv_codecs_) << " to "
                << CodecSettingsVectorToString(supported_codecs);
   recv_codecs_ = supported_codecs;
 
   rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
+  for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
            receive_streams_.begin();
-       it != receive_streams_.end();
-       ++it) {
+       it != receive_streams_.end(); ++it) {
     it->second->SetRecvCodecs(recv_codecs_);
   }
 
   return true;
 }
 
 bool WebRtcVideoChannel2::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
   TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendCodecs");
   LOG(LS_INFO) << "SetSendCodecs: " << CodecVectorToString(codecs);
   if (!ValidateCodecFormats(codecs)) {
@@ skipping 66 matching lines @@
 bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) {
   VideoCodecSettings codec_settings;
   if (!send_codec_.Get(&codec_settings)) {
     LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
     return false;
   }
   *codec = codec_settings.codec;
   return true;
 }
 
-bool WebRtcVideoChannel2::SetSendStreamFormat(uint32 ssrc,
+bool WebRtcVideoChannel2::SetSendStreamFormat(uint32_t ssrc,
                                               const VideoFormat& format) {
   LOG(LS_VERBOSE) << "SetSendStreamFormat:" << ssrc << " -> "
                   << format.ToString();
   rtc::CritScope stream_lock(&stream_crit_);
   if (send_streams_.find(ssrc) == send_streams_.end()) {
     return false;
   }
   return send_streams_[ssrc]->SetVideoFormat(format);
 }
 
@@ skipping 11 matching lines @@
   }
   if (send) {
     StartAllSendStreams();
   } else {
     StopAllSendStreams();
   }
   sending_ = send;
   return true;
 }
 
-bool WebRtcVideoChannel2::SetVideoSend(uint32 ssrc, bool mute,
+bool WebRtcVideoChannel2::SetVideoSend(uint32_t ssrc,
+                                       bool mute,
                                        const VideoOptions* options) {
   // TODO(solenberg): The state change should be fully rolled back if any one of
   //                  these calls fail.
   if (!MuteStream(ssrc, mute)) {
     return false;
   }
   if (!mute && options) {
     return SetOptions(*options);
   } else {
     return true;
@@ skipping 26 matching lines @@
 bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
   LOG(LS_INFO) << "AddSendStream: " << sp.ToString();
   if (!ValidateStreamParams(sp))
     return false;
 
   rtc::CritScope stream_lock(&stream_crit_);
 
   if (!ValidateSendSsrcAvailability(sp))
     return false;
 
-  for (uint32 used_ssrc : sp.ssrcs)
+  for (uint32_t used_ssrc : sp.ssrcs)
     send_ssrcs_.insert(used_ssrc);
 
   webrtc::VideoSendStream::Config config(this);
   config.overuse_callback = this;
 
   WebRtcVideoSendStream* stream =
       new WebRtcVideoSendStream(call_,
                                 sp,
                                 config,
                                 external_encoder_factory_,
                                 options_,
                                 bitrate_config_.max_bitrate_bps,
                                 send_codec_,
                                 send_rtp_extensions_);
 
-  uint32 ssrc = sp.first_ssrc();
+  uint32_t ssrc = sp.first_ssrc();
   RTC_DCHECK(ssrc != 0);
   send_streams_[ssrc] = stream;
 
   if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) {
     rtcp_receiver_report_ssrc_ = ssrc;
     LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added "
                     "a send stream.";
     for (auto& kv : receive_streams_)
       kv.second->SetLocalSsrc(ssrc);
   }
   if (default_send_ssrc_ == 0) {
     default_send_ssrc_ = ssrc;
   }
   if (sending_) {
     stream->Start();
   }
 
   return true;
 }
 
-bool WebRtcVideoChannel2::RemoveSendStream(uint32 ssrc) {
+bool WebRtcVideoChannel2::RemoveSendStream(uint32_t ssrc) {
   LOG(LS_INFO) << "RemoveSendStream: " << ssrc;
 
   if (ssrc == 0) {
     if (default_send_ssrc_ == 0) {
       LOG(LS_ERROR) << "No default send stream active.";
       return false;
     }
 
     LOG(LS_VERBOSE) << "Removing default stream: " << default_send_ssrc_;
     ssrc = default_send_ssrc_;
   }
 
   WebRtcVideoSendStream* removed_stream;
   {
     rtc::CritScope stream_lock(&stream_crit_);
-    std::map<uint32, WebRtcVideoSendStream*>::iterator it =
+    std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
         send_streams_.find(ssrc);
     if (it == send_streams_.end()) {
       return false;
     }
 
-    for (uint32 old_ssrc : it->second->GetSsrcs())
+    for (uint32_t old_ssrc : it->second->GetSsrcs())
       send_ssrcs_.erase(old_ssrc);
 
     removed_stream = it->second;
     send_streams_.erase(it);
   }
 
   delete removed_stream;
 
   if (ssrc == default_send_ssrc_) {
     default_send_ssrc_ = 0;
   }
 
   return true;
 }
 
 void WebRtcVideoChannel2::DeleteReceiveStream(
     WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) {
-  for (uint32 old_ssrc : stream->GetSsrcs())
+  for (uint32_t old_ssrc : stream->GetSsrcs())
     receive_ssrcs_.erase(old_ssrc);
   delete stream;
 }
 
 bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) {
   return AddRecvStream(sp, false);
 }
 
 bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
                                         bool default_stream) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "")
                << ": " << sp.ToString();
   if (!ValidateStreamParams(sp))
     return false;
 
-  uint32 ssrc = sp.first_ssrc();
+  uint32_t ssrc = sp.first_ssrc();
   RTC_DCHECK(ssrc != 0);  // TODO(pbos): Is this ever valid?
 
   rtc::CritScope stream_lock(&stream_crit_);
   // Remove running stream if this was a default stream.
   auto prev_stream = receive_streams_.find(ssrc);
   if (prev_stream != receive_streams_.end()) {
     if (default_stream || !prev_stream->second->IsDefaultStream()) {
       LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc
                     << "' already exists.";
       return false;
     }
     DeleteReceiveStream(prev_stream->second);
     receive_streams_.erase(prev_stream);
   }
 
   if (!ValidateReceiveSsrcAvailability(sp))
     return false;
 
-  for (uint32 used_ssrc : sp.ssrcs)
+  for (uint32_t used_ssrc : sp.ssrcs)
     receive_ssrcs_.insert(used_ssrc);
 
   webrtc::VideoReceiveStream::Config config(this);
   ConfigureReceiverRtp(&config, sp);
 
   // Set up A/V sync group based on sync label.
   config.sync_group = sp.sync_label;
 
   config.rtp.remb = false;
   VideoCodecSettings send_codec;
   if (send_codec_.Get(&send_codec)) {
     config.rtp.remb = HasRemb(send_codec.codec);
   }
 
   receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
       call_, sp, config, external_decoder_factory_, default_stream,
       recv_codecs_);
 
   return true;
 }
 
 void WebRtcVideoChannel2::ConfigureReceiverRtp(
     webrtc::VideoReceiveStream::Config* config,
     const StreamParams& sp) const {
-  uint32 ssrc = sp.first_ssrc();
+  uint32_t ssrc = sp.first_ssrc();
 
   config->rtp.remote_ssrc = ssrc;
   config->rtp.local_ssrc = rtcp_receiver_report_ssrc_;
 
   config->rtp.extensions = recv_rtp_extensions_;
 
   // TODO(pbos): This protection is against setting the same local ssrc as
   // remote which is not permitted by the lower-level API. RTCP requires a
   // corresponding sender SSRC. Figure out what to do when we don't have
   // (receive-only) or know a good local SSRC.
   if (config->rtp.remote_ssrc == config->rtp.local_ssrc) {
     if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) {
       config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc;
     } else {
       config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1;
     }
   }
 
   for (size_t i = 0; i < recv_codecs_.size(); ++i) {
     MergeFecConfig(recv_codecs_[i].fec, &config->rtp.fec);
   }
 
   for (size_t i = 0; i < recv_codecs_.size(); ++i) {
-    uint32 rtx_ssrc;
+    uint32_t rtx_ssrc;
     if (recv_codecs_[i].rtx_payload_type != -1 &&
         sp.GetFidSsrc(ssrc, &rtx_ssrc)) {
       webrtc::VideoReceiveStream::Config::Rtp::Rtx& rtx =
           config->rtp.rtx[recv_codecs_[i].codec.id];
       rtx.ssrc = rtx_ssrc;
       rtx.payload_type = recv_codecs_[i].rtx_payload_type;
     }
   }
 }
 
-bool WebRtcVideoChannel2::RemoveRecvStream(uint32 ssrc) {
+bool WebRtcVideoChannel2::RemoveRecvStream(uint32_t ssrc) {
   LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
   if (ssrc == 0) {
     LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported.";
     return false;
   }
 
   rtc::CritScope stream_lock(&stream_crit_);
-  std::map<uint32, WebRtcVideoReceiveStream*>::iterator stream =
+  std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator stream =
       receive_streams_.find(ssrc);
   if (stream == receive_streams_.end()) {
     LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc;
     return false;
   }
   DeleteReceiveStream(stream->second);
   receive_streams_.erase(stream);
 
   return true;
 }
 
-bool WebRtcVideoChannel2::SetRenderer(uint32 ssrc, VideoRenderer* renderer) {
+bool WebRtcVideoChannel2::SetRenderer(uint32_t ssrc, VideoRenderer* renderer) {
   LOG(LS_INFO) << "SetRenderer: ssrc:" << ssrc << " "
                << (renderer ? "(ptr)" : "NULL");
   if (ssrc == 0) {
     default_unsignalled_ssrc_handler_.SetDefaultRenderer(this, renderer);
     return true;
   }
 
   rtc::CritScope stream_lock(&stream_crit_);
-  std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
+  std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
       receive_streams_.find(ssrc);
   if (it == receive_streams_.end()) {
     return false;
   }
 
   it->second->SetRenderer(renderer);
   return true;
 }
 
-bool WebRtcVideoChannel2::GetRenderer(uint32 ssrc, VideoRenderer** renderer) {
+bool WebRtcVideoChannel2::GetRenderer(uint32_t ssrc, VideoRenderer** renderer) {
   if (ssrc == 0) {
     *renderer = default_unsignalled_ssrc_handler_.GetDefaultRenderer();
     return *renderer != NULL;
   }
 
   rtc::CritScope stream_lock(&stream_crit_);
-  std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
+  std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
       receive_streams_.find(ssrc);
   if (it == receive_streams_.end()) {
     return false;
   }
   *renderer = it->second->GetRenderer();
   return true;
 }
 
 bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) {
   info->Clear();
   FillSenderStats(info);
   FillReceiverStats(info);
   webrtc::Call::Stats stats = call_->GetStats();
   FillBandwidthEstimationStats(stats, info);
   if (stats.rtt_ms != -1) {
     for (size_t i = 0; i < info->senders.size(); ++i) {
       info->senders[i].rtt_ms = stats.rtt_ms;
     }
   }
   return true;
 }
 
 void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info) {
   rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
+  for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
            send_streams_.begin();
-       it != send_streams_.end();
-       ++it) {
+       it != send_streams_.end(); ++it) {
     video_media_info->senders.push_back(it->second->GetVideoSenderInfo());
   }
 }
 
 void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info) {
   rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
+  for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
            receive_streams_.begin();
-       it != receive_streams_.end();
-       ++it) {
+       it != receive_streams_.end(); ++it) {
     video_media_info->receivers.push_back(it->second->GetVideoReceiverInfo());
   }
 }
 
 void WebRtcVideoChannel2::FillBandwidthEstimationStats(
     const webrtc::Call::Stats& stats,
     VideoMediaInfo* video_media_info) {
   BandwidthEstimationInfo bwe_info;
   bwe_info.available_send_bandwidth = stats.send_bandwidth_bps;
   bwe_info.available_recv_bandwidth = stats.recv_bandwidth_bps;
   bwe_info.bucket_delay = stats.pacer_delay_ms;
 
   // Get send stream bitrate stats.
   rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32, WebRtcVideoSendStream*>::iterator stream =
+  for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream =
            send_streams_.begin();
-       stream != send_streams_.end();
-       ++stream) {
+       stream != send_streams_.end(); ++stream) {
     stream->second->FillBandwidthEstimationInfo(&bwe_info);
   }
   video_media_info->bw_estimations.push_back(bwe_info);
 }
 
-bool WebRtcVideoChannel2::SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
+bool WebRtcVideoChannel2::SetCapturer(uint32_t ssrc, VideoCapturer* capturer) {
   LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
                << (capturer != NULL ? "(capturer)" : "NULL");
   RTC_DCHECK(ssrc != 0);
   {
     rtc::CritScope stream_lock(&stream_crit_);
     if (send_streams_.find(ssrc) == send_streams_.end()) {
       LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
       return false;
     }
     if (!send_streams_[ssrc]->SetCapturer(capturer)) {
@@ skipping 37 matching lines @@
           webrtc_packet_time);
   switch (delivery_result) {
     case webrtc::PacketReceiver::DELIVERY_OK:
       return;
     case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR:
       return;
     case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC:
       break;
   }
 
-  uint32 ssrc = 0;
+  uint32_t ssrc = 0;
   if (!GetRtpSsrc(packet->data(), packet->size(), &ssrc)) {
     return;
   }
 
   int payload_type = 0;
   if (!GetRtpPayloadType(packet->data(), packet->size(), &payload_type)) {
     return;
   }
 
   // See if this payload_type is registered as one that usually gets its own
@@ skipping 36 matching lines @@
           webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) {
     LOG(LS_WARNING) << "Failed to deliver RTCP packet.";
   }
 }
 
 void WebRtcVideoChannel2::OnReadyToSend(bool ready) {
   LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
   call_->SignalNetworkState(ready ? webrtc::kNetworkUp : webrtc::kNetworkDown);
 }
 
-bool WebRtcVideoChannel2::MuteStream(uint32 ssrc, bool mute) {
+bool WebRtcVideoChannel2::MuteStream(uint32_t ssrc, bool mute) {
   LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> "
                   << (mute ? "mute" : "unmute");
   RTC_DCHECK(ssrc != 0);
   rtc::CritScope stream_lock(&stream_crit_);
   if (send_streams_.find(ssrc) == send_streams_.end()) {
     LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc;
     return false;
   }
 
   send_streams_[ssrc]->MuteStream(mute);
@@ skipping 12 matching lines @@
       FilterRtpExtensions(extensions);
   if (!RtpExtensionsHaveChanged(recv_rtp_extensions_, filtered_extensions)) {
     LOG(LS_INFO) << "Ignoring call to SetRecvRtpHeaderExtensions because "
                     "header extensions haven't changed.";
     return true;
   }
 
   recv_rtp_extensions_ = filtered_extensions;
 
   rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32, WebRtcVideoReceiveStream*>::iterator it =
+  for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it =
            receive_streams_.begin();
-       it != receive_streams_.end();
-       ++it) {
+       it != receive_streams_.end(); ++it) {
     it->second->SetRtpExtensions(recv_rtp_extensions_);
   }
   return true;
 }
 
 bool WebRtcVideoChannel2::SetSendRtpHeaderExtensions(
     const std::vector<RtpHeaderExtension>& extensions) {
   TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendRtpHeaderExtensions");
   LOG(LS_INFO) << "SetSendRtpHeaderExtensions: "
                << RtpExtensionsToString(extensions);
   if (!ValidateRtpHeaderExtensionIds(extensions))
     return false;
 
   std::vector<webrtc::RtpExtension> filtered_extensions =
       FilterRtpExtensions(extensions);
   if (!RtpExtensionsHaveChanged(send_rtp_extensions_, filtered_extensions)) {
     LOG(LS_INFO) << "Ignoring call to SetSendRtpHeaderExtensions because "
                     "header extensions haven't changed.";
     return true;
   }
 
   send_rtp_extensions_ = filtered_extensions;
 
   const webrtc::RtpExtension* cvo_extension = FindHeaderExtension(
       send_rtp_extensions_, kRtpVideoRotationHeaderExtension);
 
   rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
+  for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
            send_streams_.begin();
-       it != send_streams_.end();
-       ++it) {
+       it != send_streams_.end(); ++it) {
     it->second->SetRtpExtensions(send_rtp_extensions_);
     it->second->SetApplyRotation(!cvo_extension);
   }
   return true;
 }
 
 // Counter-intuitively this method doesn't only set global bitrate caps but also
 // per-stream codec max bitrates. This is to permit SetMaxSendBitrate (b=AS) to
 // raise bitrates above the 2000k default bitrate cap.
 bool WebRtcVideoChannel2::SetMaxSendBandwidth(int max_bitrate_bps) {
@@ skipping 37 matching lines @@
   }
   {
     rtc::CritScope lock(&capturer_crit_);
     options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
   }
   rtc::DiffServCodePoint dscp = options_.dscp.GetWithDefaultIfUnset(false)
                                     ? rtc::DSCP_AF41
                                     : rtc::DSCP_DEFAULT;
   MediaChannel::SetDscp(dscp);
   rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
+  for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
            send_streams_.begin();
-       it != send_streams_.end();
-       ++it) {
+       it != send_streams_.end(); ++it) {
     it->second->SetOptions(options_);
   }
   return true;
 }
 
 void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) {
   MediaChannel::SetInterface(iface);
   // Set the RTP recv/send buffer to a bigger size
   MediaChannel::SetOption(NetworkInterface::ST_RTP,
                           rtc::Socket::OPT_RCVBUF,
@@ skipping 41 matching lines @@
   return MediaChannel::SendPacket(&packet);
 }
 
 bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) {
   rtc::Buffer packet(data, len, kMaxRtpPacketLen);
   return MediaChannel::SendRtcp(&packet);
 }
 
 void WebRtcVideoChannel2::StartAllSendStreams() {
   rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
+  for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
            send_streams_.begin();
-       it != send_streams_.end();
-       ++it) {
+       it != send_streams_.end(); ++it) {
     it->second->Start();
   }
 }
 
 void WebRtcVideoChannel2::StopAllSendStreams() {
   rtc::CritScope stream_lock(&stream_crit_);
-  for (std::map<uint32, WebRtcVideoSendStream*>::iterator it =
+  for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
            send_streams_.begin();
-       it != send_streams_.end();
-       ++it) {
+       it != send_streams_.end(); ++it) {
     it->second->Stop();
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
     VideoSendStreamParameters(
         const webrtc::VideoSendStream::Config& config,
         const VideoOptions& options,
         int max_bitrate_bps,
         const Settable<VideoCodecSettings>& codec_settings)
@@ skipping 204 matching lines @@
     if (capturer_->video_adapter() != nullptr)
       old_adapt_changes_ += capturer_->video_adapter()->adaptation_changes();
 
     capturer = capturer_;
     capturer_ = NULL;
   }
   capturer->SignalVideoFrame.disconnect(this);
   return true;
 }
 
-const std::vector<uint32>&
+const std::vector<uint32_t>&
 WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const {
   return ssrcs_;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetApplyRotation(
     bool apply_rotation) {
   rtc::CritScope cs(&lock_);
   if (capturer_ == NULL)
     return;
 
@@ skipping 442 matching lines @@
     this->decoder =
         new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder);
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
   call_->DestroyVideoReceiveStream(stream_);
   ClearDecoders(&allocated_decoders_);
 }
 
-const std::vector<uint32>&
+const std::vector<uint32_t>&
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const {
   return ssrcs_;
 }
 
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder(
     std::vector<AllocatedDecoder>* old_decoders,
     const VideoCodec& codec) {
   webrtc::VideoCodecType type = CodecTypeFromName(codec.name);
 
@@ skipping 352 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO