RTC_[D]CHECK_op: Remove "u" suffix on integer constants

webrtc/modules/rtp_rtcp/source/rtp_packet.cc

 /*
  *  Copyright (c) 2016 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 235 matching lines @@
   timestamp_ = timestamp;
   ByteWriter<uint32_t>::WriteBigEndian(WriteAt(4), timestamp);
 }
 
 void Packet::SetSsrc(uint32_t ssrc) {
   ssrc_ = ssrc;
   ByteWriter<uint32_t>::WriteBigEndian(WriteAt(8), ssrc);
 }
 
 void Packet::SetCsrcs(const std::vector<uint32_t>& csrcs) {
-  RTC_DCHECK_EQ(num_extensions_, 0u);
-  RTC_DCHECK_EQ(payload_size_, 0u);
-  RTC_DCHECK_EQ(padding_size_, 0u);
+  RTC_DCHECK_EQ(num_extensions_, 0);
+  RTC_DCHECK_EQ(payload_size_, 0);
+  RTC_DCHECK_EQ(padding_size_, 0);
   RTC_DCHECK_LE(csrcs.size(), 0x0fu);
   RTC_DCHECK_LE(kFixedHeaderSize + 4 * csrcs.size(), capacity());
   payload_offset_ = kFixedHeaderSize + 4 * csrcs.size();
   WriteAt(0, (data()[0] & 0xF0) | csrcs.size());
   size_t offset = kFixedHeaderSize;
   for (uint32_t csrc : csrcs) {
     ByteWriter<uint32_t>::WriteBigEndian(WriteAt(offset), csrc);
     offset += 4;
   }
   buffer_.SetSize(payload_offset_);
 }
 
 uint8_t* Packet::AllocatePayload(size_t size_bytes) {
-  RTC_DCHECK_EQ(padding_size_, 0u);
+  RTC_DCHECK_EQ(padding_size_, 0);
   if (payload_offset_ + size_bytes > capacity()) {
     LOG(LS_WARNING) << "Cannot set payload, not enough space in buffer.";
     return nullptr;
   }
   // Reset payload size to 0. If CopyOnWrite buffer_ was shared, this will cause
   // reallocation and memcpy. Setting size to just headers reduces memcpy size.
   buffer_.SetSize(payload_offset_);
   payload_size_ = size_bytes;
   buffer_.SetSize(payload_offset_ + payload_size_);
   return WriteAt(payload_offset_);
 }
 
 void Packet::SetPayloadSize(size_t size_bytes) {
-  RTC_DCHECK_EQ(padding_size_, 0u);
+  RTC_DCHECK_EQ(padding_size_, 0);
   RTC_DCHECK_LE(size_bytes, payload_size_);
   payload_size_ = size_bytes;
   buffer_.SetSize(payload_offset_ + payload_size_);
 }
 
 bool Packet::SetPadding(uint8_t size_bytes, Random* random) {
   RTC_DCHECK(random);
   if (payload_offset_ + payload_size_ + size_bytes > capacity()) {
     LOG(LS_WARNING) << "Cannot set padding size " << size_bytes << ", only "
                     << (capacity() - payload_offset_ - payload_size_)
@@ skipping 169 matching lines @@
     return false;
   }
   if (padding_size_ > 0) {
     return false;
   }
 
   uint8_t extension_id = extensions_->GetId(type);
   if (extension_id == ExtensionManager::kInvalidId) {
     return false;
   }
-  RTC_DCHECK_GT(length, 0u);
-  RTC_DCHECK_LE(length, 16u);
+  RTC_DCHECK_GT(length, 0);
+  RTC_DCHECK_LE(length, 16);
 
   size_t num_csrc = data()[0] & 0x0F;
   size_t extensions_offset = kFixedHeaderSize + (num_csrc * 4) + 4;
   if (extensions_offset + extensions_size_ + kOneByteHeaderSize + length >
       capacity()) {
     LOG(LS_WARNING) << "Extension cannot be registered: "
                        "Not enough space left in buffer.";
     return false;
   }
 
@@ skipping 37 matching lines @@
 uint8_t* Packet::WriteAt(size_t offset) {
   return buffer_.data() + offset;
 }
 
 void Packet::WriteAt(size_t offset, uint8_t byte) {
   buffer_.data()[offset] = byte;
 }
 
 }  // namespace rtp
 }  // namespace webrtc