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

webrtc/video_engine/vie_encoder.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 142 matching lines @@
   }
   if (vcm_->RegisterSendStatisticsCallback(this) != 0) {
     return false;
   }
   return true;
 }
 
 void ViEEncoder::StartThreadsAndSetSharedMembers(
     rtc::scoped_refptr<PayloadRouter> send_payload_router,
     VCMProtectionCallback* vcm_protection_callback) {
-  DCHECK(send_payload_router_ == NULL);
+  RTC_DCHECK(send_payload_router_ == NULL);
 
   send_payload_router_ = send_payload_router;
   vcm_->RegisterProtectionCallback(vcm_protection_callback);
   module_process_thread_.RegisterModule(vcm_.get());
 }
 
 void ViEEncoder::StopThreadsAndRemoveSharedMembers() {
   if (bitrate_allocator_)
     bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get());
   module_process_thread_.DeRegisterModule(vcm_.get());
@@ skipping 73 matching lines @@
 }
 
 int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
   if (vcm_->RegisterExternalEncoder(NULL, pl_type) != VCM_OK) {
     return -1;
   }
   return 0;
 }
 
 int32_t ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
-  DCHECK(send_payload_router_ != NULL);
+  RTC_DCHECK(send_payload_router_ != NULL);
   // Setting target width and height for VPM.
   if (vpm_->SetTargetResolution(video_codec.width, video_codec.height,
                                 video_codec.maxFramerate) != VPM_OK) {
     return -1;
   }
 
   {
     CriticalSectionScoped cs(data_cs_.get());
     simulcast_enabled_ = video_codec.numberOfSimulcastStreams > 1;
   }
@@ skipping 139 matching lines @@
 
 void ViEEncoder::TraceFrameDropEnd() {
   // End trace event on first frame after encoder resumes, if frame was dropped.
   if (encoder_paused_and_dropped_frame_) {
     TRACE_EVENT_ASYNC_END0("webrtc", "EncoderPaused", this);
   }
   encoder_paused_and_dropped_frame_ = false;
 }
 
 void ViEEncoder::DeliverFrame(VideoFrame video_frame) {
-  DCHECK(send_payload_router_ != NULL);
+  RTC_DCHECK(send_payload_router_ != NULL);
   if (!send_payload_router_->active()) {
     // We've paused or we have no channels attached, don't waste resources on
     // encoding.
     return;
   }
   {
     CriticalSectionScoped cs(data_cs_.get());
     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
     if (EncoderPaused()) {
       TraceFrameDropStart();
@@ skipping 84 matching lines @@
   return last_observed_bitrate_bps_;
 }
 
 int ViEEncoder::CodecTargetBitrate(uint32_t* bitrate) const {
   if (vcm_->Bitrate(bitrate) != 0)
     return -1;
   return 0;
 }
 
 int32_t ViEEncoder::UpdateProtectionMethod(bool nack, bool fec) {
-  DCHECK(send_payload_router_ != NULL);
+  RTC_DCHECK(send_payload_router_ != NULL);
 
   if (fec_enabled_ == fec && nack_enabled_ == nack) {
     // No change needed, we're already in correct state.
     return 0;
   }
   fec_enabled_ = fec;
   nack_enabled_ = nack;
 
   // Set Video Protection for VCM.
   VCMVideoProtection protection_mode;
@@ skipping 47 matching lines @@
   CriticalSectionScoped cs(callback_cs_.get());
   if (send_statistics_proxy_ != nullptr)
     send_statistics_proxy_->OnSetRates(bitrate_bps, framerate);
 }
 
 int32_t ViEEncoder::SendData(
     const uint8_t payload_type,
     const EncodedImage& encoded_image,
     const webrtc::RTPFragmentationHeader& fragmentation_header,
     const RTPVideoHeader* rtp_video_hdr) {
-  DCHECK(send_payload_router_ != NULL);
+  RTC_DCHECK(send_payload_router_ != NULL);
 
   {
     CriticalSectionScoped cs(data_cs_.get());
     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
   }
 
   {
     CriticalSectionScoped cs(callback_cs_.get());
     if (send_statistics_proxy_ != NULL)
       send_statistics_proxy_->OnSendEncodedImage(encoded_image, rtp_video_hdr);
@@ skipping 115 matching lines @@
   min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps;
 }
 
 // Called from ViEBitrateObserver.
 void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps,
                                   uint8_t fraction_lost,
                                   int64_t round_trip_time_ms) {
   LOG(LS_VERBOSE) << "OnNetworkChanged, bitrate" << bitrate_bps
                   << " packet loss " << static_cast<int>(fraction_lost)
                   << " rtt " << round_trip_time_ms;
-  DCHECK(send_payload_router_ != NULL);
+  RTC_DCHECK(send_payload_router_ != NULL);
   vcm_->SetChannelParameters(bitrate_bps, fraction_lost, round_trip_time_ms);
   bool video_is_suspended = vcm_->VideoSuspended();
 
   VideoCodec send_codec;
   if (vcm_->SendCodec(&send_codec) != 0) {
     return;
   }
   SimulcastStream* stream_configs = send_codec.simulcastStream;
   // Allocate the bandwidth between the streams.
   std::vector<uint32_t> stream_bitrates = AllocateStreamBitrates(
@@ skipping 50 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vpm_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vpm_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc