Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/p2p/base/stun.cc

 /*
  *  Copyright 2004 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/p2p/base/stun.h"
 
 #include <string.h>
 
 #include <memory>
 
 #include "webrtc/base/byteorder.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/crc32.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
 #include "webrtc/base/stringencode.h"
 
 using rtc::ByteBufferReader;
 using rtc::ByteBufferWriter;
 
 namespace cricket {
@@ skipping 13 matching lines @@
 const char TURN_MAGIC_COOKIE_VALUE[] = { '\x72', '\xC6', '\x4B', '\xC6' };
 const char EMPTY_TRANSACTION_ID[] = "0000000000000000";
 const uint32_t STUN_FINGERPRINT_XOR_VALUE = 0x5354554E;
 
 // StunMessage
 
 StunMessage::StunMessage()
     : type_(0),
       length_(0),
       transaction_id_(EMPTY_TRANSACTION_ID) {
-  ASSERT(IsValidTransactionId(transaction_id_));
+  RTC_DCHECK(IsValidTransactionId(transaction_id_));
   attrs_ = new std::vector<StunAttribute*>();
 }
 
 StunMessage::~StunMessage() {
   for (size_t i = 0; i < attrs_->size(); i++)
     delete (*attrs_)[i];
   delete attrs_;
 }
 
 bool StunMessage::IsLegacy() const {
   if (transaction_id_.size() == kStunLegacyTransactionIdLength)
     return true;
-  ASSERT(transaction_id_.size() == kStunTransactionIdLength);
+  RTC_DCHECK(transaction_id_.size() == kStunTransactionIdLength);
   return false;
 }
 
 bool StunMessage::SetTransactionID(const std::string& str) {
   if (!IsValidTransactionId(str)) {
     return false;
   }
   transaction_id_ = str;
   return true;
 }
@@ skipping 116 matching lines @@
     //     |0 0|     STUN Message Type     |         Message Length        |
     //     +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     rtc::SetBE16(temp_data.get() + 2, static_cast<uint16_t>(new_adjusted_len));
   }
 
   char hmac[kStunMessageIntegritySize];
   size_t ret = rtc::ComputeHmac(rtc::DIGEST_SHA_1,
                                       password.c_str(), password.size(),
                                       temp_data.get(), mi_pos,
                                       hmac, sizeof(hmac));
-  ASSERT(ret == sizeof(hmac));
+  RTC_DCHECK(ret == sizeof(hmac));
   if (ret != sizeof(hmac))
     return false;
 
   // Comparing the calculated HMAC with the one present in the message.
   return memcmp(data + current_pos + kStunAttributeHeaderSize,
                 hmac,
                 sizeof(hmac)) == 0;
 }
 
 bool StunMessage::AddMessageIntegrity(const std::string& password) {
@@ skipping 14 matching lines @@
   if (!Write(&buf))
     return false;
 
   int msg_len_for_hmac = static_cast<int>(
       buf.Length() - kStunAttributeHeaderSize - msg_integrity_attr->length());
   char hmac[kStunMessageIntegritySize];
   size_t ret = rtc::ComputeHmac(rtc::DIGEST_SHA_1,
                                       key, keylen,
                                       buf.Data(), msg_len_for_hmac,
                                       hmac, sizeof(hmac));
-  ASSERT(ret == sizeof(hmac));
+  RTC_DCHECK(ret == sizeof(hmac));
   if (ret != sizeof(hmac)) {
     LOG(LS_ERROR) << "HMAC computation failed. Message-Integrity "
                   << "has dummy value.";
     return false;
   }
 
   // Insert correct HMAC into the attribute.
   msg_integrity_attr->CopyBytes(hmac, sizeof(hmac));
   return true;
 }
@@ skipping 70 matching lines @@
   if (!buf->ReadString(&transaction_id, kStunTransactionIdLength))
     return false;
 
   uint32_t magic_cookie_int =
       *reinterpret_cast<const uint32_t*>(magic_cookie.data());
   if (rtc::NetworkToHost32(magic_cookie_int) != kStunMagicCookie) {
     // If magic cookie is invalid it means that the peer implements
     // RFC3489 instead of RFC5389.
     transaction_id.insert(0, magic_cookie);
   }
-  ASSERT(IsValidTransactionId(transaction_id));
+  RTC_DCHECK(IsValidTransactionId(transaction_id));
   transaction_id_ = transaction_id;
 
   if (length_ != buf->Length())
     return false;
 
   attrs_->resize(0);
 
   size_t rest = buf->Length() - length_;
   while (buf->Length() > rest) {
     uint16_t attr_type, attr_length;
@@ skipping 12 matching lines @@
       if (!buf->Consume(attr_length))
         return false;
     } else {
       if (!attr->Read(buf))
         return false;
       // TODO(honghaiz): Change |attrs_| to be a vector of unique_ptrs.
       attrs_->push_back(attr.release());
     }
   }
 
-  ASSERT(buf->Length() == rest);
+  RTC_DCHECK(buf->Length() == rest);
   return true;
 }
 
 bool StunMessage::Write(ByteBufferWriter* buf) const {
   buf->WriteUInt16(type_);
   buf->WriteUInt16(length_);
   if (!IsLegacy())
     buf->WriteUInt32(kStunMagicCookie);
   buf->WriteString(transaction_id_);
 
@@ skipping 277 matching lines @@
 
 StunUInt32Attribute::StunUInt32Attribute(uint16_t type, uint32_t value)
     : StunAttribute(type, SIZE), bits_(value) {
 }
 
 StunUInt32Attribute::StunUInt32Attribute(uint16_t type)
     : StunAttribute(type, SIZE), bits_(0) {
 }
 
 bool StunUInt32Attribute::GetBit(size_t index) const {
-  ASSERT(index < 32);
+  RTC_DCHECK(index < 32);
   return static_cast<bool>((bits_ >> index) & 0x1);
 }
 
 void StunUInt32Attribute::SetBit(size_t index, bool value) {
-  ASSERT(index < 32);
+  RTC_DCHECK(index < 32);
   bits_ &= ~(1 << index);
   bits_ |= value ? (1 << index) : 0;
 }
 
 bool StunUInt32Attribute::Read(ByteBufferReader* buf) {
   if (length() != SIZE || !buf->ReadUInt32(&bits_))
     return false;
   return true;
 }
 
@@ skipping 50 matching lines @@
   CopyBytes(bytes, strlen(bytes));
 }
 
 void StunByteStringAttribute::CopyBytes(const void* bytes, size_t length) {
   char* new_bytes = new char[length];
   memcpy(new_bytes, bytes, length);
   SetBytes(new_bytes, length);
 }
 
 uint8_t StunByteStringAttribute::GetByte(size_t index) const {
-  ASSERT(bytes_ != NULL);
-  ASSERT(index < length());
+  RTC_DCHECK(bytes_ != NULL);
+  RTC_DCHECK(index < length());
   return static_cast<uint8_t>(bytes_[index]);
 }
 
 void StunByteStringAttribute::SetByte(size_t index, uint8_t value) {
-  ASSERT(bytes_ != NULL);
-  ASSERT(index < length());
+  RTC_DCHECK(bytes_ != NULL);
+  RTC_DCHECK(index < length());
   bytes_[index] = value;
 }
 
 bool StunByteStringAttribute::Read(ByteBufferReader* buf) {
   bytes_ = new char[length()];
   if (!buf->ReadBytes(bytes_, length())) {
     return false;
   }
 
   ConsumePadding(buf);
@@ skipping 162 matching lines @@
       digest, sizeof(digest));
   if (size == 0) {
     return false;
   }
 
   *hash = std::string(digest, size);
   return true;
 }
 
 }  // namespace cricket