Replace ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/wtf

third_party/WebKit/Source/platform/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 982 matching lines @@
   bool IsEmpty() const { return !size(); }
 
   // at() and operator[]: Obtain the reference of the element that is located
   // at the given index. The reference may be invalidated on a reallocation.
   //
   // at() can be used in cases like:
   //     pointerToVector->at(1);
   // instead of:
   //     (*pointerToVector)[1];
   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); }
 
   // Return a pointer to the front of the backing buffer. Those pointers get
   // invalidated on a reallocation.
   T* data() { return Base::Buffer(); }
   const T* data() const { return Base::Buffer(); }
@@ skipping 482 matching lines @@
   size_t old_capacity = capacity();
   size_t expanded_capacity = old_capacity;
   // 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) {
     expanded_capacity *= 2;
     // Check for integer overflow, which could happen in the 32-bit build.
-    RELEASE_ASSERT(expanded_capacity > old_capacity);
+    CHECK_GT(expanded_capacity, old_capacity);
   } 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.
     expanded_capacity += (expanded_capacity / 4) + 1;
   }
   ReserveCapacity(std::max(
@@ skipping 178 matching lines @@
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 void Vector<T, inlineCapacity, Allocator>::Append(const U* data,
                                                   size_t data_size) {
   DCHECK(Allocator::IsAllocationAllowed());
   size_t new_size = size_ + data_size;
   if (new_size > capacity()) {
     data = ExpandCapacity(new_size, data);
     DCHECK(begin());
   }
-  RELEASE_ASSERT(new_size >= size_);
+  CHECK_GE(new_size, size_);
   T* dest = end();
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), size_, new_size);
   VectorCopier<VectorTraits<T>::kCanCopyWithMemcpy, T>::UninitializedCopy(
       data, &data[data_size], dest);
   size_ = new_size;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 NEVER_INLINE void Vector<T, inlineCapacity, Allocator>::AppendSlowCase(
@@ skipping 39 matching lines @@
   new (NotNull, end()) T(std::forward<U>(val));
   ++size_;
 #endif
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 inline void Vector<T, inlineCapacity, Allocator>::insert(size_t position,
                                                          U&& val) {
   DCHECK(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);
     DCHECK(begin());
   }
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), size_, size_ + 1);
   T* spot = begin() + position;
   TypeOperations::MoveOverlapping(spot, end(), spot + 1);
   new (NotNull, spot) T(std::forward<U>(*data));
   ++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 data_size) {
   DCHECK(Allocator::IsAllocationAllowed());
-  RELEASE_ASSERT(position <= size());
+  CHECK_LE(position, size());
   size_t new_size = size_ + data_size;
   if (new_size > capacity()) {
     data = ExpandCapacity(new_size, data);
     DCHECK(begin());
   }
-  RELEASE_ASSERT(new_size >= size_);
+  CHECK_GE(new_size, size_);
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), size_, new_size);
   T* spot = begin() + position;
   TypeOperations::MoveOverlapping(spot, end(), spot + data_size);
   VectorCopier<VectorTraits<T>::kCanCopyWithMemcpy, T>::UninitializedCopy(
       data, &data[data_size], spot);
   size_ = new_size;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U, size_t otherCapacity, typename OtherAllocator>
@@ skipping 18 matching lines @@
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U, size_t otherCapacity, typename OtherAllocator>
 inline void Vector<T, inlineCapacity, Allocator>::PrependVector(
     const Vector<U, otherCapacity, OtherAllocator>& val) {
   insert(0, val.begin(), val.size());
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void Vector<T, inlineCapacity, Allocator>::erase(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(), size_, size_ - 1);
   --size_;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void Vector<T, inlineCapacity, Allocator>::erase(size_t position,
                                                         size_t length) {
   SECURITY_DCHECK(position <= size());
   if (!length)
     return;
-  RELEASE_ASSERT(position + length <= size());
+  CHECK_LE(position + length, size());
   T* begin_spot = begin() + position;
   T* end_spot = begin_spot + length;
   TypeOperations::Destruct(begin_spot, end_spot);
   TypeOperations::MoveOverlapping(end_spot, end(), begin_spot);
   ClearUnusedSlots(end() - length, end());
   ANNOTATE_CHANGE_SIZE(begin(), capacity(), size_, size_ - length);
   size_ -= length;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
@@ skipping 58 matching lines @@
           visitor, *const_cast<T*>(buffer_entry));
     CheckUnusedSlots(Buffer() + size(), Buffer() + capacity());
   }
 }
 
 }  // namespace WTF
 
 using WTF::Vector;
 
 #endif  // WTF_Vector_h