Add RTC_ prefix to (D)CHECKs and related macros.

talk/media/webrtc/webrtcvoiceengine.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 313 matching lines @@
   voe_codec->rate = GetOpusBitrate(codec, *max_playback_rate);
 }
 
 // Changes RTP timestamp rate of G722. This is due to the "bug" in the RFC
 // which says that G722 should be advertised as 8 kHz although it is a 16 kHz
 // codec.
 static void MaybeFixupG722(webrtc::CodecInst* voe_codec, int new_plfreq) {
   if (IsCodec(*voe_codec, kG722CodecName)) {
     // If the ASSERT triggers, the codec definition in WebRTC VoiceEngine
     // has changed, and this special case is no longer needed.
-    DCHECK(voe_codec->plfreq != new_plfreq);
+    RTC_DCHECK(voe_codec->plfreq != new_plfreq);
     voe_codec->plfreq = new_plfreq;
   }
 }
 
 // Gets the default set of options applied to the engine. Historically, these
 // were supplied as a combination of flags from the channel manager (ec, agc,
 // ns, and highpass) and the rest hardcoded in InitInternal.
 static AudioOptions GetDefaultEngineOptions() {
   AudioOptions options;
   options.echo_cancellation.Set(true);
@@ skipping 141 matching lines @@
   if (voe_wrapper_->base()->DeRegisterVoiceEngineObserver() == -1) {
     LOG_RTCERR0(DeRegisterVoiceEngineObserver);
   }
   if (adm_) {
     voe_wrapper_.reset();
     adm_->Release();
     adm_ = NULL;
   }
 
   // Test to see if the media processor was deregistered properly
-  DCHECK(SignalRxMediaFrame.is_empty());
-  DCHECK(SignalTxMediaFrame.is_empty());
+  RTC_DCHECK(SignalRxMediaFrame.is_empty());
+  RTC_DCHECK(SignalTxMediaFrame.is_empty());
 
   tracing_->SetTraceCallback(NULL);
 }
 
 bool WebRtcVoiceEngine::Init(rtc::Thread* worker_thread) {
-  DCHECK(worker_thread == rtc::Thread::Current());
+  RTC_DCHECK(worker_thread == rtc::Thread::Current());
   LOG(LS_INFO) << "WebRtcVoiceEngine::Init";
   bool res = InitInternal();
   if (res) {
     LOG(LS_INFO) << "WebRtcVoiceEngine::Init Done!";
   } else {
     LOG(LS_ERROR) << "WebRtcVoiceEngine::Init failed";
     Terminate();
   }
   return res;
 }
@@ skipping 550 matching lines @@
   unsigned int ulevel;
   if (voe_wrapper_->volume()->GetSpeakerVolume(ulevel) == -1) {
     LOG_RTCERR1(GetSpeakerVolume, level);
     return false;
   }
   *level = ulevel;
   return true;
 }
 
 bool WebRtcVoiceEngine::SetOutputVolume(int level) {
-  DCHECK(level >= 0 && level <= 255);
+  RTC_DCHECK(level >= 0 && level <= 255);
   if (voe_wrapper_->volume()->SetSpeakerVolume(level) == -1) {
     LOG_RTCERR1(SetSpeakerVolume, level);
     return false;
   }
   return true;
 }
 
 int WebRtcVoiceEngine::GetInputLevel() {
   unsigned int ulevel;
   return (voe_wrapper_->volume()->GetSpeechInputLevel(ulevel) != -1) ?
@@ skipping 212 matching lines @@
   }
 }
 
 void WebRtcVoiceEngine::CallbackOnError(int channel_num, int err_code) {
   rtc::CritScope lock(&channels_cs_);
   WebRtcVoiceMediaChannel* channel = NULL;
   uint32 ssrc = 0;
   LOG(LS_WARNING) << "VoiceEngine error " << err_code << " reported on channel "
                   << channel_num << ".";
   if (FindChannelAndSsrc(channel_num, &channel, &ssrc)) {
-    DCHECK(channel != NULL);
+    RTC_DCHECK(channel != NULL);
     channel->OnError(ssrc, err_code);
   } else {
     LOG(LS_ERROR) << "VoiceEngine channel " << channel_num
                   << " could not be found in channel list when error reported.";
   }
 }
 
 bool WebRtcVoiceEngine::FindChannelAndSsrc(
     int channel_num, WebRtcVoiceMediaChannel** channel, uint32* ssrc) const {
-  DCHECK(channel != NULL && ssrc != NULL);
+  RTC_DCHECK(channel != NULL && ssrc != NULL);
 
   *channel = NULL;
   *ssrc = 0;
   // Find corresponding channel and ssrc
   for (WebRtcVoiceMediaChannel* ch : channels_) {
-    DCHECK(ch != NULL);
+    RTC_DCHECK(ch != NULL);
     if (ch->FindSsrc(channel_num, ssrc)) {
       *channel = ch;
       return true;
     }
   }
 
   return false;
 }
 
 // This method will search through the WebRtcVoiceMediaChannels and
 // obtain the voice engine's channel number.
 bool WebRtcVoiceEngine::FindChannelNumFromSsrc(
     uint32 ssrc, MediaProcessorDirection direction, int* channel_num) {
-  DCHECK(channel_num != NULL);
-  DCHECK(direction == MPD_RX || direction == MPD_TX);
+  RTC_DCHECK(channel_num != NULL);
+  RTC_DCHECK(direction == MPD_RX || direction == MPD_TX);
 
   *channel_num = -1;
   // Find corresponding channel for ssrc.
   for (const WebRtcVoiceMediaChannel* ch : channels_) {
-    DCHECK(ch != NULL);
+    RTC_DCHECK(ch != NULL);
     if (direction & MPD_RX) {
       *channel_num = ch->GetReceiveChannelNum(ssrc);
     }
     if (*channel_num == -1 && (direction & MPD_TX)) {
       *channel_num = ch->GetSendChannelNum(ssrc);
     }
     if (*channel_num != -1) {
       return true;
     }
   }
@@ skipping 261 matching lines @@
         voe_audio_transport_(voe_audio_transport),
         renderer_(NULL) {}
   ~WebRtcVoiceChannelRenderer() override { Stop(); }
 
   // Starts the rendering by setting a sink to the renderer to get data
   // callback.
   // This method is called on the libjingle worker thread.
   // TODO(xians): Make sure Start() is called only once.
   void Start(AudioRenderer* renderer) {
     rtc::CritScope lock(&lock_);
-    DCHECK(renderer != NULL);
+    RTC_DCHECK(renderer != NULL);
     if (renderer_ != NULL) {
-      DCHECK(renderer_ == renderer);
+      RTC_DCHECK(renderer_ == renderer);
       return;
     }
 
     // TODO(xians): Remove AddChannel() call after Chrome turns on APM
     // in getUserMedia by default.
     renderer->AddChannel(channel_);
     renderer->SetSink(this);
     renderer_ = renderer;
   }
 
@@ skipping 63 matching lines @@
       nack_enabled_(false),
       playout_(false),
       typing_noise_detected_(false),
       desired_send_(SEND_NOTHING),
       send_(SEND_NOTHING),
       call_(call),
       default_receive_ssrc_(0) {
   engine->RegisterChannel(this);
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel "
                   << voe_channel();
-  DCHECK(nullptr != call);
+  RTC_DCHECK(nullptr != call);
   ConfigureSendChannel(voe_channel());
 }
 
 WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel "
                   << voe_channel();
 
   // Remove any remaining send streams, the default channel will be deleted
   // later.
   while (!send_channels_.empty())
     RemoveSendStream(send_channels_.begin()->first);
 
   // Unregister ourselves from the engine.
   engine()->UnregisterChannel(this);
   // Remove any remaining streams.
   while (!receive_channels_.empty()) {
     RemoveRecvStream(receive_channels_.begin()->first);
   }
-  DCHECK(receive_streams_.empty());
+  RTC_DCHECK(receive_streams_.empty());
 
   // Delete the default channel.
   DeleteChannel(voe_channel());
 }
 
 bool WebRtcVoiceMediaChannel::SetSendParameters(
     const AudioSendParameters& params) {
   // TODO(pthatcher): Refactor this to be more clean now that we have
   // all the information at once.
   return (SetSendCodecs(params.codecs) &&
@@ skipping 617 matching lines @@
     if (engine()->voe()->base()->StartSend(channel) == -1) {
       LOG_RTCERR1(StartSend, channel);
       return false;
     }
     if (engine()->voe()->file() &&
         engine()->voe()->file()->StopPlayingFileAsMicrophone(channel) == -1) {
       LOG_RTCERR1(StopPlayingFileAsMicrophone, channel);
       return false;
     }
   } else {  // SEND_NOTHING
-    DCHECK(send == SEND_NOTHING);
+    RTC_DCHECK(send == SEND_NOTHING);
     if (engine()->voe()->base()->StopSend(channel) == -1) {
       LOG_RTCERR1(StopSend, channel);
       return false;
     }
   }
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetAudioSend(uint32 ssrc, bool mute,
@@ skipping 146 matching lines @@
       return false;
   }
 
   if (send_channels_.empty())
     ChangeSend(SEND_NOTHING);
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   rtc::CritScope lock(&receive_channels_cs_);
 
   if (!VERIFY(sp.ssrcs.size() == 1))
     return false;
   uint32 ssrc = sp.first_ssrc();
 
   if (ssrc == 0) {
     LOG(LS_WARNING) << "AddRecvStream with 0 ssrc is not supported.";
     return false;
   }
 
   if (receive_channels_.find(ssrc) != receive_channels_.end()) {
     LOG(LS_ERROR) << "Stream already exists with ssrc " << ssrc;
     return false;
   }
 
-  DCHECK(receive_stream_params_.find(ssrc) == receive_stream_params_.end());
+  RTC_DCHECK(receive_stream_params_.find(ssrc) == receive_stream_params_.end());
 
   // Reuse default channel for recv stream in non-conference mode call
   // when the default channel is not being used.
   webrtc::AudioTransport* audio_transport =
       engine()->voe()->base()->audio_transport();
   if (!InConferenceMode() && default_receive_ssrc_ == 0) {
     LOG(LS_INFO) << "Recv stream " << ssrc << " reuse default channel";
     default_receive_ssrc_ = ssrc;
     WebRtcVoiceChannelRenderer* channel_renderer =
         new WebRtcVoiceChannelRenderer(voe_channel(), audio_transport);
@@ skipping 92 matching lines @@
 
   // Set RTP header extension for the new channel.
   if (!SetChannelRecvRtpHeaderExtensions(channel, receive_extensions_)) {
     return false;
   }
 
   return SetPlayout(channel, playout_);
 }
 
 bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32 ssrc) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   rtc::CritScope lock(&receive_channels_cs_);
   ChannelMap::iterator it = receive_channels_.find(ssrc);
   if (it == receive_channels_.end()) {
     LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc
                     << " which doesn't exist.";
     return false;
   }
 
   RemoveAudioReceiveStream(ssrc);
   receive_stream_params_.erase(ssrc);
 
   // Delete the WebRtcVoiceChannelRenderer object connected to the channel, this
   // will disconnect the audio renderer with the receive channel.
   // Cache the channel before the deletion.
   const int channel = it->second->channel();
   delete it->second;
   receive_channels_.erase(it);
 
   if (ssrc == default_receive_ssrc_) {
-    DCHECK(IsDefaultChannel(channel));
+    RTC_DCHECK(IsDefaultChannel(channel));
     // Recycle the default channel is for recv stream.
     if (playout_)
       SetPlayout(voe_channel(), false);
 
     default_receive_ssrc_ = 0;
     return true;
   }
 
   LOG(LS_INFO) << "Removing audio stream " << ssrc
                << " with VoiceEngine channel #" << channel << ".";
@@ skipping 260 matching lines @@
       LOG_RTCERR2(PlayDtmfTone, event, duration);
       return false;
     }
   }
 
   return true;
 }
 
 void WebRtcVoiceMediaChannel::OnPacketReceived(
     rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   // Forward packet to Call as well.
   const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
                                               packet_time.not_before);
   call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
       reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
       webrtc_packet_time);
 
   // Pick which channel to send this packet to. If this packet doesn't match
   // any multiplexed streams, just send it to the default channel. Otherwise,
@@ skipping 21 matching lines @@
   }
 
   // Pass it off to the decoder.
   engine()->voe()->network()->ReceivedRTPPacket(
       which_channel, packet->data(), packet->size(),
       webrtc::PacketTime(packet_time.timestamp, packet_time.not_before));
 }
 
 void WebRtcVoiceMediaChannel::OnRtcpReceived(
     rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   // Forward packet to Call as well.
   const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
                                               packet_time.not_before);
   call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
       reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
       webrtc_packet_time);
 
   // Sending channels need all RTCP packets with feedback information.
   // Even sender reports can contain attached report blocks.
@@ skipping 299 matching lines @@
           GetSpeechOutputLevelFullRange(ch_id, level) != -1) ? level : -1;
       info->receivers.push_back(rinfo);
     }
   }
 
   return true;
 }
 
 void WebRtcVoiceMediaChannel::GetLastMediaError(
     uint32* ssrc, VoiceMediaChannel::Error* error) {
-  DCHECK(ssrc != NULL);
-  DCHECK(error != NULL);
+  RTC_DCHECK(ssrc != NULL);
+  RTC_DCHECK(error != NULL);
   FindSsrc(voe_channel(), ssrc);
   *error = WebRtcErrorToChannelError(GetLastEngineError());
 }
 
 bool WebRtcVoiceMediaChannel::FindSsrc(int channel_num, uint32* ssrc) {
   rtc::CritScope lock(&receive_channels_cs_);
-  DCHECK(ssrc != NULL);
+  RTC_DCHECK(ssrc != NULL);
   if (channel_num == -1 && send_ != SEND_NOTHING) {
     // Sometimes the VoiceEngine core will throw error with channel_num = -1.
     // This means the error is not limited to a specific channel.  Signal the
     // message using ssrc=0.  If the current channel is sending, use this
     // channel for sending the message.
     *ssrc = 0;
     return true;
   } else {
     // Check whether this is a sending channel.
     for (const auto& ch : send_channels_) {
@@ skipping 190 matching lines @@
     uri = extension->uri;
   }
   if ((engine()->voe()->rtp()->*setter)(channel_id, enable, id) != 0) {
     LOG_RTCERR4(*setter, uri, channel_id, enable, id);
     return false;
   }
   return true;
 }
 
 void WebRtcVoiceMediaChannel::RecreateAudioReceiveStreams() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   for (const auto& it : receive_channels_) {
     RemoveAudioReceiveStream(it.first);
   }
   for (const auto& it : receive_channels_) {
     AddAudioReceiveStream(it.first);
   }
 }
 
 void WebRtcVoiceMediaChannel::AddAudioReceiveStream(uint32 ssrc) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   WebRtcVoiceChannelRenderer* channel = receive_channels_[ssrc];
-  DCHECK(channel != nullptr);
-  DCHECK(receive_streams_.find(ssrc) == receive_streams_.end());
+  RTC_DCHECK(channel != nullptr);
+  RTC_DCHECK(receive_streams_.find(ssrc) == receive_streams_.end());
   webrtc::AudioReceiveStream::Config config;
   config.rtp.remote_ssrc = ssrc;
   // Only add RTP extensions if we support combined A/V BWE.
   config.rtp.extensions = recv_rtp_extensions_;
   config.combined_audio_video_bwe =
       options_.combined_audio_video_bwe.GetWithDefaultIfUnset(false);
   config.voe_channel_id = channel->channel();
   config.sync_group = receive_stream_params_[ssrc].sync_label;
   webrtc::AudioReceiveStream* s = call_->CreateAudioReceiveStream(config);
   receive_streams_.insert(std::make_pair(ssrc, s));
 }
 
 void WebRtcVoiceMediaChannel::RemoveAudioReceiveStream(uint32 ssrc) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   auto stream_it = receive_streams_.find(ssrc);
   if (stream_it != receive_streams_.end()) {
     call_->DestroyAudioReceiveStream(stream_it->second);
     receive_streams_.erase(stream_it);
   }
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvCodecsInternal(
     const std::vector<AudioCodec>& new_codecs) {
   for (const AudioCodec& codec : new_codecs) {
@@ skipping 40 matching lines @@
 
 int WebRtcSoundclipStream::Rewind() {
   mem_.Rewind();
   // Return -1 to keep VoiceEngine from looping.
   return (loop_) ? 0 : -1;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE