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

third_party/WebKit/Source/wtf/Deque.h

 /*
  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 72 matching lines @@
   reverse_iterator rbegin() { return reverse_iterator(end()); }
   reverse_iterator rend() { return reverse_iterator(begin()); }
   const_reverse_iterator rbegin() const {
     return const_reverse_iterator(end());
   }
   const_reverse_iterator rend() const {
     return const_reverse_iterator(begin());
   }
 
   T& first() {
-    ASSERT(m_start != m_end);
+    DCHECK_NE(m_start, m_end);
     return m_buffer.buffer()[m_start];
   }
   const T& first() const {
-    ASSERT(m_start != m_end);
+    DCHECK_NE(m_start, m_end);
     return m_buffer.buffer()[m_start];
   }
   T takeFirst();
 
   T& last() {
-    ASSERT(m_start != m_end);
+    DCHECK_NE(m_start, m_end);
     return *(--end());
   }
   const T& last() const {
-    ASSERT(m_start != m_end);
+    DCHECK_NE(m_start, m_end);
     return *(--end());
   }
   T takeLast();
 
   T& at(size_t i) {
     RELEASE_ASSERT(i < size());
     size_t right = m_buffer.capacity() - m_start;
     return i < right ? m_buffer.buffer()[m_start + i]
                      : m_buffer.buffer()[i - right];
   }
@@ skipping 380 matching lines @@
   expandCapacityIfNeeded();
   if (!m_start)
     m_start = m_buffer.capacity() - 1;
   else
     --m_start;
   new (NotNull, &m_buffer.buffer()[m_start]) T(std::forward<U>(value));
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void Deque<T, inlineCapacity, Allocator>::removeFirst() {
-  ASSERT(!isEmpty());
+  DCHECK(!isEmpty());
   TypeOperations::destruct(&m_buffer.buffer()[m_start],
                            &m_buffer.buffer()[m_start + 1]);
   m_buffer.clearUnusedSlots(&m_buffer.buffer()[m_start],
                             &m_buffer.buffer()[m_start + 1]);
   if (m_start == m_buffer.capacity() - 1)
     m_start = 0;
   else
     ++m_start;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void Deque<T, inlineCapacity, Allocator>::removeLast() {
-  ASSERT(!isEmpty());
+  DCHECK(!isEmpty());
   if (!m_end)
     m_end = m_buffer.capacity() - 1;
   else
     --m_end;
   TypeOperations::destruct(&m_buffer.buffer()[m_end],
                            &m_buffer.buffer()[m_end + 1]);
   m_buffer.clearUnusedSlots(&m_buffer.buffer()[m_end],
                             &m_buffer.buffer()[m_end + 1]);
 }
 
@@ skipping 59 matching lines @@
 inline DequeIteratorBase<T, inlineCapacity, Allocator>::~DequeIteratorBase() {}
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline bool DequeIteratorBase<T, inlineCapacity, Allocator>::isEqual(
     const DequeIteratorBase& other) const {
   return m_index == other.m_index;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void DequeIteratorBase<T, inlineCapacity, Allocator>::increment() {
-  ASSERT(m_index != m_deque->m_end);
-  ASSERT(m_deque->m_buffer.capacity());
+  DCHECK_NE(m_index, m_deque->m_end);
+  DCHECK(m_deque->m_buffer.capacity());
   if (m_index == m_deque->m_buffer.capacity() - 1)
     m_index = 0;
   else
     ++m_index;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline void DequeIteratorBase<T, inlineCapacity, Allocator>::decrement() {
-  ASSERT(m_index != m_deque->m_start);
-  ASSERT(m_deque->m_buffer.capacity());
+  DCHECK_NE(m_index, m_deque->m_start);
+  DCHECK(m_deque->m_buffer.capacity());
   if (!m_index)
     m_index = m_deque->m_buffer.capacity() - 1;
   else
     --m_index;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline T* DequeIteratorBase<T, inlineCapacity, Allocator>::after() const {
   RELEASE_ASSERT(m_index != m_deque->m_end);
   return &m_deque->m_buffer.buffer()[m_index];
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 inline T* DequeIteratorBase<T, inlineCapacity, Allocator>::before() const {
   RELEASE_ASSERT(m_index != m_deque->m_start);
   if (!m_index)
     return &m_deque->m_buffer.buffer()[m_deque->m_buffer.capacity() - 1];
   return &m_deque->m_buffer.buffer()[m_index - 1];
 }
 
 // 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 Deque<T, inlineCapacity, Allocator>::trace(VisitorDispatcher visitor) {
-  ASSERT(Allocator::isGarbageCollected);  // Garbage collector must be enabled.
+  DCHECK(Allocator::isGarbageCollected) << "Garbage collector must be enabled.";
   const T* bufferBegin = m_buffer.buffer();
   const T* end = bufferBegin + m_end;
   if (IsTraceableInCollectionTrait<VectorTraits<T>>::value) {
     if (m_start <= m_end) {
       for (const T* bufferEntry = bufferBegin + m_start; bufferEntry != end;
            bufferEntry++)
         Allocator::template trace<VisitorDispatcher, T, VectorTraits<T>>(
             visitor, *const_cast<T*>(bufferEntry));
     } else {
       for (const T* bufferEntry = bufferBegin; bufferEntry != end;
@@ skipping 17 matching lines @@
 inline void swap(Deque<T, inlineCapacity, Allocator>& a,
                  Deque<T, inlineCapacity, Allocator>& b) {
   a.swap(b);
 }
 
 }  // namespace WTF
 
 using WTF::Deque;
 
 #endif  // WTF_Deque_h