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

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc

 /*
  *  Copyright (c) 2015 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 116 matching lines @@
       std::vector<TransportFeedback::StatusSymbol>* vec) const override {
     vec->insert(vec->end(), &symbols_[0], &symbols_[kCapacity]);
   }
 
   void WriteTo(uint8_t* buffer) const override {
     const int kSymbolsInFirstByte = 6;
     const int kSymbolsInSecondByte = 8;
     buffer[0] = 0x80u;
     for (int i = 0; i < kSymbolsInFirstByte; ++i) {
       uint8_t encoded_symbol = EncodeSymbol(symbols_[i]);
-      DCHECK_LE(encoded_symbol, 1u);
+      RTC_DCHECK_LE(encoded_symbol, 1u);
       buffer[0] |= encoded_symbol << (kSymbolsInFirstByte - (i + 1));
     }
     buffer[1] = 0x00u;
     for (int i = 0; i < kSymbolsInSecondByte; ++i) {
       uint8_t encoded_symbol = EncodeSymbol(symbols_[i + kSymbolsInFirstByte]);
-      DCHECK_LE(encoded_symbol, 1u);
+      RTC_DCHECK_LE(encoded_symbol, 1u);
       buffer[1] |= encoded_symbol << (kSymbolsInSecondByte - (i + 1));
     }
   }
 
   static OneBitVectorChunk* ParseFrom(const uint8_t* data) {
     OneBitVectorChunk* chunk = new OneBitVectorChunk();
 
     size_t index = 0;
     for (int i = 5; i >= 0; --i)  // Last 5 bits from first byte.
       chunk->symbols_[index++] = DecodeSymbol((data[0] >> i) & 0x01);
@@ skipping 87 matching lines @@
 //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 //
 //  T = 0
 //  S = symbol, see (Encode|Decode)Symbol
 //  Run Length = Unsigned integer denoting the run length of the symbol
 
 class RunLengthChunk : public PacketStatusChunk {
  public:
   RunLengthChunk(TransportFeedback::StatusSymbol symbol, size_t size)
       : symbol_(symbol), size_(size) {
-    DCHECK_LE(size, 0x1FFFu);
+    RTC_DCHECK_LE(size, 0x1FFFu);
   }
 
   virtual ~RunLengthChunk() {}
 
   uint16_t NumSymbols() const override { return size_; }
 
   void AppendSymbolsTo(
       std::vector<TransportFeedback::StatusSymbol>* vec) const override {
     vec->insert(vec->end(), size_, symbol_);
   }
 
   void WriteTo(uint8_t* buffer) const override {
     buffer[0] = EncodeSymbol(symbol_) << 5;  // Write S (T = 0 implicitly)
     buffer[0] |= (size_ >> 8) & 0x1F;  // 5 most significant bits of run length.
     buffer[1] = size_ & 0xFF;  // 8 least significant bits of run length.
   }
 
   static RunLengthChunk* ParseFrom(const uint8_t* buffer) {
-    DCHECK_EQ(0, buffer[0] & 0x80);
+    RTC_DCHECK_EQ(0, buffer[0] & 0x80);
     TransportFeedback::StatusSymbol symbol =
         DecodeSymbol((buffer[0] >> 5) & 0x03);
     uint16_t count = (static_cast<uint16_t>(buffer[0] & 0x1F) << 8) | buffer[1];
 
     return new RunLengthChunk(symbol, count);
   }
 
  private:
   const TransportFeedback::StatusSymbol symbol_;
   const size_t size_;
@@ skipping 26 matching lines @@
 
 uint32_t TransportFeedback::GetPacketSenderSsrc() const {
   return packet_sender_ssrc_;
 }
 
 uint32_t TransportFeedback::GetMediaSourceSsrc() const {
   return media_source_ssrc_;
 }
 void TransportFeedback::WithBase(uint16_t base_sequence,
                                  int64_t ref_timestamp_us) {
-  DCHECK_EQ(-1, base_seq_);
-  DCHECK_NE(-1, ref_timestamp_us);
+  RTC_DCHECK_EQ(-1, base_seq_);
+  RTC_DCHECK_NE(-1, ref_timestamp_us);
   base_seq_ = base_sequence;
   last_seq_ = base_sequence;
   base_time_ = ref_timestamp_us / kBaseScaleFactor;
   last_timestamp_ = base_time_ * kBaseScaleFactor;
 }
 
 void TransportFeedback::WithFeedbackSequenceNumber(uint8_t feedback_sequence) {
   feedback_seq_ = feedback_sequence;
 }
 
 bool TransportFeedback::WithReceivedPacket(uint16_t sequence_number,
                                            int64_t timestamp) {
-  DCHECK_NE(-1, base_seq_);
+  RTC_DCHECK_NE(-1, base_seq_);
   int64_t seq = Unwrap(sequence_number);
   if (seq != base_seq_ && seq <= last_seq_)
     return false;
 
   // Convert to ticks and round.
   int64_t delta_full = timestamp - last_timestamp_;
   delta_full +=
       delta_full < 0 ? -(kDeltaScaleFactor / 2) : kDeltaScaleFactor / 2;
   delta_full /= kDeltaScaleFactor;
 
@@ skipping 171 matching lines @@
   // symbol_vec.
   first_symbol_cardinality_ = 1;
   for (size_t i = 1; i < symbol_vec_.size(); ++i) {
     if (symbol_vec_[i] != symbol_vec_[0])
       break;
     ++first_symbol_cardinality_;
   }
 }
 
 void TransportFeedback::EmitRunLengthChunk() {
-  DCHECK_GE(first_symbol_cardinality_, symbol_vec_.size());
+  RTC_DCHECK_GE(first_symbol_cardinality_, symbol_vec_.size());
   status_chunks_.push_back(
       new RunLengthChunk(symbol_vec_.front(), first_symbol_cardinality_));
   symbol_vec_.clear();
 }
 
 size_t TransportFeedback::BlockLength() const {
   return size_bytes_;
 }
 
 uint16_t TransportFeedback::GetBaseSequence() const {
@@ skipping 44 matching lines @@
       return false;
   }
 
   CreateHeader(kFeedbackMessageType, kPayloadType, HeaderLength(), packet,
                position);
   ByteWriter<uint32_t>::WriteBigEndian(&packet[*position], packet_sender_ssrc_);
   *position += 4;
   ByteWriter<uint32_t>::WriteBigEndian(&packet[*position], media_source_ssrc_);
   *position += 4;
 
-  DCHECK_LE(base_seq_, 0xFFFF);
+  RTC_DCHECK_LE(base_seq_, 0xFFFF);
   ByteWriter<uint16_t>::WriteBigEndian(&packet[*position], base_seq_);
   *position += 2;
 
   int64_t status_count = last_seq_ - base_seq_ + 1;
-  DCHECK_LE(status_count, 0xFFFF);
+  RTC_DCHECK_LE(status_count, 0xFFFF);
   ByteWriter<uint16_t>::WriteBigEndian(&packet[*position], status_count);
   *position += 2;
 
   ByteWriter<int32_t, 3>::WriteBigEndian(&packet[*position],
                                          static_cast<int32_t>(base_time_));
   *position += 3;
 
   packet[(*position)++] = feedback_seq_;
 
   // TODO(sprang): Get rid of this cast.
@@ skipping 103 matching lines @@
     if (chunk == nullptr)
       return nullptr;
 
     index += 2;
     packet->status_chunks_.push_back(chunk);
     packets_read += chunk->NumSymbols();
   }
 
   std::vector<StatusSymbol> symbols = packet->GetStatusVector();
 
-  DCHECK_EQ(num_packets, symbols.size());
+  RTC_DCHECK_EQ(num_packets, symbols.size());
 
   for (StatusSymbol symbol : symbols) {
     switch (symbol) {
       case StatusSymbol::kReceivedSmallDelta:
         if (index + 1 > end_index) {
           LOG(LS_WARNING) << "Buffer overflow while parsing packet.";
           return nullptr;
         }
         packet->receive_deltas_.push_back(buffer[index]);
         ++index;
         break;
       case StatusSymbol::kReceivedLargeDelta:
         if (index + 2 > end_index) {
           LOG(LS_WARNING) << "Buffer overflow while parsing packet.";
           return nullptr;
         }
         packet->receive_deltas_.push_back(
             ByteReader<int16_t>::ReadBigEndian(&buffer[index]));
         index += 2;
         break;
       default:
         continue;
     }
   }
 
-  DCHECK_GE(index, end_index - 3);
-  DCHECK_LE(index, end_index);
+  RTC_DCHECK_GE(index, end_index - 3);
+  RTC_DCHECK_LE(index, end_index);
 
   return packet;
 }
 
 PacketStatusChunk* TransportFeedback::ParseChunk(const uint8_t* buffer,
                                                  size_t max_size) {
   if (buffer[0] & 0x80) {
     // First bit set => vector chunk.
     std::deque<StatusSymbol> symbols;
     if (buffer[0] & 0x40) {
@@ skipping 12 matching lines @@
                        "RLE block of size " << rle_chunk->NumSymbols()
                     << " but only " << max_size << " left to read.";
     delete rle_chunk;
     return nullptr;
   }
   return rle_chunk;
 }
 
 }  // namespace rtcp
 }  // namespace webrtc