Replace ASSERT with DCHECK in core/layout/ excluding subdirs

third_party/WebKit/Source/core/layout/CounterNode.cpp

 /*
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 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,
@@ skipping 127 matching lines @@
   while (CounterNode* lastChild = previous->m_lastChild)
     previous = lastChild;
 
   return previous;
 }
 
 int CounterNode::computeCountInParent() const {
   int increment = actsAsReset() ? 0 : m_value;
   if (m_previousSibling)
     return m_previousSibling->m_countInParent + increment;
-  ASSERT(m_parent->m_firstChild == this);
+  DCHECK_EQ(m_parent->m_firstChild, this);
   return m_parent->m_value + increment;
 }
 
 void CounterNode::addLayoutObject(LayoutCounter* value) {
   if (!value) {
     NOTREACHED();
     return;
   }
   if (value->m_counterNode) {
     NOTREACHED();
     value->m_counterNode->removeLayoutObject(value);
   }
-  ASSERT(!value->m_nextForSameCounter);
+  DCHECK(!value->m_nextForSameCounter);
   for (LayoutCounter* iterator = m_rootLayoutObject; iterator;
        iterator = iterator->m_nextForSameCounter) {
     if (iterator == value) {
       NOTREACHED();
       return;
     }
   }
   value->m_nextForSameCounter = m_rootLayoutObject;
   m_rootLayoutObject = value;
   if (value->m_counterNode != this) {
@@ skipping 54 matching lines @@
     if (oldCount == newCount)
       break;
     node->m_countInParent = newCount;
     node->resetThisAndDescendantsLayoutObjects();
   }
 }
 
 void CounterNode::insertAfter(CounterNode* newChild,
                               CounterNode* refChild,
                               const AtomicString& identifier) {
-  ASSERT(newChild);
-  ASSERT(!newChild->m_parent);
-  ASSERT(!newChild->m_previousSibling);
-  ASSERT(!newChild->m_nextSibling);
+  DCHECK(newChild);
+  DCHECK(!newChild->m_parent);
+  DCHECK(!newChild->m_previousSibling);
+  DCHECK(!newChild->m_nextSibling);
   // If the refChild is not our child we can not complete the request. This
   // hardens against bugs in LayoutCounter.
   // When layoutObjects are reparented it may request that we insert counter
   // nodes improperly.
   if (refChild && refChild->m_parent != this)
     return;
 
   if (newChild->m_hasResetType) {
     while (m_lastChild != refChild)
       LayoutCounter::destroyCounterNode(m_lastChild->owner(), identifier);
   }
 
   CounterNode* next;
 
   if (refChild) {
     next = refChild->m_nextSibling;
     refChild->m_nextSibling = newChild;
   } else {
     next = m_firstChild;
     m_firstChild = newChild;
   }
 
   newChild->m_parent = this;
   newChild->m_previousSibling = refChild;
 
   if (next) {
-    ASSERT(next->m_previousSibling == refChild);
+    DCHECK_EQ(next->m_previousSibling, refChild);
     next->m_previousSibling = newChild;
     newChild->m_nextSibling = next;
   } else {
-    ASSERT(m_lastChild == refChild);
+    DCHECK_EQ(m_lastChild, refChild);
     m_lastChild = newChild;
   }
 
   if (!newChild->m_firstChild || newChild->m_hasResetType) {
     newChild->m_countInParent = newChild->computeCountInParent();
     newChild->resetThisAndDescendantsLayoutObjects();
     if (next)
       next->recount();
     return;
   }
 
   // The code below handles the case when a formerly root increment counter is
   // loosing its root position and therefore its children become next siblings.
   CounterNode* last = newChild->m_lastChild;
   CounterNode* first = newChild->m_firstChild;
 
   if (first) {
-    ASSERT(last);
+    DCHECK(last);
     newChild->m_nextSibling = first;
     if (m_lastChild == newChild)
       m_lastChild = last;
 
     first->m_previousSibling = newChild;
 
     // The case when the original next sibling of the inserted node becomes a
     // child of one of the former children of the inserted node is not handled
     // as it is believed to be impossible since:
     // 1. if the increment counter node lost it's root position as a result of
     //    another counter node being created, it will be inserted as the last
     //    child so next is null.
     // 2. if the increment counter node lost it's root position as a result of a
     //    layoutObject being inserted into the document's layout tree, all its
     //    former children counters are attached to children of the inserted
     //    layoutObject and hence cannot be in scope for counter nodes attached
     // to layoutObjects that were already in the document's layout tree.
     last->m_nextSibling = next;
     if (next) {
-      ASSERT(next->m_previousSibling == newChild);
+      DCHECK_EQ(next->m_previousSibling, newChild);
       next->m_previousSibling = last;
     } else {
       m_lastChild = last;
     }
     for (next = first;; next = next->m_nextSibling) {
       next->m_parent = this;
       if (last == next)
         break;
     }
   }
   newChild->m_firstChild = nullptr;
   newChild->m_lastChild = nullptr;
   newChild->m_countInParent = newChild->computeCountInParent();
   newChild->resetLayoutObjects();
   first->recount();
 }
 
 void CounterNode::removeChild(CounterNode* oldChild) {
-  ASSERT(oldChild);
-  ASSERT(!oldChild->m_firstChild);
-  ASSERT(!oldChild->m_lastChild);
+  DCHECK(oldChild);
+  DCHECK(!oldChild->m_firstChild);
+  DCHECK(!oldChild->m_lastChild);
 
   CounterNode* next = oldChild->m_nextSibling;
   CounterNode* previous = oldChild->m_previousSibling;
 
   oldChild->m_nextSibling = nullptr;
   oldChild->m_previousSibling = nullptr;
   oldChild->m_parent = nullptr;
 
   if (previous) {
     previous->m_nextSibling = next;
   } else {
-    ASSERT(m_firstChild == oldChild);
+    DCHECK_EQ(m_firstChild, oldChild);
     m_firstChild = next;
   }
 
   if (next) {
     next->m_previousSibling = previous;
   } else {
-    ASSERT(m_lastChild == oldChild);
+    DCHECK_EQ(m_lastChild, oldChild);
     m_lastChild = previous;
   }
 
   if (next)
     next->recount();
 }
 
 #ifndef NDEBUG
 
 static void showTreeAndMark(const CounterNode* node) {
@@ skipping 23 matching lines @@
 #ifndef NDEBUG
 
 void showCounterTree(const blink::CounterNode* counter) {
   if (counter)
     showTreeAndMark(counter);
   else
     fprintf(stderr, "Cannot showCounterTree for (nil).\n");
 }
 
 #endif