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

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 88 matching lines @@
     for (const auto& codec : codecs) {
       if (codec.type == webrtc::kVideoCodecVP8) {
         return true;
       }
     }
     return false;
   }
 
   webrtc::VideoEncoder* CreateVideoEncoder(
       webrtc::VideoCodecType type) override {
-    DCHECK(factory_ != NULL);
+    RTC_DCHECK(factory_ != NULL);
     // If it's a codec type we can simulcast, create a wrapped encoder.
     if (type == webrtc::kVideoCodecVP8) {
       return new webrtc::SimulcastEncoderAdapter(
           new EncoderFactoryAdapter(factory_));
     }
     webrtc::VideoEncoder* encoder = factory_->CreateVideoEncoder(type);
     if (encoder) {
       non_simulcast_encoders_.push_back(encoder);
     }
     return encoder;
@@ skipping 473 matching lines @@
                   << codec.ToString();
     return false;
   }
 
   return true;
 }
 
 WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel(
     webrtc::Call* call,
     const VideoOptions& options) {
-  DCHECK(initialized_);
+  RTC_DCHECK(initialized_);
   LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
   WebRtcVideoChannel2* channel = new WebRtcVideoChannel2(call, options,
       external_encoder_factory_, external_decoder_factory_);
   channel->SetRecvCodecs(video_codecs_);
   return channel;
 }
 
 const std::vector<VideoCodec>& WebRtcVideoEngine2::codecs() const {
   return video_codecs_;
 }
 
 const std::vector<RtpHeaderExtension>&
 WebRtcVideoEngine2::rtp_header_extensions() const {
   return rtp_header_extensions_;
 }
 
 void WebRtcVideoEngine2::SetLogging(int min_sev, const char* filter) {
   // TODO(pbos): Set up logging.
   LOG(LS_VERBOSE) << "SetLogging: " << min_sev << '"' << filter << '"';
   // if min_sev == -1, we keep the current log level.
   if (min_sev < 0) {
-    DCHECK(min_sev == -1);
+    RTC_DCHECK(min_sev == -1);
     return;
   }
 }
 
 void WebRtcVideoEngine2::SetExternalDecoderFactory(
     WebRtcVideoDecoderFactory* decoder_factory) {
-  DCHECK(!initialized_);
+  RTC_DCHECK(!initialized_);
   external_decoder_factory_ = decoder_factory;
 }
 
 void WebRtcVideoEngine2::SetExternalEncoderFactory(
     WebRtcVideoEncoderFactory* encoder_factory) {
-  DCHECK(!initialized_);
+  RTC_DCHECK(!initialized_);
   if (external_encoder_factory_ == encoder_factory)
     return;
 
   // No matter what happens we shouldn't hold on to a stale
   // WebRtcSimulcastEncoderFactory.
   simulcast_encoder_factory_.reset();
 
   if (encoder_factory &&
       WebRtcSimulcastEncoderFactory::UseSimulcastEncoderFactory(
           encoder_factory->codecs())) {
@@ skipping 25 matching lines @@
   return false;
 }
 
 // Tells whether the |requested| codec can be transmitted or not. If it can be
 // transmitted |out| is set with the best settings supported. Aspect ratio will
 // be set as close to |current|'s as possible. If not set |requested|'s
 // dimensions will be used for aspect ratio matching.
 bool WebRtcVideoEngine2::CanSendCodec(const VideoCodec& requested,
                                       const VideoCodec& current,
                                       VideoCodec* out) {
-  DCHECK(out != NULL);
+  RTC_DCHECK(out != NULL);
 
   if (requested.width != requested.height &&
       (requested.height == 0 || requested.width == 0)) {
     // 0xn and nx0 are invalid resolutions.
     return false;
   }
 
   VideoCodec matching_codec;
   if (!FindFirstMatchingCodec(video_codecs_, requested, &matching_codec)) {
     // Codec not supported.
@@ skipping 45 matching lines @@
   for (size_t i = 0; i < codecs.size(); ++i) {
     // Don't add internally-supported codecs twice.
     if (CodecIsInternallySupported(codecs[i].name)) {
       continue;
     }
 
     // External video encoders are given payloads 120-127. This also means that
     // we only support up to 8 external payload types.
     const int kExternalVideoPayloadTypeBase = 120;
     size_t payload_type = kExternalVideoPayloadTypeBase + i;
-    DCHECK(payload_type < 128);
+    RTC_DCHECK(payload_type < 128);
     VideoCodec codec(static_cast<int>(payload_type),
                      codecs[i].name,
                      codecs[i].max_width,
                      codecs[i].max_height,
                      codecs[i].max_fps,
                      0);
 
     AddDefaultFeedbackParams(&codec);
     supported_codecs.push_back(codec);
   }
   return supported_codecs;
 }
 
 WebRtcVideoChannel2::WebRtcVideoChannel2(
     webrtc::Call* call,
     const VideoOptions& options,
     WebRtcVideoEncoderFactory* external_encoder_factory,
     WebRtcVideoDecoderFactory* external_decoder_factory)
     : call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       external_encoder_factory_(external_encoder_factory),
       external_decoder_factory_(external_decoder_factory) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   SetDefaultOptions();
   options_.SetAll(options);
   options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   default_send_ssrc_ = 0;
 }
 
 void WebRtcVideoChannel2::SetDefaultOptions() {
   options_.cpu_overuse_detection.Set(true);
@@ skipping 172 matching lines @@
     // Using same codec, avoid reconfiguring.
     return true;
   }
 
   send_codec_.Set(supported_codecs.front());
 
   rtc::CritScope stream_lock(&stream_crit_);
   LOG(LS_INFO) << "Change the send codec because SetSendCodecs has a different "
                   "first supported codec.";
   for (auto& kv : send_streams_) {
-    DCHECK(kv.second != nullptr);
+    RTC_DCHECK(kv.second != nullptr);
     kv.second->SetCodec(supported_codecs.front());
   }
   LOG(LS_INFO) << "SetNackAndRemb on all the receive streams because the send "
                   "codec has changed.";
   for (auto& kv : receive_streams_) {
-    DCHECK(kv.second != nullptr);
+    RTC_DCHECK(kv.second != nullptr);
     kv.second->SetNackAndRemb(HasNack(supported_codecs.front().codec),
                               HasRemb(supported_codecs.front().codec));
   }
 
   // TODO(holmer): Changing the codec parameters shouldn't necessarily mean that
   // we change the min/max of bandwidth estimation. Reevaluate this.
   VideoCodec codec = supported_codecs.front().codec;
   int bitrate_kbps;
   if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) &&
       bitrate_kbps > 0) {
@@ skipping 118 matching lines @@
       new WebRtcVideoSendStream(call_,
                                 sp,
                                 config,
                                 external_encoder_factory_,
                                 options_,
                                 bitrate_config_.max_bitrate_bps,
                                 send_codec_,
                                 send_rtp_extensions_);
 
   uint32 ssrc = sp.first_ssrc();
-  DCHECK(ssrc != 0);
+  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) {
@@ skipping 50 matching lines @@
     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) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  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();
-  DCHECK(ssrc != 0);  // TODO(pbos): Is this ever valid?
+  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;
     }
@@ skipping 168 matching lines @@
        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) {
   LOG(LS_INFO) << "SetCapturer: " << ssrc << " -> "
                << (capturer != NULL ? "(capturer)" : "NULL");
-  DCHECK(ssrc != 0);
+  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)) {
       return false;
     }
   }
@@ skipping 94 matching lines @@
 }
 
 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) {
   LOG(LS_VERBOSE) << "MuteStream: " << ssrc << " -> "
                   << (mute ? "mute" : "unmute");
-  DCHECK(ssrc != 0);
+  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);
   return true;
 }
 
@@ skipping 282 matching lines @@
     // Frame input before send codecs are configured, dropping frame.
     return;
   }
 
   // Not sending, abort early to prevent expensive reconfigurations while
   // setting up codecs etc.
   if (!sending_)
     return;
 
   if (format_.width == 0) {  // Dropping frames.
-    DCHECK(format_.height == 0);
+    RTC_DCHECK(format_.height == 0);
     LOG(LS_VERBOSE) << "VideoFormat 0x0 set, Dropping frame.";
     return;
   }
   if (muted_) {
     // Create a black frame to transmit instead.
     CreateBlackFrame(&video_frame,
                      static_cast<int>(frame->GetWidth()),
                      static_cast<int>(frame->GetHeight()));
   }
 
@@ skipping 173 matching lines @@
   } else if (type == webrtc::kVideoCodecVP9) {
     return AllocatedEncoder(
         webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kVp9), type, false);
   } else if (type == webrtc::kVideoCodecH264) {
     return AllocatedEncoder(
         webrtc::VideoEncoder::Create(webrtc::VideoEncoder::kH264), type, false);
   }
 
   // This shouldn't happen, we should not be trying to create something we don't
   // support.
-  DCHECK(false);
+  RTC_DCHECK(false);
   return AllocatedEncoder(NULL, webrtc::kVideoCodecUnknown, false);
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder(
     AllocatedEncoder* encoder) {
   if (encoder->external) {
     external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder);
   }
   delete encoder->encoder;
 }
@@ skipping 134 matching lines @@
     // Configured using the same parameters, do not reconfigure.
     return;
   }
   LOG(LS_INFO) << "SetDimensions: " << width << "x" << height
                << (is_screencast ? " (screencast)" : " (not screencast)");
 
   last_dimensions_.width = width;
   last_dimensions_.height = height;
   last_dimensions_.is_screencast = is_screencast;
 
-  DCHECK(!parameters_.encoder_config.streams.empty());
+  RTC_DCHECK(!parameters_.encoder_config.streams.empty());
 
   VideoCodecSettings codec_settings;
   parameters_.codec_settings.Get(&codec_settings);
 
   webrtc::VideoEncoderConfig encoder_config =
       CreateVideoEncoderConfig(last_dimensions_, codec_settings.codec);
 
   encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings(
       codec_settings.codec, parameters_.options, is_screencast);
 
   bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
 
   encoder_config.encoder_specific_settings = NULL;
 
   if (!stream_reconfigured) {
     LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
                     << width << "x" << height;
     return;
   }
 
   parameters_.encoder_config = encoder_config;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
   rtc::CritScope cs(&lock_);
-  DCHECK(stream_ != NULL);
+  RTC_DCHECK(stream_ != NULL);
   stream_->Start();
   sending_ = true;
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::Stop() {
   rtc::CritScope cs(&lock_);
   if (stream_ != NULL) {
     stream_->Stop();
   }
   sending_ = false;
@@ skipping 230 matching lines @@
         webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp9), type, false);
   }
 
   if (type == webrtc::kVideoCodecH264) {
     return AllocatedDecoder(
         webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kH264), type, false);
   }
 
   // This shouldn't happen, we should not be trying to create something we don't
   // support.
-  DCHECK(false);
+  RTC_DCHECK(false);
   return AllocatedDecoder(NULL, webrtc::kVideoCodecUnknown, false);
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvCodecs(
     const std::vector<VideoCodecSettings>& recv_codecs) {
   std::vector<AllocatedDecoder> old_decoders = allocated_decoders_;
   allocated_decoders_.clear();
   config_.decoders.clear();
   for (size_t i = 0; i < recv_codecs.size(); ++i) {
     AllocatedDecoder allocated_decoder =
@@ skipping 13 matching lines @@
       HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0;
 
   ClearDecoders(&old_decoders);
   LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvCodecs: "
                << CodecSettingsVectorToString(recv_codecs);
   RecreateWebRtcStream();
 }
 
 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc(
     uint32_t local_ssrc) {
-  // TODO(pbos): Consider turning this sanity check into a DCHECK. You should
-  // not be able to create a sender with the same SSRC as a receiver, but right
-  // now this can't be done due to unittests depending on receiving what they
-  // are sending from the same MediaChannel.
+  // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You
+  // should not be able to create a sender with the same SSRC as a receiver, but
+  // right now this can't be done due to unittests depending on receiving what
+  // they are sending from the same MediaChannel.
   if (local_ssrc == config_.rtp.remote_ssrc) {
     LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are "
                     "unchanged; local_ssrc=" << local_ssrc;
     return;
   }
 
   config_.rtp.local_ssrc = local_ssrc;
   LOG(LS_INFO)
       << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc="
       << local_ssrc;
@@ skipping 174 matching lines @@
          rtx_payload_type == other.rtx_payload_type;
 }
 
 bool WebRtcVideoChannel2::VideoCodecSettings::operator!=(
     const WebRtcVideoChannel2::VideoCodecSettings& other) const {
   return !(*this == other);
 }
 
 std::vector<WebRtcVideoChannel2::VideoCodecSettings>
 WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) {
-  DCHECK(!codecs.empty());
+  RTC_DCHECK(!codecs.empty());
 
   std::vector<VideoCodecSettings> video_codecs;
   std::map<int, bool> payload_used;
   std::map<int, VideoCodec::CodecType> payload_codec_type;
   // |rtx_mapping| maps video payload type to rtx payload type.
   std::map<int, int> rtx_mapping;
 
   webrtc::FecConfig fec_settings;
 
   for (size_t i = 0; i < codecs.size(); ++i) {
     const VideoCodec& in_codec = codecs[i];
     int payload_type = in_codec.id;
 
     if (payload_used[payload_type]) {
       LOG(LS_ERROR) << "Payload type already registered: "
                     << in_codec.ToString();
       return std::vector<VideoCodecSettings>();
     }
     payload_used[payload_type] = true;
     payload_codec_type[payload_type] = in_codec.GetCodecType();
 
     switch (in_codec.GetCodecType()) {
       case VideoCodec::CODEC_RED: {
         // RED payload type, should not have duplicates.
-        DCHECK(fec_settings.red_payload_type == -1);
+        RTC_DCHECK(fec_settings.red_payload_type == -1);
         fec_settings.red_payload_type = in_codec.id;
         continue;
       }
 
       case VideoCodec::CODEC_ULPFEC: {
         // ULPFEC payload type, should not have duplicates.
-        DCHECK(fec_settings.ulpfec_payload_type == -1);
+        RTC_DCHECK(fec_settings.ulpfec_payload_type == -1);
         fec_settings.ulpfec_payload_type = in_codec.id;
         continue;
       }
 
       case VideoCodec::CODEC_RTX: {
         int associated_payload_type;
         if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
                                &associated_payload_type) ||
             !IsValidRtpPayloadType(associated_payload_type)) {
           LOG(LS_ERROR)
               << "RTX codec with invalid or no associated payload type: "
               << in_codec.ToString();
           return std::vector<VideoCodecSettings>();
         }
         rtx_mapping[associated_payload_type] = in_codec.id;
         continue;
       }
 
       case VideoCodec::CODEC_VIDEO:
         break;
     }
 
     video_codecs.push_back(VideoCodecSettings());
     video_codecs.back().codec = in_codec;
   }
 
   // One of these codecs should have been a video codec. Only having FEC
   // parameters into this code is a logic error.
-  DCHECK(!video_codecs.empty());
+  RTC_DCHECK(!video_codecs.empty());
 
   for (std::map<int, int>::const_iterator it = rtx_mapping.begin();
        it != rtx_mapping.end();
        ++it) {
     if (!payload_used[it->first]) {
       LOG(LS_ERROR) << "RTX mapped to payload not in codec list.";
       return std::vector<VideoCodecSettings>();
     }
     if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO &&
         payload_codec_type[it->first] != VideoCodec::CODEC_RED) {
@@ skipping 14 matching lines @@
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VIDEO