Replace ASSERT, ENABLE(ASSERT), and ASSERT_NOT_REACHED in wtf

third_party/WebKit/Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 64 matching lines @@
   }
 };
 
 template <bool unusedSlotsMustBeZeroed, typename T>
 struct VectorUnusedSlotClearer;
 
 template <typename T>
 struct VectorUnusedSlotClearer<false, T> {
   STATIC_ONLY(VectorUnusedSlotClearer);
   static void clear(T*, T*) {}
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   static void checkCleared(const T*, const T*) {}
 #endif
 };
 
 template <typename T>
 struct VectorUnusedSlotClearer<true, T> {
   STATIC_ONLY(VectorUnusedSlotClearer);
   static void clear(T* begin, T* end) {
     memset(reinterpret_cast<void*>(begin), 0, sizeof(T) * (end - begin));
   }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   static void checkCleared(const T* begin, const T* end) {
     const unsigned char* unusedArea =
         reinterpret_cast<const unsigned char*>(begin);
     const unsigned char* endAddress =
         reinterpret_cast<const unsigned char*>(end);
-    ASSERT(endAddress >= unusedArea);
+    DCHECK_GE(endAddress, unusedArea);
     for (int i = 0; i < endAddress - unusedArea; ++i)
-      ASSERT(!unusedArea[i]);
+      DCHECK(!unusedArea[i]);
   }
 #endif
 };
 
 template <bool canInitializeWithMemset, typename T>
 struct VectorInitializer;
 
 template <typename T>
 struct VectorInitializer<false, T> {
   STATIC_ONLY(VectorInitializer);
@@ skipping 122 matching lines @@
   }
 };
 
 template <bool canCompareWithMemcmp, typename T>
 struct VectorComparer;
 
 template <typename T>
 struct VectorComparer<false, T> {
   STATIC_ONLY(VectorComparer);
   static bool compare(const T* a, const T* b, size_t size) {
-    ASSERT(a);
-    ASSERT(b);
+    DCHECK(a);
+    DCHECK(b);
     return std::equal(a, a + size, b);
   }
 };
 
 template <typename T>
 struct VectorComparer<true, T> {
   STATIC_ONLY(VectorComparer);
   static bool compare(const T* a, const T* b, size_t size) {
-    ASSERT(a);
-    ASSERT(b);
+    DCHECK(a);
+    DCHECK(b);
     return memcmp(a, b, sizeof(T) * size) == 0;
   }
 };
 
 template <typename T>
 struct VectorElementComparer {
   STATIC_ONLY(VectorElementComparer);
   template <typename U>
   static bool compareElement(const T& left, const U& right) {
     return left == right;
@@ skipping 57 matching lines @@
   }
 };
 
 template <typename T, bool hasInlineCapacity, typename Allocator>
 class VectorBufferBase {
   WTF_MAKE_NONCOPYABLE(VectorBufferBase);
   DISALLOW_NEW();
 
  public:
   void allocateBuffer(size_t newCapacity) {
-    ASSERT(newCapacity);
+    DCHECK(newCapacity);
     size_t sizeToAllocate = allocationSize(newCapacity);
     if (hasInlineCapacity)
       m_buffer =
           Allocator::template allocateInlineVectorBacking<T>(sizeToAllocate);
     else
       m_buffer = Allocator::template allocateVectorBacking<T>(sizeToAllocate);
     m_capacity = sizeToAllocate / sizeof(T);
   }
 
   void allocateExpandedBuffer(size_t newCapacity) {
-    ASSERT(newCapacity);
+    DCHECK(newCapacity);
     size_t sizeToAllocate = allocationSize(newCapacity);
     if (hasInlineCapacity)
       m_buffer =
           Allocator::template allocateInlineVectorBacking<T>(sizeToAllocate);
     else
       m_buffer =
           Allocator::template allocateExpandedVectorBacking<T>(sizeToAllocate);
     m_capacity = sizeToAllocate / sizeof(T);
   }
 
@@ skipping 10 matching lines @@
     // finalizing, we clear out the unused slots so that the visitor or the
     // finalizer does not cause a problem when visiting the unused slots.
     VectorUnusedSlotClearer<
         Allocator::isGarbageCollected &&
             (VectorTraits<T>::needsDestruction ||
              IsTraceableInCollectionTrait<VectorTraits<T>>::value),
         T>::clear(from, to);
   }
 
   void checkUnusedSlots(const T* from, const T* to) {
-#if ENABLE(ASSERT) && !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
+#if DCHECK_IS_ON() && !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
     VectorUnusedSlotClearer<
         Allocator::isGarbageCollected &&
             (VectorTraits<T>::needsDestruction ||
              IsTraceableInCollectionTrait<VectorTraits<T>>::value),
         T>::checkCleared(from, to);
 #endif
   }
 
   // |end| is exclusive, a la STL.
   struct OffsetRange final {
     OffsetRange() : begin(0), end(0) {}
     explicit OffsetRange(size_t begin, size_t end) : begin(begin), end(end) {
-      ASSERT(begin <= end);
+      DCHECK_LE(begin, end);
     }
     bool empty() const { return begin == end; }
     size_t begin;
     size_t end;
   };
 
  protected:
   VectorBufferBase() : m_buffer(nullptr), m_capacity(0) {}
 
   VectorBufferBase(T* buffer, size_t capacity)
@@ skipping 39 matching lines @@
   bool expandBuffer(size_t newCapacity) {
     size_t sizeToAllocate = allocationSize(newCapacity);
     if (Allocator::expandVectorBacking(m_buffer, sizeToAllocate)) {
       m_capacity = sizeToAllocate / sizeof(T);
       return true;
     }
     return false;
   }
 
   inline bool shrinkBuffer(size_t newCapacity) {
-    ASSERT(newCapacity < capacity());
+    DCHECK_LT(newCapacity, capacity());
     size_t sizeToAllocate = allocationSize(newCapacity);
     if (Allocator::shrinkVectorBacking(m_buffer, allocationSize(capacity()),
                                        sizeToAllocate)) {
       m_capacity = sizeToAllocate / sizeof(T);
       return true;
     }
     return false;
   }
 
   void resetBufferPointer() {
@@ skipping 65 matching lines @@
   NEVER_INLINE void reallyDeallocateBuffer(T* bufferToDeallocate) {
     Allocator::freeInlineVectorBacking(bufferToDeallocate);
   }
 
   void deallocateBuffer(T* bufferToDeallocate) {
     if (UNLIKELY(bufferToDeallocate != inlineBuffer()))
       reallyDeallocateBuffer(bufferToDeallocate);
   }
 
   bool expandBuffer(size_t newCapacity) {
-    ASSERT(newCapacity > inlineCapacity);
+    DCHECK_GT(newCapacity, inlineCapacity);
     if (m_buffer == inlineBuffer())
       return false;
 
     size_t sizeToAllocate = allocationSize(newCapacity);
     if (Allocator::expandInlineVectorBacking(m_buffer, sizeToAllocate)) {
       m_capacity = sizeToAllocate / sizeof(T);
       return true;
     }
     return false;
   }
 
   inline bool shrinkBuffer(size_t newCapacity) {
-    ASSERT(newCapacity < capacity());
+    DCHECK_LT(newCapacity, capacity());
     if (newCapacity <= inlineCapacity) {
       // We need to switch to inlineBuffer.  Vector::shrinkCapacity will
       // handle it.
       return false;
     }
-    ASSERT(m_buffer != inlineBuffer());
+    DCHECK_NE(m_buffer, inlineBuffer());
     size_t newSize = allocationSize(newCapacity);
     if (!Allocator::shrinkInlineVectorBacking(
             m_buffer, allocationSize(capacity()), newSize))
       return false;
     m_capacity = newSize / sizeof(T);
     return true;
   }
 
   void resetBufferPointer() {
     m_buffer = inlineBuffer();
     m_capacity = inlineCapacity;
   }
 
   void allocateBuffer(size_t newCapacity) {
-    // FIXME: This should ASSERT(!m_buffer) to catch misuse/leaks.
+    // FIXME: This should DCHECK(!m_buffer) to catch misuse/leaks.
     if (newCapacity > inlineCapacity)
       Base::allocateBuffer(newCapacity);
     else
       resetBufferPointer();
   }
 
   void allocateExpandedBuffer(size_t newCapacity) {
     if (newCapacity > inlineCapacity)
       Base::allocateExpandedBuffer(newCapacity);
     else
@@ skipping 52 matching lines @@
     // buffer's inline buffer. Elements in an out-of-line buffer won't move,
     // because we can just swap pointers of out-of-line buffers.
     T* thisSourceBegin = nullptr;
     size_t thisSourceSize = 0;
     T* thisDestinationBegin = nullptr;
     if (buffer() == inlineBuffer()) {
       thisSourceBegin = buffer();
       thisSourceSize = m_size;
       thisDestinationBegin = other.inlineBuffer();
       if (!thisHole.empty()) {  // Sanity check.
-        ASSERT(thisHole.begin < thisHole.end);
-        ASSERT(thisHole.end <= thisSourceSize);
+        DCHECK_LT(thisHole.begin, thisHole.end);
+        DCHECK_LE(thisHole.end, thisSourceSize);
       }
     } else {
       // We don't need the hole information for an out-of-line buffer.
       thisHole.begin = thisHole.end = 0;
     }
     T* otherSourceBegin = nullptr;
     size_t otherSourceSize = 0;
     T* otherDestinationBegin = nullptr;
     if (other.buffer() == other.inlineBuffer()) {
       otherSourceBegin = other.buffer();
       otherSourceSize = other.m_size;
       otherDestinationBegin = inlineBuffer();
       if (!otherHole.empty()) {
-        ASSERT(otherHole.begin < otherHole.end);
-        ASSERT(otherHole.end <= otherSourceSize);
+        DCHECK_LT(otherHole.begin, otherHole.end);
+        DCHECK_LE(otherHole.end, otherSourceSize);
       }
     } else {
       otherHole.begin = otherHole.end = 0;
     }
 
     // Next, we mutate members and do other bookkeeping. We do pointer swapping
     // (for out-of-line buffers) here if we can. From now on, don't assume
     // buffer() or capacity() maintains their original values.
     std::swap(m_capacity, other.m_capacity);
     if (thisSourceBegin &&
         !otherSourceBegin) {  // Our buffer is inline, theirs is not.
-      ASSERT(buffer() == inlineBuffer());
-      ASSERT(other.buffer() != other.inlineBuffer());
+      DCHECK_EQ(buffer(), inlineBuffer());
+      DCHECK_NE(other.buffer(), other.inlineBuffer());
       ANNOTATE_DELETE_BUFFER(m_buffer, inlineCapacity, m_size);
       m_buffer = other.buffer();
       other.m_buffer = other.inlineBuffer();
       std::swap(m_size, other.m_size);
       ANNOTATE_NEW_BUFFER(other.m_buffer, inlineCapacity, other.m_size);
     } else if (!thisSourceBegin &&
                otherSourceBegin) {  // Their buffer is inline, ours is not.
-      ASSERT(buffer() != inlineBuffer());
-      ASSERT(other.buffer() == other.inlineBuffer());
+      DCHECK_NE(buffer(), inlineBuffer());
+      DCHECK_EQ(other.buffer(), other.inlineBuffer());
       ANNOTATE_DELETE_BUFFER(other.m_buffer, inlineCapacity, other.m_size);
       other.m_buffer = buffer();
       m_buffer = inlineBuffer();
       std::swap(m_size, other.m_size);
       ANNOTATE_NEW_BUFFER(m_buffer, inlineCapacity, m_size);
     } else {  // Both buffers are inline.
-      ASSERT(thisSourceBegin && otherSourceBegin);
-      ASSERT(buffer() == inlineBuffer());
-      ASSERT(other.buffer() == other.inlineBuffer());
+      DCHECK(thisSourceBegin);
+      DCHECK(otherSourceBegin);
+      DCHECK_EQ(buffer(), inlineBuffer());
+      DCHECK_EQ(other.buffer(), other.inlineBuffer());
       ANNOTATE_CHANGE_SIZE(m_buffer, inlineCapacity, m_size, other.m_size);
       ANNOTATE_CHANGE_SIZE(other.m_buffer, inlineCapacity, other.m_size,
                            m_size);
       std::swap(m_size, other.m_size);
     }
 
     // We are ready to move elements. We determine an action for each "section",
     // which is a contiguous range such that all elements in the range are
     // treated similarly.
     size_t sectionBegin = 0;
     while (sectionBegin < inlineCapacity) {
       // To determine the end of this section, we list up all the boundaries
       // where the "occupiedness" may change.
       size_t sectionEnd = inlineCapacity;
       if (thisSourceBegin && sectionBegin < thisSourceSize)
         sectionEnd = std::min(sectionEnd, thisSourceSize);
       if (!thisHole.empty() && sectionBegin < thisHole.begin)
         sectionEnd = std::min(sectionEnd, thisHole.begin);
       if (!thisHole.empty() && sectionBegin < thisHole.end)
         sectionEnd = std::min(sectionEnd, thisHole.end);
       if (otherSourceBegin && sectionBegin < otherSourceSize)
         sectionEnd = std::min(sectionEnd, otherSourceSize);
       if (!otherHole.empty() && sectionBegin < otherHole.begin)
         sectionEnd = std::min(sectionEnd, otherHole.begin);
       if (!otherHole.empty() && sectionBegin < otherHole.end)
         sectionEnd = std::min(sectionEnd, otherHole.end);
 
-      ASSERT(sectionBegin < sectionEnd);
+      DCHECK_LT(sectionBegin, sectionEnd);
 
       // Is the |sectionBegin|-th element of |thisSource| occupied?
       bool thisOccupied = false;
       if (thisSourceBegin && sectionBegin < thisSourceSize) {
         // Yes, it's occupied, unless the position is in a hole.
         if (thisHole.empty() || sectionBegin < thisHole.begin ||
             sectionBegin >= thisHole.end)
           thisOccupied = true;
       }
       bool otherOccupied = false;
       if (otherSourceBegin && sectionBegin < otherSourceSize) {
         if (otherHole.empty() || sectionBegin < otherHole.begin ||
             sectionBegin >= otherHole.end)
           otherOccupied = true;
       }
 
       if (thisOccupied && otherOccupied) {
         // Both occupied; swap them. In this case, one's destination must be the
         // other's source (i.e. both ranges are in inline buffers).
-        ASSERT(thisDestinationBegin == otherSourceBegin);
-        ASSERT(otherDestinationBegin == thisSourceBegin);
+        DCHECK_EQ(thisDestinationBegin, otherSourceBegin);
+        DCHECK_EQ(otherDestinationBegin, thisSourceBegin);
         TypeOperations::swap(thisSourceBegin + sectionBegin,
                              thisSourceBegin + sectionEnd,
                              otherSourceBegin + sectionBegin);
       } else if (thisOccupied) {
         // Move from ours to theirs.
         TypeOperations::move(thisSourceBegin + sectionBegin,
                              thisSourceBegin + sectionEnd,
                              thisDestinationBegin + sectionBegin);
         Base::clearUnusedSlots(thisSourceBegin + sectionBegin,
                                thisSourceBegin + sectionEnd);
@@ skipping 217 matching lines @@
   void prepend(const U*, size_t);
   template <typename U>
   void prepend(U&&);
   template <typename U, size_t c, typename V>
   void prependVector(const Vector<U, c, V>&);
 
   void remove(size_t position);
   void remove(size_t position, size_t length);
 
   void pop_back() {
-    ASSERT(!isEmpty());
+    DCHECK(!isEmpty());
     shrink(size() - 1);
   }
 
   Vector(size_t size, const T& val) : Base(size) {
     ANNOTATE_NEW_BUFFER(begin(), capacity(), size);
     m_size = size;
     TypeOperations::uninitializedFill(begin(), end(), val);
   }
 
   void fill(const T&, size_t);
@@ skipping 65 matching lines @@
 Vector<T, inlineCapacity, Allocator>& Vector<T, inlineCapacity, Allocator>::
 operator=(const Vector<T, inlineCapacity, Allocator>& other) {
   if (UNLIKELY(&other == this))
     return *this;
 
   if (size() > other.size()) {
     shrink(other.size());
   } else if (other.size() > capacity()) {
     clear();
     reserveCapacity(other.size());
-    ASSERT(begin());
+    DCHECK(begin());
   }
 
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, other.size());
   std::copy(other.begin(), other.begin() + size(), begin());
   TypeOperations::uninitializedCopy(other.begin() + size(), other.end(), end());
   m_size = other.size();
 
   return *this;
 }
 
 inline bool typelessPointersAreEqual(const void* a, const void* b) {
   return a == b;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <size_t otherCapacity>
 Vector<T, inlineCapacity, Allocator>& Vector<T, inlineCapacity, Allocator>::
 operator=(const Vector<T, otherCapacity, Allocator>& other) {
   // If the inline capacities match, we should call the more specific
   // template.  If the inline capacities don't match, the two objects
   // shouldn't be allocated the same address.
-  ASSERT(!typelessPointersAreEqual(&other, this));
+  DCHECK(!typelessPointersAreEqual(&other, this));
 
   if (size() > other.size()) {
     shrink(other.size());
   } else if (other.size() > capacity()) {
     clear();
     reserveCapacity(other.size());
-    ASSERT(begin());
+    DCHECK(begin());
   }
 
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, other.size());
   std::copy(other.begin(), other.begin() + size(), begin());
   TypeOperations::uninitializedCopy(other.begin() + size(), other.end(), end());
   m_size = other.size();
 
   return *this;
 }
 
@@ skipping 72 matching lines @@
   return kNotFound;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 void Vector<T, inlineCapacity, Allocator>::fill(const T& val, size_t newSize) {
   if (size() > newSize) {
     shrink(newSize);
   } else if (newSize > capacity()) {
     clear();
     reserveCapacity(newSize);
-    ASSERT(begin());
+    DCHECK(begin());
   }
 
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, newSize);
   std::fill(begin(), end(), val);
   TypeOperations::uninitializedFill(end(), begin() + newSize, val);
   m_size = newSize;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename Iterator>
@@ skipping 63 matching lines @@
       expandCapacity(size);
     ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, size);
     TypeOperations::initialize(end(), begin() + size);
   }
 
   m_size = size;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 void Vector<T, inlineCapacity, Allocator>::shrink(size_t size) {
-  ASSERT(size <= m_size);
+  DCHECK_LE(size, m_size);
   TypeOperations::destruct(begin() + size, end());
   clearUnusedSlots(begin() + size, end());
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, size);
   m_size = size;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 void Vector<T, inlineCapacity, Allocator>::grow(size_t size) {
-  ASSERT(size >= m_size);
+  DCHECK_GE(size, m_size);
   if (size > capacity())
     expandCapacity(size);
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, size);
   TypeOperations::initialize(end(), begin() + size);
   m_size = size;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 void Vector<T, inlineCapacity, Allocator>::reserveCapacity(size_t newCapacity) {
   if (UNLIKELY(newCapacity <= capacity()))
@@ skipping 18 matching lines @@
   ANNOTATE_NEW_BUFFER(begin(), capacity(), m_size);
   TypeOperations::move(oldBuffer, oldEnd, begin());
   clearUnusedSlots(oldBuffer, oldEnd);
   ANNOTATE_DELETE_BUFFER(oldBuffer, oldCapacity, m_size);
   Base::deallocateBuffer(oldBuffer);
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void Vector<T, inlineCapacity, Allocator>::reserveInitialCapacity(
     size_t initialCapacity) {
-  ASSERT(!m_size);
-  ASSERT(capacity() == INLINE_CAPACITY);
+  DCHECK(!m_size);
+  DCHECK(capacity() == INLINE_CAPACITY);
   if (initialCapacity > INLINE_CAPACITY) {
     ANNOTATE_DELETE_BUFFER(begin(), capacity(), m_size);
     Base::allocateBuffer(initialCapacity);
     ANNOTATE_NEW_BUFFER(begin(), capacity(), m_size);
   }
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 void Vector<T, inlineCapacity, Allocator>::shrinkCapacity(size_t newCapacity) {
   if (newCapacity >= capacity())
@@ skipping 34 matching lines @@
 }
 
 // Templatizing these is better than just letting the conversion happen
 // implicitly, because for instance it allows a PassRefPtr to be appended to a
 // RefPtr vector without refcount thrash.
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 void Vector<T, inlineCapacity, Allocator>::append(const U* data,
                                                   size_t dataSize) {
-  ASSERT(Allocator::isAllocationAllowed());
+  DCHECK(Allocator::isAllocationAllowed());
   size_t newSize = m_size + dataSize;
   if (newSize > capacity()) {
     data = expandCapacity(newSize, data);
-    ASSERT(begin());
+    DCHECK(begin());
   }
   RELEASE_ASSERT(newSize >= m_size);
   T* dest = end();
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, newSize);
   VectorCopier<VectorTraits<T>::canCopyWithMemcpy, T>::uninitializedCopy(
       data, &data[dataSize], dest);
   m_size = newSize;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 ALWAYS_INLINE void Vector<T, inlineCapacity, Allocator>::push_back(U&& val) {
   return append(std::forward<U>(val));
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 ALWAYS_INLINE void Vector<T, inlineCapacity, Allocator>::append(U&& val) {
-  ASSERT(Allocator::isAllocationAllowed());
+  DCHECK(Allocator::isAllocationAllowed());
   if (LIKELY(size() != capacity())) {
     ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, m_size + 1);
     new (NotNull, end()) T(std::forward<U>(val));
     ++m_size;
     return;
   }
 
   appendSlowCase(std::forward<U>(val));
 }
 
@@ skipping 11 matching lines @@
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, m_size + 1);
   T* t = new (NotNull, end()) T(std::forward<Args>(args)...);
   ++m_size;
   return *t;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 NEVER_INLINE void Vector<T, inlineCapacity, Allocator>::appendSlowCase(
     U&& val) {
-  ASSERT(size() == capacity());
+  DCHECK_EQ(size(), capacity());
 
   typename std::remove_reference<U>::type* ptr = &val;
   ptr = expandCapacity(size() + 1, ptr);
-  ASSERT(begin());
+  DCHECK(begin());
 
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, m_size + 1);
   new (NotNull, end()) T(std::forward<U>(*ptr));
   ++m_size;
 }
 
 // This version of append saves a branch in the case where you know that the
 // vector's capacity is large enough for the append to succeed.
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 ALWAYS_INLINE void Vector<T, inlineCapacity, Allocator>::uncheckedAppend(
     U&& val) {
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
   // Vectors in ASAN builds don't have inlineCapacity.
   append(std::forward<U>(val));
 #else
-  ASSERT(size() < capacity());
+  DCHECK_LT(size(), capacity());
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, m_size + 1);
   new (NotNull, end()) T(std::forward<U>(val));
   ++m_size;
 #endif
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U, size_t otherCapacity, typename OtherAllocator>
 inline void Vector<T, inlineCapacity, Allocator>::appendVector(
     const Vector<U, otherCapacity, OtherAllocator>& val) {
   append(val.begin(), val.size());
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 void Vector<T, inlineCapacity, Allocator>::insert(size_t position,
                                                   const U* data,
                                                   size_t dataSize) {
-  ASSERT(Allocator::isAllocationAllowed());
+  DCHECK(Allocator::isAllocationAllowed());
   RELEASE_ASSERT(position <= size());
   size_t newSize = m_size + dataSize;
   if (newSize > capacity()) {
     data = expandCapacity(newSize, data);
-    ASSERT(begin());
+    DCHECK(begin());
   }
   RELEASE_ASSERT(newSize >= m_size);
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, newSize);
   T* spot = begin() + position;
   TypeOperations::moveOverlapping(spot, end(), spot + dataSize);
   VectorCopier<VectorTraits<T>::canCopyWithMemcpy, T>::uninitializedCopy(
       data, &data[dataSize], spot);
   m_size = newSize;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 inline void Vector<T, inlineCapacity, Allocator>::insert(size_t position,
                                                          U&& val) {
-  ASSERT(Allocator::isAllocationAllowed());
+  DCHECK(Allocator::isAllocationAllowed());
   RELEASE_ASSERT(position <= size());
   typename std::remove_reference<U>::type* data = &val;
   if (size() == capacity()) {
     data = expandCapacity(size() + 1, data);
-    ASSERT(begin());
+    DCHECK(begin());
   }
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, m_size + 1);
   T* spot = begin() + position;
   TypeOperations::moveOverlapping(spot, end(), spot + 1);
   new (NotNull, spot) T(std::forward<U>(*data));
   ++m_size;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U, size_t c, typename OtherAllocator>
@@ skipping 82 matching lines @@
 inline bool operator!=(const Vector<T, inlineCapacityA, Allocator>& a,
                        const Vector<T, inlineCapacityB, Allocator>& b) {
   return !(a == b);
 }
 
 // This is only called if the allocator is a HeapAllocator. It is used when
 // visiting during a tracing GC.
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename VisitorDispatcher>
 void Vector<T, inlineCapacity, Allocator>::trace(VisitorDispatcher visitor) {
-  ASSERT(Allocator::isGarbageCollected);  // Garbage collector must be enabled.
+  DCHECK(Allocator::isGarbageCollected) << "Garbage collector must be enabled.";
   if (!buffer())
     return;
   if (this->hasOutOfLineBuffer()) {
     // This is a performance optimization for a case where the buffer has
     // been already traced by somewhere. This can happen if the conservative
     // scanning traced an on-stack (false-positive or real) pointer to the
     // HeapVector, and then visitor->trace() traces the HeapVector.
     if (Allocator::isHeapObjectAlive(buffer()))
       return;
     Allocator::markNoTracing(visitor, buffer());
     Allocator::registerBackingStoreReference(visitor, Base::bufferSlot());
   }
   const T* bufferBegin = buffer();
   const T* bufferEnd = buffer() + size();
   if (IsTraceableInCollectionTrait<VectorTraits<T>>::value) {
     for (const T* bufferEntry = bufferBegin; bufferEntry != bufferEnd;
          bufferEntry++)
       Allocator::template trace<VisitorDispatcher, T, VectorTraits<T>>(
           visitor, *const_cast<T*>(bufferEntry));
     checkUnusedSlots(buffer() + size(), buffer() + capacity());
   }
 }
 
 }  // namespace WTF
 
 using WTF::Vector;
 
 #endif  // WTF_Vector_h