Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /**
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * 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 125 matching lines @@
   return firstNode;
 }
 
 // Returns the next list item with respect to the DOM order.
 static LayoutListItem* nextListItem(const Node* listNode,
                                     const LayoutListItem* item = nullptr) {
   if (!listNode)
     return nullptr;
 
   const Node* current = item ? item->node() : listNode;
-  ASSERT(current);
-  ASSERT(!current->document().childNeedsDistributionRecalc());
+  DCHECK(current);
+  DCHECK(!current->document().childNeedsDistributionRecalc());
   current = LayoutTreeBuilderTraversal::next(*current, listNode);
 
   while (current) {
     if (isList(*current)) {
       // We've found a nested, independent list: nothing to do here.
       current =
           LayoutTreeBuilderTraversal::nextSkippingChildren(*current, listNode);
       continue;
     }
 
     LayoutObject* layoutObject = current->layoutObject();
     if (layoutObject && layoutObject->isListItem())
       return toLayoutListItem(layoutObject);
 
     // FIXME: Can this be optimized to skip the children of the elements without
     // a layoutObject?
     current = LayoutTreeBuilderTraversal::next(*current, listNode);
   }
 
   return nullptr;
 }
 
 // Returns the previous list item with respect to the DOM order.
 static LayoutListItem* previousListItem(const Node* listNode,
                                         const LayoutListItem* item) {
   Node* current = item->node();
-  ASSERT(current);
-  ASSERT(!current->document().childNeedsDistributionRecalc());
+  DCHECK(current);
+  DCHECK(!current->document().childNeedsDistributionRecalc());
   for (current = LayoutTreeBuilderTraversal::previous(*current, listNode);
        current && current != listNode;
        current = LayoutTreeBuilderTraversal::previous(*current, listNode)) {
     LayoutObject* layoutObject = current->layoutObject();
     if (!layoutObject || (layoutObject && !layoutObject->isListItem()))
       continue;
     Node* otherList = enclosingList(toLayoutListItem(layoutObject));
     // This item is part of our current list, so it's what we're looking for.
     if (listNode == otherList)
       return toLayoutListItem(layoutObject);
     // We found ourself inside another list; lets skip the rest of it.
     // Use nextIncludingPseudo() here because the other list itself may actually
     // be a list item itself. We need to examine it, so we do this to counteract
     // the previousIncludingPseudo() that will be done by the loop.
     if (otherList)
       current = LayoutTreeBuilderTraversal::next(*otherList, listNode);
   }
   return nullptr;
 }
 
 void LayoutListItem::updateItemValuesForOrderedList(
     const HTMLOListElement* listNode) {
-  ASSERT(listNode);
+  DCHECK(listNode);
 
   for (LayoutListItem* listItem = nextListItem(listNode); listItem;
        listItem = nextListItem(listNode, listItem))
     listItem->updateValue();
 }
 
 unsigned LayoutListItem::itemCountForOrderedList(
     const HTMLOListElement* listNode) {
-  ASSERT(listNode);
+  DCHECK(listNode);
 
   unsigned itemCount = 0;
   for (LayoutListItem* listItem = nextListItem(listNode); listItem;
        listItem = nextListItem(listNode, listItem))
     itemCount++;
 
   return itemCount;
 }
 
 inline int LayoutListItem::calcValue() const {
@@ skipping 80 matching lines @@
 }
 
 static LayoutObject* firstNonMarkerChild(LayoutObject* parent) {
   LayoutObject* result = parent->slowFirstChild();
   while (result && result->isListMarker())
     result = result->nextSibling();
   return result;
 }
 
 bool LayoutListItem::updateMarkerLocation() {
-  ASSERT(m_marker);
+  DCHECK(m_marker);
 
   LayoutObject* markerParent = m_marker->parent();
   // list-style-position:inside makes the ::marker pseudo an ordinary
   // position:static element that should be attached to LayoutListItem block.
   LayoutObject* lineBoxParent =
       m_marker->isInside() ? this : getParentOfFirstLineBox(this, m_marker);
   if (!lineBoxParent) {
     // If the marker is currently contained inside an anonymous box, then we
     // are the only item in that anonymous box (since no line box parent was
     // found). It's ok to just leave the marker where it is in this case.
@@ skipping 156 matching lines @@
 void LayoutListItem::explicitValueChanged() {
   if (m_marker)
     m_marker->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
         LayoutInvalidationReason::ListValueChange);
   Node* listNode = enclosingList(this);
   for (LayoutListItem* item = this; item; item = nextListItem(listNode, item))
     item->updateValue();
 }
 
 void LayoutListItem::setExplicitValue(int value) {
-  ASSERT(node());
+  DCHECK(node());
 
   if (m_hasExplicitValue && m_explicitValue == value)
     return;
   m_explicitValue = value;
   m_value = value;
   m_hasExplicitValue = true;
   explicitValueChanged();
 }
 
 void LayoutListItem::clearExplicitValue() {
-  ASSERT(node());
+  DCHECK(node());
 
   if (!m_hasExplicitValue)
     return;
   m_hasExplicitValue = false;
   m_isValueUpToDate = false;
   explicitValueChanged();
 }
 
 void LayoutListItem::setNotInList(bool notInList) {
   m_notInList = notInList;
 }
 
 static LayoutListItem* previousOrNextItem(bool isListReversed,
                                           Node* list,
                                           LayoutListItem* item) {
   return isListReversed ? previousListItem(list, item)
                         : nextListItem(list, item);
 }
 
 void LayoutListItem::updateListMarkerNumbers() {
   // If distribution recalc is needed, updateListMarkerNumber will be re-invoked
   // after distribution is calculated.
   if (node()->document().childNeedsDistributionRecalc())
     return;
 
   Node* listNode = enclosingList(this);
-  ASSERT(listNode);
+  DCHECK(listNode);
 
   bool isListReversed = false;
   HTMLOListElement* oListElement =
       isHTMLOListElement(listNode) ? toHTMLOListElement(listNode) : 0;
   if (oListElement) {
     oListElement->itemCountChanged();
     isListReversed = oListElement->isReversed();
   }
 
   // FIXME: The n^2 protection below doesn't help if the elements were inserted
@@ skipping 12 matching lines @@
       // assume that all the following ones have too.
       // This gives us the opportunity to stop here and avoid
       // marking the same nodes again.
       break;
     }
     item->updateValue();
   }
 }
 
 }  // namespace blink