Replace all occurrences of RELEASE_ASSERT in wtf with CHECK.

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 823 matching lines @@
 
     Vector(std::initializer_list<T> elements);
     Vector& operator=(std::initializer_list<T> elements);
 
     size_t size() const { return m_size; }
     size_t capacity() const { return Base::capacity(); }
     bool isEmpty() const { return !size(); }
 
     T& at(size_t i)
     {
-        RELEASE_ASSERT(i < size());
+        CHECK_LT(i, size());
         return Base::buffer()[i];
     }
     const T& at(size_t i) const
     {
-        RELEASE_ASSERT(i < size());
+        CHECK_LT(i, size());
         return Base::buffer()[i];
     }
 
     T& operator[](size_t i) { return at(i); }
     const T& operator[](size_t i) const { return at(i); }
 
     T* data() { return Base::buffer(); }
     const T* data() const { return Base::buffer(); }
 
     iterator begin() { return data(); }
@@ skipping 286 matching lines @@
     size_t oldCapacity = capacity();
     size_t expandedCapacity = oldCapacity;
     // We use a more aggressive expansion strategy for Vectors with inline
     // storage.  This is because they are more likely to be on the stack, so the
     // risk of heap bloat is minimized.  Furthermore, exceeding the inline
     // capacity limit is not supposed to happen in the common case and may
     // indicate a pathological condition or microbenchmark.
     if (INLINE_CAPACITY) {
         expandedCapacity *= 2;
         // Check for integer overflow, which could happen in the 32-bit build.
-        RELEASE_ASSERT(expandedCapacity > oldCapacity);
+        CHECK_GT(expandedCapacity, oldCapacity);
     } else {
         // This cannot integer overflow.
         // On 64-bit, the "expanded" integer is 32-bit, and any encroachment
         // above 2^32 will fail allocation in allocateBuffer().  On 32-bit,
         // there's not enough address space to hold the old and new buffers.  In
         // addition, our underlying allocator is supposed to always fail on >
         // (2^31 - 1) allocations.
         expandedCapacity += (expandedCapacity / 4) + 1;
     }
     reserveCapacity(std::max(newMinCapacity, std::max(static_cast<size_t>(kInitialVectorSize), expandedCapacity)));
@@ skipping 145 matching lines @@
 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());
     size_t newSize = m_size + dataSize;
     if (newSize > capacity()) {
         data = expandCapacity(newSize, data);
         ASSERT(begin());
     }
-    RELEASE_ASSERT(newSize >= m_size);
+    CHECK_GE(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>::append(U&& val)
 {
@@ skipping 46 matching lines @@
 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());
-    RELEASE_ASSERT(position <= size());
+    CHECK_LE(position, size());
     size_t newSize = m_size + dataSize;
     if (newSize > capacity()) {
         data = expandCapacity(newSize, data);
         ASSERT(begin());
     }
-    RELEASE_ASSERT(newSize >= m_size);
+    CHECK_GE(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());
-    RELEASE_ASSERT(position <= size());
+    CHECK_LE(position, size());
     typename std::remove_reference<U>::type* data = &val;
     if (size() == capacity()) {
         data = expandCapacity(size() + 1, data);
         ASSERT(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;
@@ skipping 23 matching lines @@
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U, size_t c, typename V>
 inline void Vector<T, inlineCapacity, Allocator>::prependVector(const Vector<U, c, V>& val)
 {
     insert(0, val.begin(), val.size());
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void Vector<T, inlineCapacity, Allocator>::remove(size_t position)
 {
-    RELEASE_ASSERT(position < size());
+    CHECK_LT(position, size());
     T* spot = begin() + position;
     spot->~T();
     TypeOperations::moveOverlapping(spot + 1, end(), spot);
     clearUnusedSlots(end() - 1, end());
     ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, m_size - 1);
     --m_size;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void Vector<T, inlineCapacity, Allocator>::remove(size_t position, size_t length)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(position <= size());
     if (!length)
         return;
-    RELEASE_ASSERT(position + length <= size());
+    CHECK_LE(position + length, size());
     T* beginSpot = begin() + position;
     T* endSpot = beginSpot + length;
     TypeOperations::destruct(beginSpot, endSpot);
     TypeOperations::moveOverlapping(endSpot, end(), beginSpot);
     clearUnusedSlots(end() - length, end());
     ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, m_size - length);
     m_size -= length;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
@@ skipping 50 matching lines @@
             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