Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /**
  * Copyright (C) 2004 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 55 matching lines @@
   return nullptr;
 }
 
 // This function processes the layoutObject tree in the order of the DOM tree
 // including pseudo elements as defined in CSS 2.1. This method will always
 // return either a previous object within the same contain: style scope or
 // nullptr.
 static LayoutObject* previousInPreOrderRespectingContainment(
     const LayoutObject& object) {
   Element* self = toElement(object.node());
-  ASSERT(self);
+  DCHECK(self);
   Element* previous = ElementTraversal::previousIncludingPseudo(*self);
   Element* styleContainAncestor = ancestorStyleContainmentObject(*self);
 
   while (1) {
     while (previous && !previous->layoutObject())
       previous = ElementTraversal::previousIncludingPseudo(*previous);
     if (!previous)
       return nullptr;
     Element* previousStyleContainAncestor =
         ancestorStyleContainmentObject(*previous);
     if (previousStyleContainAncestor == styleContainAncestor)
       return previous->layoutObject();
     if (!previousStyleContainAncestor)
       return nullptr;
     previous = previousStyleContainAncestor;
   }
 }
 
 // This function processes the layoutObject tree in the order of the DOM tree
 // including pseudo elements as defined in CSS 2.1. This method avoids crossing
 // contain: style boundaries.
 static LayoutObject* previousSiblingOrParentRespectingContainment(
     const LayoutObject& object) {
   Element* self = toElement(object.node());
-  ASSERT(self);
+  DCHECK(self);
   Element* previous = ElementTraversal::pseudoAwarePreviousSibling(*self);
   while (previous && !previous->layoutObject())
     previous = ElementTraversal::pseudoAwarePreviousSibling(*previous);
   if (previous)
     return previous->layoutObject();
   previous = self->parentElement();
   return previous && previous->layoutObject() &&
                  !(previous->layoutObject()->style()->contain() & ContainsStyle)
              ? previous->layoutObject()
              : nullptr;
 }
 
 static inline Element* parentElement(LayoutObject& object) {
   return toElement(object.node())->parentElement();
 }
 
 static inline bool areLayoutObjectsElementsSiblings(LayoutObject& first,
                                                     LayoutObject& second) {
   return parentElement(first) == parentElement(second);
 }
 
 // This function processes the layoutObject tree in the order of the DOM tree
 // including pseudo elements as defined in CSS 2.1.
 static LayoutObject* nextInPreOrder(const LayoutObject& object,
                                     const Element* stayWithin,
                                     bool skipDescendants = false) {
   Element* self = toElement(object.node());
-  ASSERT(self);
+  DCHECK(self);
   Element* next =
       skipDescendants
           ? ElementTraversal::nextIncludingPseudoSkippingChildren(*self,
                                                                   stayWithin)
           : ElementTraversal::nextIncludingPseudo(*self, stayWithin);
   while (next && !next->layoutObject())
     next = skipDescendants
                ? ElementTraversal::nextIncludingPseudoSkippingChildren(
                      *next, stayWithin)
                : ElementTraversal::nextIncludingPseudo(*next, stayWithin);
@@ skipping 293 matching lines @@
       m_nextForSameCounter(nullptr) {
   setDocumentForAnonymous(&pseudo.document());
   view()->addLayoutCounter();
 }
 
 LayoutCounter::~LayoutCounter() {}
 
 void LayoutCounter::willBeDestroyed() {
   if (m_counterNode) {
     m_counterNode->removeLayoutObject(this);
-    ASSERT(!m_counterNode);
+    DCHECK(!m_counterNode);
   }
   if (view())
     view()->removeLayoutCounter();
   LayoutText::willBeDestroyed();
 }
 
 PassRefPtr<StringImpl> LayoutCounter::originalText() const {
   if (!m_counterNode) {
     LayoutObject* beforeAfterContainer = parent();
     while (true) {
       if (!beforeAfterContainer)
         return nullptr;
       if (!beforeAfterContainer->isAnonymous() &&
           !beforeAfterContainer->isPseudoElement())
         return nullptr;  // LayoutCounters are restricted to before and after
                          // pseudo elements
       PseudoId containerStyle = beforeAfterContainer->style()->styleType();
       if ((containerStyle == PseudoIdBefore) ||
           (containerStyle == PseudoIdAfter))
         break;
       beforeAfterContainer = beforeAfterContainer->parent();
     }
     makeCounterNodeIfNeeded(*beforeAfterContainer, m_counter.identifier(), true)
         ->addLayoutObject(const_cast<LayoutCounter*>(this));
-    ASSERT(m_counterNode);
+    DCHECK(m_counterNode);
   }
   CounterNode* child = m_counterNode;
   int value = child->actsAsReset() ? child->value() : child->countInParent();
 
   String text = ListMarkerText::text(m_counter.listStyle(), value);
 
   if (!m_counter.separator().isNull()) {
     if (!child->actsAsReset())
       child = child->parent();
     while (CounterNode* parent = child->parent()) {
       text =
           ListMarkerText::text(m_counter.listStyle(), child->countInParent()) +
           m_counter.separator() + text;
       child = parent;
     }
   }
 
   return text.impl();
 }
 
 void LayoutCounter::updateCounter() {
   setText(originalText());
 }
 
 void LayoutCounter::invalidate() {
   m_counterNode->removeLayoutObject(this);
-  ASSERT(!m_counterNode);
+  DCHECK(!m_counterNode);
   if (documentBeingDestroyed())
     return;
   setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
       LayoutInvalidationReason::CountersChanged);
 }
 
 static void destroyCounterNodeWithoutMapRemoval(const AtomicString& identifier,
                                                 CounterNode* node) {
   CounterNode* previous;
   for (RefPtr<CounterNode> child = node->lastDescendant();
        child && child != node; child = previous) {
     previous = child->previousInPreOrder();
     child->parent()->removeChild(child.get());
-    ASSERT(counterMaps().at(&child->owner())->at(identifier) == child);
+    DCHECK(counterMaps().at(&child->owner())->at(identifier) == child);
     counterMaps().at(&child->owner())->erase(identifier);
   }
   if (CounterNode* parent = node->parent())
     parent->removeChild(node);
 }
 
 void LayoutCounter::destroyCounterNodes(LayoutObject& owner) {
   CounterMaps& maps = counterMaps();
   CounterMaps::iterator mapsIterator = maps.find(&owner);
   if (mapsIterator == maps.end())
@@ skipping 25 matching lines @@
   // The destruction of the LayoutObject (possibly caused by the removal of its
   // associated DOM node) is the other case that leads to the permanent
   // destruction of all counters attached to a LayoutObject. In this case
   // LayoutCounter::destroyCounterNodes() must be and is now called, too.
   // LayoutCounter::destroyCounterNodes() handles destruction of the counter
   // map associated with a layoutObject, so there is no risk in leaking the map.
 }
 
 void LayoutCounter::layoutObjectSubtreeWillBeDetached(
     LayoutObject* layoutObject) {
-  ASSERT(layoutObject->view());
+  DCHECK(layoutObject->view());
   // View should never be non-zero. crbug.com/546939
   if (!layoutObject->view() || !layoutObject->view()->hasLayoutCounters())
     return;
 
   LayoutObject* currentLayoutObject = layoutObject->lastLeafChild();
   if (!currentLayoutObject)
     currentLayoutObject = layoutObject;
   while (true) {
     destroyCounterNodes(*currentLayoutObject);
     if (currentLayoutObject == layoutObject)
       break;
     currentLayoutObject = currentLayoutObject->previousInPreOrder();
   }
 }
 
 static void updateCounters(LayoutObject& layoutObject) {
-  ASSERT(layoutObject.style());
+  DCHECK(layoutObject.style());
   const CounterDirectiveMap* directiveMap =
       layoutObject.style()->counterDirectives();
   if (!directiveMap)
     return;
   CounterDirectiveMap::const_iterator end = directiveMap->end();
   if (!layoutObject.hasCounterNodeMap()) {
     for (CounterDirectiveMap::const_iterator it = directiveMap->begin();
          it != end; ++it)
       makeCounterNodeIfNeeded(layoutObject, it->key, false);
     return;
   }
   CounterMap* counterMap = counterMaps().at(&layoutObject);
-  ASSERT(counterMap);
+  DCHECK(counterMap);
   for (CounterDirectiveMap::const_iterator it = directiveMap->begin();
        it != end; ++it) {
     RefPtr<CounterNode> node = counterMap->at(it->key);
     if (!node) {
       makeCounterNodeIfNeeded(layoutObject, it->key, false);
       continue;
     }
     RefPtr<CounterNode> newParent = nullptr;
     RefPtr<CounterNode> newPreviousSibling = nullptr;
 
     findPlaceForCounter(layoutObject, it->key, node->hasResetType(), newParent,
                         newPreviousSibling);
     if (node != counterMap->at(it->key))
       continue;
     CounterNode* parent = node->parent();
     if (newParent == parent && newPreviousSibling == node->previousSibling())
       continue;
     if (parent)
       parent->removeChild(node.get());
     if (newParent)
       newParent->insertAfter(node.get(), newPreviousSibling.get(), it->key);
   }
 }
 
 void LayoutCounter::layoutObjectSubtreeAttached(LayoutObject* layoutObject) {
-  ASSERT(layoutObject->view());
+  DCHECK(layoutObject->view());
   if (!layoutObject->view()->hasLayoutCounters())
     return;
   Node* node = layoutObject->node();
   if (node)
     node = node->parentNode();
   else
     node = layoutObject->generatingNode();
   if (node && node->needsAttach())
     return;  // No need to update if the parent is not attached yet
   for (LayoutObject* descendant = layoutObject; descendant;
@@ skipping 85 matching lines @@
             current->nextSibling(),
             current->hasCounterNodeMap()
                 ? counterName ? blink::counterMaps().at(current)->at(identifier)
                               : (blink::CounterNode*)1
                 : (blink::CounterNode*)0);
   }
   fflush(stderr);
 }
 
 #endif  // NDEBUG