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

webrtc/modules/rtp_rtcp/source/rtcp_sender.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 76 matching lines @@
         nack_list(nack_list),
         repeat(repeat),
         picture_id(picture_id),
         buffer(buffer),
         buffer_size(buffer_size),
         ntp_sec(0),
         ntp_frac(0),
         position(0) {}
 
   uint8_t* AllocateData(uint32_t bytes) {
-    DCHECK_LE(position + bytes, buffer_size);
+    RTC_DCHECK_LE(position + bytes, buffer_size);
     uint8_t* ptr = &buffer[position];
     position += bytes;
     return ptr;
   }
 
   const FeedbackState& feedback_state;
   int32_t nack_size;
   const uint16_t* nack_list;
   bool repeat;
   uint64_t picture_id;
@@ skipping 204 matching lines @@
 
 void RTCPSender::SetRemoteSSRC(uint32_t ssrc) {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   remote_ssrc_ = ssrc;
 }
 
 int32_t RTCPSender::SetCNAME(const char* c_name) {
   if (!c_name)
     return -1;
 
-  DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
+  RTC_DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   cname_ = c_name;
   return 0;
 }
 
 int32_t RTCPSender::AddMixedCNAME(uint32_t SSRC, const char* c_name) {
   assert(c_name);
-  DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
+  RTC_DCHECK_LT(strlen(c_name), static_cast<size_t>(RTCP_CNAME_SIZE));
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   if (csrc_cnames_.size() >= kRtpCsrcSize)
     return -1;
 
   csrc_cnames_[SSRC] = c_name;
   return 0;
 }
 
 int32_t RTCPSender::RemoveMixedCNAME(uint32_t SSRC) {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
@@ skipping 168 matching lines @@
   PacketBuiltCallback callback(ctx);
   if (!callback.BuildPacket(report))
     return BuildResult::kTruncated;
 
   report_blocks_.clear();
   return BuildResult::kSuccess;
 }
 
 RTCPSender::BuildResult RTCPSender::BuildSDES(RtcpContext* ctx) {
   size_t length_cname = cname_.length();
-  CHECK_LT(length_cname, static_cast<size_t>(RTCP_CNAME_SIZE));
+  RTC_CHECK_LT(length_cname, static_cast<size_t>(RTCP_CNAME_SIZE));
 
   rtcp::Sdes sdes;
   sdes.WithCName(ssrc_, cname_);
 
   for (const auto it : csrc_cnames_)
     sdes.WithCName(it.first, it.second);
 
   PacketBuiltCallback callback(ctx);
   if (!callback.BuildPacket(sdes))
     return BuildResult::kTruncated;
@@ skipping 445 matching lines @@
   // and all new volatile flags added will be consumed by the end of this call.
   SetFlags(packetTypes, true);
 
   if (packet_type_counter_.first_packet_time_ms == -1)
     packet_type_counter_.first_packet_time_ms = clock_->TimeInMilliseconds();
 
   bool generate_report;
   if (IsFlagPresent(kRtcpSr) || IsFlagPresent(kRtcpRr)) {
     // Report type already explicitly set, don't automatically populate.
     generate_report = true;
-    DCHECK(ConsumeFlag(kRtcpReport) == false);
+    RTC_DCHECK(ConsumeFlag(kRtcpReport) == false);
   } else {
     generate_report =
         (ConsumeFlag(kRtcpReport) && method_ == kRtcpNonCompound) ||
         method_ == kRtcpCompound;
     if (generate_report)
       SetFlag(sending_ ? kRtcpSr : kRtcpRr, true);
   }
 
   if (IsFlagPresent(kRtcpSr) || (IsFlagPresent(kRtcpRr) && !cname_.empty()))
     SetFlag(kRtcpSdes, true);
@@ skipping 38 matching lines @@
                           &report_block)) {
           AddReportBlock(report_block);
         }
       }
     }
   }
 
   auto it = report_flags_.begin();
   while (it != report_flags_.end()) {
     auto builder = builders_.find(it->type);
-    DCHECK(builder != builders_.end());
+    RTC_DCHECK(builder != builders_.end());
     if (it->is_volatile) {
       report_flags_.erase(it++);
     } else {
       ++it;
     }
 
     uint32_t start_position = context.position;
     BuildResult result = (this->*(builder->second))(&context);
     switch (result) {
       case BuildResult::kError:
         return -1;
       case BuildResult::kTruncated:
         return context.position;
       case BuildResult::kAborted:
         context.position = start_position;
         FALLTHROUGH();
       case BuildResult::kSuccess:
         continue;
       default:
         abort();
     }
   }
 
   if (packet_type_counter_observer_ != NULL) {
     packet_type_counter_observer_->RtcpPacketTypesCounterUpdated(
         remote_ssrc_, packet_type_counter_);
   }
 
-  DCHECK(AllVolatileFlagsConsumed());
+  RTC_DCHECK(AllVolatileFlagsConsumed());
 
   return context.position;
 }
 
 bool RTCPSender::PrepareReport(const FeedbackState& feedback_state,
                                uint32_t ssrc,
                                StreamStatistician* statistician,
                                RTCPReportBlock* report_block) {
   // Do we have receive statistics to send?
   RtcpStatistics stats;
@@ skipping 146 matching lines @@
     int32_t id_;
     bool send_failure_;
   } sender(cbTransport_, id_);
 
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, IP_PACKET_SIZE, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc