rtc::Buffer: Use RTC_DCHECK instead of assert

webrtc/base/buffer.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_BASE_BUFFER_H_
 #define WEBRTC_BASE_BUFFER_H_
 
-#include <cassert>
 #include <cstring>
 #include <memory>
 #include <utility>
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/deprecation.h"
 
 namespace rtc {
@@ skipping 49 matching lines @@
   template <typename T, size_t N, typename internal::ByteType<T>::t = 0>
   Buffer(const T(&array)[N])
       : Buffer(array, N) {}
 
   ~Buffer();
 
   // Get a pointer to the data. Just .data() will give you a (const) uint8_t*,
   // but you may also use .data<int8_t>() and .data<char>().
   template <typename T = uint8_t, typename internal::ByteType<T>::t = 0>
   const T* data() const {
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
     return reinterpret_cast<T*>(data_.get());
   }
 
   template <typename T = uint8_t, typename internal::ByteType<T>::t = 0>
   T* data() {
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
     return reinterpret_cast<T*>(data_.get());
   }
 
   size_t size() const {
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
     return size_;
   }
 
   size_t capacity() const {
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
     return capacity_;
   }
 
   Buffer& operator=(const Buffer& buf) {
     if (&buf != this)
       SetData(buf.data(), buf.size());
     return *this;
   }
 
   Buffer& operator=(Buffer&& buf) {
-    assert(IsConsistent());
-    assert(buf.IsConsistent());
+    RTC_DCHECK(IsConsistent());
+    RTC_DCHECK(buf.IsConsistent());
     size_ = buf.size_;
     capacity_ = buf.capacity_;
     data_ = std::move(buf.data_);
     buf.OnMovedFrom();
     return *this;
   }
 
   bool operator==(const Buffer& buf) const {
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
     return size_ == buf.size() && memcmp(data_.get(), buf.data(), size_) == 0;
   }
 
   bool operator!=(const Buffer& buf) const { return !(*this == buf); }
 
   // The SetData functions replace the contents of the buffer. They accept the
   // same input types as the constructors.
   template <typename T, typename internal::ByteType<T>::t = 0>
   void SetData(const T* data, size_t size) {
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
     size_ = 0;
     AppendData(data, size);
   }
 
   template <typename T, size_t N, typename internal::ByteType<T>::t = 0>
   void SetData(const T(&array)[N]) {
     SetData(array, N);
   }
 
   void SetData(const Buffer& buf) { SetData(buf.data(), buf.size()); }
@@ skipping 10 matching lines @@
   size_t SetData(size_t max_bytes, F&& setter) {
     RTC_DCHECK(IsConsistent());
     size_ = 0;
     return AppendData<T>(max_bytes, std::forward<F>(setter));
   }
 
   // The AppendData functions adds data to the end of the buffer. They accept
   // the same input types as the constructors.
   template <typename T, typename internal::ByteType<T>::t = 0>
   void AppendData(const T* data, size_t size) {
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
     const size_t new_size = size_ + size;
     EnsureCapacity(new_size);
     std::memcpy(data_.get() + size_, data, size);
     size_ = new_size;
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
   }
 
   template <typename T, size_t N, typename internal::ByteType<T>::t = 0>
   void AppendData(const T(&array)[N]) {
     AppendData(array, N);
   }
 
   void AppendData(const Buffer& buf) { AppendData(buf.data(), buf.size()); }
 
   // Append at most |max_bytes| of data to the end of the buffer, using the
@@ skipping 25 matching lines @@
   // uninitialized.
   void SetSize(size_t size) {
     EnsureCapacity(size);
     size_ = size;
   }
 
   // Ensure that the buffer size can be increased to at least capacity without
   // further reallocation. (Of course, this operation might need to reallocate
   // the buffer.)
   void EnsureCapacity(size_t capacity) {
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
     if (capacity <= capacity_)
       return;
     std::unique_ptr<uint8_t[]> new_data(new uint8_t[capacity]);
     std::memcpy(new_data.get(), data_.get(), size_);
     data_ = std::move(new_data);
     capacity_ = capacity;
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
   }
 
   // b.Pass() does the same thing as std::move(b).
   // Deprecated; remove in March 2016 (bug 5373).
   RTC_DEPRECATED Buffer&& Pass() { return DEPRECATED_Pass(); }
 
   Buffer&& DEPRECATED_Pass() {
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
     return std::move(*this);
   }
 
   // Resets the buffer to zero size without altering capacity. Works even if the
   // buffer has been moved from.
   void Clear() {
     size_ = 0;
-    assert(IsConsistent());
+    RTC_DCHECK(IsConsistent());
   }
 
   // Swaps two buffers. Also works for buffers that have been moved from.
   friend void swap(Buffer& a, Buffer& b) {
     using std::swap;
     swap(a.size_, b.size_);
     swap(a.capacity_, b.capacity_);
     swap(a.data_, b.data_);
   }
 
@@ skipping 22 matching lines @@
   }
 
   size_t size_;
   size_t capacity_;
   std::unique_ptr<uint8_t[]> data_;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_BUFFER_H_