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

third_party/WebKit/Source/wtf/TreeNode.h

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 25 matching lines @@
 namespace WTF {
 
 //
 // TreeNode is generic, ContainerNode-like linked tree data structure.
 // There are a few notable difference between TreeNode and Node:
 //
 //  * Each TreeNode node is NOT ref counted. The user have to retain its
 //    lifetime somehow.
 //    FIXME: lifetime management could be parameterized so that ref counted
 //    implementations can be used.
-//  * It ASSERT()s invalid input. The callers have to ensure that given
+//  * It checks invalid input. The callers have to ensure that given
 //    parameter is sound.
 //  * There is no branch-leaf difference. Every node can be a parent of other
 //    node.
 //
 // FIXME: oilpan: Trace tree node edges to ensure we don't have dangling
 // pointers.
 // As it is used in HTMLImport it is safe since they all die together.
 template <class T>
 class TreeNode {
  public:
@@ skipping 14 matching lines @@
   NodeType* here() const {
     return static_cast<NodeType*>(const_cast<TreeNode*>(this));
   }
 
   bool orphan() const {
     return !m_parent && !m_next && !m_previous && !m_firstChild && !m_lastChild;
   }
   bool hasChildren() const { return m_firstChild; }
 
   void insertBefore(NodeType* newChild, NodeType* refChild) {
-    ASSERT(!newChild->parent());
-    ASSERT(!newChild->next());
-    ASSERT(!newChild->previous());
+    DCHECK(!newChild->parent());
+    DCHECK(!newChild->next());
+    DCHECK(!newChild->previous());
 
-    ASSERT(!refChild || this == refChild->parent());
+    DCHECK(!refChild || this == refChild->parent());
 
     if (!refChild) {
       appendChild(newChild);
       return;
     }
 
     NodeType* newPrevious = refChild->previous();
     newChild->m_parent = here();
     newChild->m_next = refChild;
     newChild->m_previous = newPrevious;
     refChild->m_previous = newChild;
     if (newPrevious)
       newPrevious->m_next = newChild;
     else
       m_firstChild = newChild;
   }
 
   void appendChild(NodeType* child) {
-    ASSERT(!child->parent());
-    ASSERT(!child->next());
-    ASSERT(!child->previous());
+    DCHECK(!child->parent());
+    DCHECK(!child->next());
+    DCHECK(!child->previous());
 
     child->m_parent = here();
 
     if (!m_lastChild) {
-      ASSERT(!m_firstChild);
+      DCHECK(!m_firstChild);
       m_lastChild = m_firstChild = child;
       return;
     }
 
-    ASSERT(!m_lastChild->m_next);
+    DCHECK(!m_lastChild->m_next);
     NodeType* oldLast = m_lastChild;
     m_lastChild = child;
 
     child->m_previous = oldLast;
     oldLast->m_next = child;
   }
 
   NodeType* removeChild(NodeType* child) {
-    ASSERT(child->parent() == this);
+    DCHECK_EQ(child->parent(), this);
 
     if (m_firstChild == child)
       m_firstChild = child->next();
     if (m_lastChild == child)
       m_lastChild = child->previous();
 
     NodeType* oldNext = child->next();
     NodeType* oldPrevious = child->previous();
     child->m_parent = child->m_next = child->m_previous = 0;
 
     if (oldNext)
       oldNext->m_previous = oldPrevious;
     if (oldPrevious)
       oldPrevious->m_next = oldNext;
 
     return child;
   }
 
   void takeChildrenFrom(NodeType* oldParent) {
-    ASSERT(oldParent != this);
+    DCHECK_NE(oldParent, this);
     while (oldParent->hasChildren()) {
       NodeType* child = oldParent->firstChild();
       oldParent->removeChild(child);
       this->appendChild(child);
     }
   }
 
  private:
   NodeType* m_next;
   NodeType* m_previous;
@@ skipping 47 matching lines @@
   return next;
 }
 
 }  // namespace WTF
 
 using WTF::TreeNode;
 using WTF::traverseNext;
 using WTF::traverseNextPostOrder;
 
 #endif