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

webrtc/base/bitbuffer.cc

 /*
  *  Copyright 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.
  */
 
 #include "webrtc/base/bitbuffer.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "webrtc/base/checks.h"
 
 namespace {
 
 // Returns the lowest (right-most) |bit_count| bits in |byte|.
 uint8_t LowestBits(uint8_t byte, size_t bit_count) {
-  DCHECK_LE(bit_count, 8u);
+  RTC_DCHECK_LE(bit_count, 8u);
   return byte & ((1 << bit_count) - 1);
 }
 
 // Returns the highest (left-most) |bit_count| bits in |byte|, shifted to the
 // lowest bits (to the right).
 uint8_t HighestBits(uint8_t byte, size_t bit_count) {
-  DCHECK_LE(bit_count, 8u);
+  RTC_DCHECK_LE(bit_count, 8u);
   uint8_t shift = 8 - static_cast<uint8_t>(bit_count);
   uint8_t mask = 0xFF << shift;
   return (byte & mask) >> shift;
 }
 
 // Returns the highest byte of |val| in a uint8_t.
 uint8_t HighestByte(uint64_t val) {
   return static_cast<uint8_t>(val >> 56);
 }
 
 // Returns the result of writing partial data from |source|, of
 // |source_bit_count| size in the highest bits, to |target| at
 // |target_bit_offset| from the highest bit.
 uint8_t WritePartialByte(uint8_t source,
                          size_t source_bit_count,
                          uint8_t target,
                          size_t target_bit_offset) {
-  DCHECK(target_bit_offset < 8);
-  DCHECK(source_bit_count < 9);
-  DCHECK(source_bit_count <= (8 - target_bit_offset));
+  RTC_DCHECK(target_bit_offset < 8);
+  RTC_DCHECK(source_bit_count < 9);
+  RTC_DCHECK(source_bit_count <= (8 - target_bit_offset));
   // Generate a mask for just the bits we're going to overwrite, so:
   uint8_t mask =
       // The number of bits we want, in the most significant bits...
       static_cast<uint8_t>(0xFF << (8 - source_bit_count))
       // ...shifted over to the target offset from the most signficant bit.
       >> target_bit_offset;
 
   // We want the target, with the bits we'll overwrite masked off, or'ed with
   // the bits from the source we want.
   return (target & ~mask) | (source >> target_bit_offset);
 }
 
 // Counts the number of bits used in the binary representation of val.
 size_t CountBits(uint64_t val) {
   size_t bit_count = 0;
   while (val != 0) {
     bit_count++;
     val >>= 1;
   }
   return bit_count;
 }
 
 }  // namespace
 
 namespace rtc {
 
 BitBuffer::BitBuffer(const uint8_t* bytes, size_t byte_count)
     : bytes_(bytes), byte_count_(byte_count), byte_offset_(), bit_offset_() {
-  DCHECK(static_cast<uint64_t>(byte_count_) <=
-         std::numeric_limits<uint32_t>::max());
+  RTC_DCHECK(static_cast<uint64_t>(byte_count_) <=
+             std::numeric_limits<uint32_t>::max());
 }
 
 uint64_t BitBuffer::RemainingBitCount() const {
   return (static_cast<uint64_t>(byte_count_) - byte_offset_) * 8 - bit_offset_;
 }
 
 bool BitBuffer::ReadUInt8(uint8_t* val) {
   uint32_t bit_val;
   if (!ReadBits(&bit_val, sizeof(uint8_t) * 8)) {
     return false;
   }
-  DCHECK(bit_val <= std::numeric_limits<uint8_t>::max());
+  RTC_DCHECK(bit_val <= std::numeric_limits<uint8_t>::max());
   *val = static_cast<uint8_t>(bit_val);
   return true;
 }
 
 bool BitBuffer::ReadUInt16(uint16_t* val) {
   uint32_t bit_val;
   if (!ReadBits(&bit_val, sizeof(uint16_t) * 8)) {
     return false;
   }
-  DCHECK(bit_val <= std::numeric_limits<uint16_t>::max());
+  RTC_DCHECK(bit_val <= std::numeric_limits<uint16_t>::max());
   *val = static_cast<uint16_t>(bit_val);
   return true;
 }
 
 bool BitBuffer::ReadUInt32(uint32_t* val) {
   return ReadBits(val, sizeof(uint32_t) * 8);
 }
 
 bool BitBuffer::PeekBits(uint32_t* val, size_t bit_count) {
   if (!val || bit_count > RemainingBitCount() || bit_count > 32) {
@@ skipping 54 matching lines @@
 
   // Count the number of leading 0 bits by peeking/consuming them one at a time.
   size_t zero_bit_count = 0;
   uint32_t peeked_bit;
   while (PeekBits(&peeked_bit, 1) && peeked_bit == 0) {
     zero_bit_count++;
     ConsumeBits(1);
   }
 
   // We should either be at the end of the stream, or the next bit should be 1.
-  DCHECK(!PeekBits(&peeked_bit, 1) || peeked_bit == 1);
+  RTC_DCHECK(!PeekBits(&peeked_bit, 1) || peeked_bit == 1);
 
   // The bit count of the value is the number of zeros + 1. Make sure that many
   // bits fits in a uint32_t and that we have enough bits left for it, and then
   // read the value.
   size_t value_bit_count = zero_bit_count + 1;
   if (value_bit_count > 32 || !ReadBits(val, value_bit_count)) {
-    CHECK(Seek(original_byte_offset, original_bit_offset));
+    RTC_CHECK(Seek(original_byte_offset, original_bit_offset));
     return false;
   }
   *val -= 1;
   return true;
 }
 
 void BitBuffer::GetCurrentOffset(
     size_t* out_byte_offset, size_t* out_bit_offset) {
-  CHECK(out_byte_offset != NULL);
-  CHECK(out_bit_offset != NULL);
+  RTC_CHECK(out_byte_offset != NULL);
+  RTC_CHECK(out_bit_offset != NULL);
   *out_byte_offset = byte_offset_;
   *out_bit_offset = bit_offset_;
 }
 
 bool BitBuffer::Seek(size_t byte_offset, size_t bit_offset) {
   if (byte_offset > byte_count_ || bit_offset > 7 ||
       (byte_offset == byte_count_ && bit_offset > 0)) {
     return false;
   }
   byte_offset_ = byte_offset;
@@ skipping 70 matching lines @@
   }
   uint64_t val_to_encode = static_cast<uint64_t>(val) + 1;
 
   // We need to write CountBits(val+1) 0s and then val+1. Since val (as a
   // uint64_t) has leading zeros, we can just write the total golomb encoded
   // size worth of bits, knowing the value will appear last.
   return WriteBits(val_to_encode, CountBits(val_to_encode) * 2 - 1);
 }
 
 }  // namespace rtc