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

webrtc/video_engine/vie_channel.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 139 matching lines @@
 
   rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqFirRtp);
   if (paced_sender_) {
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
       rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_);
   }
   packet_router_->AddRtpModule(rtp_rtcp_modules_[0]);
   if (sender_) {
     std::list<RtpRtcp*> send_rtp_modules(1, rtp_rtcp_modules_[0]);
     send_payload_router_->SetSendingRtpModules(send_rtp_modules);
-    DCHECK(!send_payload_router_->active());
+    RTC_DCHECK(!send_payload_router_->active());
   }
   if (vcm_->RegisterReceiveCallback(this) != 0) {
     return -1;
   }
   vcm_->RegisterFrameTypeCallback(this);
   vcm_->RegisterReceiveStatisticsCallback(this);
   vcm_->RegisterDecoderTimingCallback(this);
   vcm_->SetRenderDelay(kViEDefaultRenderDelayMs);
 
   module_process_thread_->RegisterModule(vcm_);
@@ skipping 153 matching lines @@
         RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.FecBitrateReceivedInKbps",
                                    static_cast<int>(rtp_rtx.fec.TotalBytes() *
                                                     8 / elapsed_sec / 1000));
       }
     }
   }
 }
 
 int32_t ViEChannel::SetSendCodec(const VideoCodec& video_codec,
                                  bool new_stream) {
-  DCHECK(sender_);
+  RTC_DCHECK(sender_);
   if (video_codec.codecType == kVideoCodecRED ||
       video_codec.codecType == kVideoCodecULPFEC) {
     LOG_F(LS_ERROR) << "Not a valid send codec " << video_codec.codecType;
     return -1;
   }
   if (kMaxSimulcastStreams < video_codec.numberOfSimulcastStreams) {
     LOG_F(LS_ERROR) << "Incorrect config "
                     << video_codec.numberOfSimulcastStreams;
     return -1;
   }
@@ skipping 63 matching lines @@
   }
   // Register new active modules.
   for (size_t i = num_prev_active_modules; i < num_active_modules; ++i) {
     module_process_thread_->RegisterModule(rtp_rtcp_modules_[i]);
     packet_router_->AddRtpModule(rtp_rtcp_modules_[i]);
   }
   return 0;
 }
 
 int32_t ViEChannel::SetReceiveCodec(const VideoCodec& video_codec) {
-  DCHECK(!sender_);
+  RTC_DCHECK(!sender_);
   if (!vie_receiver_.SetReceiveCodec(video_codec)) {
     return -1;
   }
 
   if (video_codec.codecType != kVideoCodecRED &&
       video_codec.codecType != kVideoCodecULPFEC) {
     // Register codec type with VCM, but do not register RED or ULPFEC.
     if (vcm_->RegisterReceiveCodec(&video_codec, number_of_cores_, false) !=
         VCM_OK) {
       return -1;
     }
   }
   return 0;
 }
 
 
 int32_t ViEChannel::RegisterExternalDecoder(const uint8_t pl_type,
                                             VideoDecoder* decoder,
                                             bool buffered_rendering,
                                             int32_t render_delay) {
-  DCHECK(!sender_);
+  RTC_DCHECK(!sender_);
   int32_t result;
   result = vcm_->RegisterExternalDecoder(decoder, pl_type, buffered_rendering);
   if (result != VCM_OK) {
     return result;
   }
   return vcm_->SetRenderDelay(render_delay);
 }
 
 int32_t ViEChannel::DeRegisterExternalDecoder(const uint8_t pl_type) {
-  DCHECK(!sender_);
+  RTC_DCHECK(!sender_);
   VideoCodec current_receive_codec;
   int32_t result = 0;
   result = vcm_->ReceiveCodec(&current_receive_codec);
   if (vcm_->RegisterExternalDecoder(NULL, pl_type, false) != VCM_OK) {
     return -1;
   }
 
   if (result == 0 && current_receive_codec.plType == pl_type) {
     result = vcm_->RegisterReceiveCodec(&current_receive_codec,
                                         number_of_cores_, false);
@@ skipping 21 matching lines @@
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->SetRTCPStatus(rtcp_mode);
 }
 
 void ViEChannel::SetProtectionMode(bool enable_nack,
                                    bool enable_fec,
                                    int payload_type_red,
                                    int payload_type_fec) {
   // Validate payload types.
   if (enable_fec) {
-    DCHECK_GE(payload_type_red, 0);
-    DCHECK_GE(payload_type_fec, 0);
-    DCHECK_LE(payload_type_red, 127);
-    DCHECK_LE(payload_type_fec, 127);
+    RTC_DCHECK_GE(payload_type_red, 0);
+    RTC_DCHECK_GE(payload_type_fec, 0);
+    RTC_DCHECK_LE(payload_type_red, 127);
+    RTC_DCHECK_LE(payload_type_fec, 127);
   } else {
-    DCHECK_EQ(payload_type_red, -1);
-    DCHECK_EQ(payload_type_fec, -1);
+    RTC_DCHECK_EQ(payload_type_red, -1);
+    RTC_DCHECK_EQ(payload_type_fec, -1);
     // Set to valid uint8_ts to be castable later without signed overflows.
     payload_type_red = 0;
     payload_type_fec = 0;
   }
 
   VCMVideoProtection protection_method;
   if (enable_nack) {
     protection_method = enable_fec ? kProtectionNackFEC : kProtectionNack;
   } else {
     protection_method = kProtectionNone;
@@ skipping 192 matching lines @@
 
 int ViEChannel::SetReceiveTransportSequenceNumber(bool enable, int id) {
   return vie_receiver_.SetReceiveTransportSequenceNumber(enable, id) ? 0 : -1;
 }
 
 void ViEChannel::SetRtcpXrRrtrStatus(bool enable) {
   rtp_rtcp_modules_[0]->SetRtcpXrRrtrStatus(enable);
 }
 
 void ViEChannel::SetTransmissionSmoothingStatus(bool enable) {
-  DCHECK(paced_sender_ && "No paced sender registered.");
+  RTC_DCHECK(paced_sender_ && "No paced sender registered.");
   paced_sender_->SetStatus(enable);
 }
 
 void ViEChannel::EnableTMMBR(bool enable) {
   rtp_rtcp_modules_[0]->SetTMMBRStatus(enable);
 }
 
 int32_t ViEChannel::SetSSRC(const uint32_t SSRC,
                             const StreamType usage,
                             const uint8_t simulcast_idx) {
   RtpRtcp* rtp_rtcp = rtp_rtcp_modules_[simulcast_idx];
   if (usage == kViEStreamTypeRtx) {
     rtp_rtcp->SetRtxSsrc(SSRC);
   } else {
     rtp_rtcp->SetSSRC(SSRC);
   }
   return 0;
 }
 
 int32_t ViEChannel::SetRemoteSSRCType(const StreamType usage,
                                       const uint32_t SSRC) {
   vie_receiver_.SetRtxSsrc(SSRC);
   return 0;
 }
 
 int32_t ViEChannel::GetLocalSSRC(uint8_t idx, unsigned int* ssrc) {
-  DCHECK_LE(idx, rtp_rtcp_modules_.size());
+  RTC_DCHECK_LE(idx, rtp_rtcp_modules_.size());
   *ssrc = rtp_rtcp_modules_[idx]->SSRC();
   return 0;
 }
 
 int32_t ViEChannel::GetRemoteSSRC(uint32_t* ssrc) {
   *ssrc = vie_receiver_.GetRemoteSsrc();
   return 0;
 }
 
 int ViEChannel::SetRtxSendPayloadType(int payload_type,
@@ skipping 10 matching lines @@
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->SetRtxSendStatus(rtx_settings);
 }
 
 void ViEChannel::SetRtxReceivePayloadType(int payload_type,
                                           int associated_payload_type) {
   vie_receiver_.SetRtxPayloadType(payload_type, associated_payload_type);
 }
 
 void ViEChannel::SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state) {
-  DCHECK(!rtp_rtcp_modules_[0]->Sending());
+  RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending());
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     if (rtp_rtcp->SetRtpStateForSsrc(ssrc, rtp_state))
       return;
   }
 }
 
 RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) {
-  DCHECK(!rtp_rtcp_modules_[0]->Sending());
+  RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending());
   RtpState rtp_state;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     if (rtp_rtcp->GetRtpStateForSsrc(ssrc, &rtp_state))
       return rtp_state;
   }
   LOG(LS_ERROR) << "Couldn't get RTP state for ssrc: " << ssrc;
   return rtp_state;
 }
 
 // TODO(pbos): Set CNAME on all modules.
 int32_t ViEChannel::SetRTCPCName(const char* rtcp_cname) {
-  DCHECK(!rtp_rtcp_modules_[0]->Sending());
+  RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending());
   return rtp_rtcp_modules_[0]->SetCNAME(rtcp_cname);
 }
 
 int32_t ViEChannel::GetRemoteRTCPCName(char rtcp_cname[]) {
   uint32_t remoteSSRC = vie_receiver_.GetRemoteSsrc();
   return rtp_rtcp_modules_[0]->RemoteCNAME(remoteSSRC, rtcp_cname);
 }
 
 int32_t ViEChannel::GetSendRtcpStatistics(uint16_t* fraction_lost,
                                           uint32_t* cumulative_lost,
@@ skipping 344 matching lines @@
     TransportFeedbackObserver* transport_feedback_callback,
     RtcpRttStats* rtt_stats,
     RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
     RemoteBitrateEstimator* remote_bitrate_estimator,
     PacedSender* paced_sender,
     PacketRouter* packet_router,
     BitrateStatisticsObserver* send_bitrate_observer,
     FrameCountObserver* send_frame_count_observer,
     SendSideDelayObserver* send_side_delay_observer,
     size_t num_modules) {
-  DCHECK_GT(num_modules, 0u);
+  RTC_DCHECK_GT(num_modules, 0u);
   RtpRtcp::Configuration configuration;
   ReceiveStatistics* null_receive_statistics = configuration.receive_statistics;
   configuration.id = id;
   configuration.audio = false;
   configuration.receiver_only = receiver_only;
   configuration.receive_statistics = receive_statistics;
   configuration.outgoing_transport = outgoing_transport;
   configuration.intra_frame_callback = intra_frame_callback;
   configuration.rtt_stats = rtt_stats;
   configuration.rtcp_packet_type_counter_observer =
@@ skipping 15 matching lines @@
     modules.push_back(rtp_rtcp);
     // Receive statistics and remote bitrate estimator should only be set for
     // the primary (first) module.
     configuration.receive_statistics = null_receive_statistics;
     configuration.remote_bitrate_estimator = nullptr;
   }
   return modules;
 }
 
 void ViEChannel::StartDecodeThread() {
-  DCHECK(!sender_);
+  RTC_DCHECK(!sender_);
   // Start the decode thread
   if (decode_thread_)
     return;
   decode_thread_ = ThreadWrapper::CreateThread(ChannelDecodeThreadFunction,
                                                this, "DecodingThread");
   decode_thread_->Start();
   decode_thread_->SetPriority(kHighestPriority);
 }
 
 void ViEChannel::StopDecodeThread() {
@@ skipping 38 matching lines @@
     const uint8_t channels,
     const uint32_t rate) {
   LOG(LS_INFO) << "OnInitializeDecoder " << static_cast<int>(payload_type)
                << " " << payload_name;
   vcm_->ResetDecoder();
 
   return 0;
 }
 
 void ViEChannel::OnIncomingSSRCChanged(const int32_t id, const uint32_t ssrc) {
-  DCHECK_EQ(channel_id_, ChannelId(id));
+  RTC_DCHECK_EQ(channel_id_, ChannelId(id));
   rtp_rtcp_modules_[0]->SetRemoteSSRC(ssrc);
 }
 
 void ViEChannel::OnIncomingCSRCChanged(const int32_t id,
                                        const uint32_t CSRC,
                                        const bool added) {
-  DCHECK_EQ(channel_id_, ChannelId(id));
+  RTC_DCHECK_EQ(channel_id_, ChannelId(id));
   CriticalSectionScoped cs(crit_.get());
 }
 
 void ViEChannel::RegisterSendFrameCountObserver(
     FrameCountObserver* observer) {
   send_frame_count_observer_.Set(observer);
 }
 
 void ViEChannel::RegisterReceiveStatisticsProxy(
     ReceiveStatisticsProxy* receive_statistics_proxy) {
   CriticalSectionScoped cs(crit_.get());
   receive_stats_callback_ = receive_statistics_proxy;
 }
 
 void ViEChannel::SetIncomingVideoStream(
     IncomingVideoStream* incoming_video_stream) {
   CriticalSectionScoped cs(crit_.get());
   incoming_video_stream_ = incoming_video_stream;
 }
 }  // namespace webrtc