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

third_party/WebKit/Source/wtf/ListHashSet.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2011, Benjamin Poulain <ikipou@gmail.com>
  *
  * 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.
  *
@@ skipping 248 matching lines @@
 
 // ListHashSetNode has this base class to hold the members because the MSVC
 // compiler otherwise gets into circular template dependencies when trying to do
 // sizeof on a node.
 template <typename ValueArg>
 class ListHashSetNodeBase {
   DISALLOW_NEW();
 
  protected:
   template <typename U>
-  explicit ListHashSetNodeBase(U&& value)
-      : m_value(std::forward<U>(value)),
-        m_prev(nullptr),
-        m_next(nullptr)
-#if ENABLE(ASSERT)
-        ,
-        m_isAllocated(true)
-#endif
-  {
-  }
+  explicit ListHashSetNodeBase(U&& value) : m_value(std::forward<U>(value)) {}
 
  public:
   ValueArg m_value;
-  ListHashSetNodeBase* m_prev;
-  ListHashSetNodeBase* m_next;
-#if ENABLE(ASSERT)
-  bool m_isAllocated;
+  ListHashSetNodeBase* m_prev = nullptr;
+  ListHashSetNodeBase* m_next = nullptr;
+#if DCHECK_IS_ON()
+  bool m_isAllocated = true;
 #endif
 };
 
 // This allocator is only used for non-Heap ListHashSets.
 template <typename ValueArg, size_t inlineCapacity>
 struct ListHashSetAllocator : public PartitionAllocator {
   typedef PartitionAllocator TableAllocator;
   typedef ListHashSetNode<ValueArg, ListHashSetAllocator> Node;
   typedef ListHashSetNodeBase<ValueArg> NodeBase;
 
@@ skipping 10 matching lines @@
     void releaseAllocator() {
       delete m_allocator;
       m_allocator = nullptr;
     }
 
     void swap(AllocatorProvider& other) {
       std::swap(m_allocator, other.m_allocator);
     }
 
     void deallocate(Node* node) const {
-      ASSERT(m_allocator);
+      DCHECK(m_allocator);
       m_allocator->deallocate(node);
     }
 
     ListHashSetAllocator* get() const {
-      ASSERT(m_allocator);
+      DCHECK(m_allocator);
       return m_allocator;
     }
 
    private:
     // Not using std::unique_ptr as this pointer should be deleted at
     // releaseAllocator() method rather than at destructor.
     ListHashSetAllocator* m_allocator;
   };
 
   ListHashSetAllocator()
       : m_freeList(pool()), m_isDoneWithInitialFreeList(false) {
     memset(m_pool.buffer, 0, sizeof(m_pool.buffer));
   }
 
   Node* allocateNode() {
     Node* result = m_freeList;
 
     if (!result)
       return static_cast<Node*>(WTF::Partitions::fastMalloc(
           sizeof(NodeBase), WTF_HEAP_PROFILER_TYPE_NAME(Node)));
 
-    ASSERT(!result->m_isAllocated);
+#if DCHECK_IS_ON()
+    DCHECK(!result->m_isAllocated);
+#endif
 
     Node* next = result->next();
-    ASSERT(!next || !next->m_isAllocated);
+#if DCHECK_IS_ON()
+    DCHECK(!next || !next->m_isAllocated);
+#endif
     if (!next && !m_isDoneWithInitialFreeList) {
       next = result + 1;
       if (next == pastPool()) {
         m_isDoneWithInitialFreeList = true;
         next = nullptr;
       } else {
-        ASSERT(inPool(next));
-        ASSERT(!next->m_isAllocated);
+        DCHECK(inPool(next));
+#if DCHECK_IS_ON()
+        DCHECK(!next->m_isAllocated);
+#endif
       }
     }
     m_freeList = next;
 
     return result;
   }
 
   void deallocate(Node* node) {
     if (inPool(node)) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
       node->m_isAllocated = false;
 #endif
       node->m_next = m_freeList;
       m_freeList = node;
       return;
     }
 
     WTF::Partitions::fastFree(node);
   }
 
@@ skipping 36 matching lines @@
     return allocator->allocateNode();
   }
 
   void setWasAlreadyDestructed() {
     if (NodeAllocator::isGarbageCollected &&
         !IsTriviallyDestructible<ValueArg>::value)
       this->m_prev = unlinkedNodePointer();
   }
 
   bool wasAlreadyDestructed() const {
-    ASSERT(NodeAllocator::isGarbageCollected);
+    DCHECK(NodeAllocator::isGarbageCollected);
     return this->m_prev == unlinkedNodePointer();
   }
 
   static void finalize(void* pointer) {
     // No need to waste time calling finalize if it's not needed.
-    ASSERT(!IsTriviallyDestructible<ValueArg>::value);
+    DCHECK(!IsTriviallyDestructible<ValueArg>::value);
     ListHashSetNode* self = reinterpret_cast_ptr<ListHashSetNode*>(pointer);
 
     // Check whether this node was already destructed before being unlinked
     // from the collection.
     if (self->wasAlreadyDestructed())
       return;
 
     self->m_value.~ValueArg();
   }
   void finalizeGarbageCollectedObject() { finalize(this); }
@@ skipping 126 matching lines @@
       : m_set(set), m_position(position) {}
 
  public:
   ListHashSetConstIterator() {}
 
   PointerType get() const { return &m_position->m_value; }
   ReferenceType operator*() const { return *get(); }
   PointerType operator->() const { return get(); }
 
   ListHashSetConstIterator& operator++() {
-    ASSERT(m_position != 0);
+    DCHECK(m_position);
     m_position = m_position->next();
     return *this;
   }
 
   ListHashSetConstIterator& operator--() {
-    ASSERT(m_position != m_set->m_head);
+    DCHECK_NE(m_position, m_set->m_head);
     if (!m_position)
       m_position = m_set->m_tail;
     else
       m_position = m_position->prev();
     return *this;
   }
 
   // Postfix ++ and -- intentionally omitted.
 
   // Comparison.
@@ skipping 84 matching lines @@
       : m_set(set), m_position(position) {}
 
  public:
   ListHashSetConstReverseIterator() {}
 
   PointerType get() const { return &m_position->m_value; }
   ReferenceType operator*() const { return *get(); }
   PointerType operator->() const { return get(); }
 
   ListHashSetConstReverseIterator& operator++() {
-    ASSERT(m_position != 0);
+    DCHECK(m_position);
     m_position = m_position->prev();
     return *this;
   }
 
   ListHashSetConstReverseIterator& operator--() {
-    ASSERT(m_position != m_set->m_tail);
+    DCHECK_NE(m_position, m_set->m_tail);
     if (!m_position)
       m_position = m_set->m_head;
     else
       m_position = m_position->next();
     return *this;
   }
 
   // Postfix ++ and -- intentionally omitted.
 
   // Comparison.
@@ skipping 82 matching lines @@
 template <typename T, size_t inlineCapacity, typename U, typename V>
 inline void ListHashSet<T, inlineCapacity, U, V>::finalize() {
   static_assert(!Allocator::isGarbageCollected,
                 "heap allocated ListHashSet should never call finalize()");
   deleteAllNodes();
   m_allocatorProvider.releaseAllocator();
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 inline T& ListHashSet<T, inlineCapacity, U, V>::first() {
-  ASSERT(!isEmpty());
+  DCHECK(!isEmpty());
   return m_head->m_value;
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 inline void ListHashSet<T, inlineCapacity, U, V>::removeFirst() {
-  ASSERT(!isEmpty());
+  DCHECK(!isEmpty());
   m_impl.remove(m_head);
   unlinkAndDelete(m_head);
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 inline const T& ListHashSet<T, inlineCapacity, U, V>::first() const {
-  ASSERT(!isEmpty());
+  DCHECK(!isEmpty());
   return m_head->m_value;
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 inline T& ListHashSet<T, inlineCapacity, U, V>::last() {
-  ASSERT(!isEmpty());
+  DCHECK(!isEmpty());
   return m_tail->m_value;
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 inline const T& ListHashSet<T, inlineCapacity, U, V>::last() const {
-  ASSERT(!isEmpty());
+  DCHECK(!isEmpty());
   return m_tail->m_value;
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 inline void ListHashSet<T, inlineCapacity, U, V>::removeLast() {
-  ASSERT(!isEmpty());
+  DCHECK(!isEmpty());
   m_impl.remove(m_tail);
   unlinkAndDelete(m_tail);
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 inline typename ListHashSet<T, inlineCapacity, U, V>::iterator
 ListHashSet<T, inlineCapacity, U, V>::find(ValuePeekInType value) {
   ImplTypeIterator it = m_impl.template find<BaseTranslator>(value);
   if (it == m_impl.end())
     return end();
@@ skipping 166 matching lines @@
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 auto ListHashSet<T, inlineCapacity, U, V>::take(ValuePeekInType value)
     -> ValueType {
   return take(find(value));
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 auto ListHashSet<T, inlineCapacity, U, V>::takeFirst() -> ValueType {
-  ASSERT(!isEmpty());
+  DCHECK(!isEmpty());
   m_impl.remove(m_head);
   ValueType result = std::move(m_head->m_value);
   unlinkAndDelete(m_head);
 
   return result;
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename Allocator>
 void ListHashSet<T, inlineCapacity, U, Allocator>::unlink(Node* node) {
   if (!node->m_prev) {
-    ASSERT(node == m_head);
+    DCHECK_EQ(node, m_head);
     m_head = node->next();
   } else {
-    ASSERT(node != m_head);
+    DCHECK_NE(node, m_head);
     node->m_prev->m_next = node->m_next;
   }
 
   if (!node->m_next) {
-    ASSERT(node == m_tail);
+    DCHECK_EQ(node, m_tail);
     m_tail = node->prev();
   } else {
-    ASSERT(node != m_tail);
+    DCHECK_NE(node, m_tail);
     node->m_next->m_prev = node->m_prev;
   }
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 void ListHashSet<T, inlineCapacity, U, V>::unlinkAndDelete(Node* node) {
   unlink(node);
   node->destroy(this->getAllocator());
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 void ListHashSet<T, inlineCapacity, U, V>::appendNode(Node* node) {
   node->m_prev = m_tail;
   node->m_next = nullptr;
 
   if (m_tail) {
-    ASSERT(m_head);
+    DCHECK(m_head);
     m_tail->m_next = node;
   } else {
-    ASSERT(!m_head);
+    DCHECK(!m_head);
     m_head = node;
   }
 
   m_tail = node;
 }
 
 template <typename T, size_t inlineCapacity, typename U, typename V>
 void ListHashSet<T, inlineCapacity, U, V>::prependNode(Node* node) {
   node->m_prev = nullptr;
   node->m_next = m_head;
@@ skipping 42 matching lines @@
   // through the HashTable. That includes m_head and m_tail so we do not have
   // to explicitly trace them here.
   m_impl.trace(visitor);
 }
 
 }  // namespace WTF
 
 using WTF::ListHashSet;
 
 #endif  // WTF_ListHashSet_h