ASSERT -> {DCHECK|DCHECK_XX}, ENABLE(ASSERT) -> DCHECK_IS_ON() in dom

third_party/WebKit/Source/core/dom/ContainerNode.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2013 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.
@@ skipping 60 matching lines @@
         return;
     }
     nodes.append(&node);
     if (ContainerNode* oldParent = node.parentNode())
         oldParent->removeChild(&node, exceptionState);
 }
 
 #if !ENABLE(OILPAN)
 void ContainerNode::removeDetachedChildren()
 {
-    ASSERT(!connectedSubframeCount());
-    ASSERT(needsAttach());
+    DCHECK(!connectedSubframeCount());
+    DCHECK(needsAttach());
     removeDetachedChildrenInContainer(*this);
 }
 #endif
 
 void ContainerNode::parserTakeAllChildrenFrom(ContainerNode& oldParent)
 {
     while (RawPtr<Node> child = oldParent.firstChild()) {
         // Explicitly remove since appending can fail, but this loop shouldn't be infinite.
         oldParent.parserRemoveChild(*child);
         parserAppendChild(child.get());
     }
 }
 
 ContainerNode::~ContainerNode()
 {
-    ASSERT(needsAttach());
+    DCHECK(needsAttach());
 #if !ENABLE(OILPAN)
     willBeDeletedFromDocument();
     removeDetachedChildren();
 #endif
 }
 
 bool ContainerNode::isChildTypeAllowed(const Node& child) const
 {
     if (!child.isDocumentFragment())
         return childTypeAllowed(child.getNodeType());
@@ skipping 15 matching lines @@
 bool ContainerNode::checkAcceptChild(const Node* newChild, const Node* oldChild, ExceptionState& exceptionState) const
 {
     // Not mentioned in spec: throw NotFoundError if newChild is null
     if (!newChild) {
         exceptionState.throwDOMException(NotFoundError, "The new child element is null.");
         return false;
     }
 
     // Use common case fast path if possible.
     if ((newChild->isElementNode() || newChild->isTextNode()) && isElementNode()) {
-        ASSERT(isChildTypeAllowed(*newChild));
+        DCHECK(isChildTypeAllowed(*newChild));
         if (containsConsideringHostElements(*newChild)) {
             exceptionState.throwDOMException(HierarchyRequestError, "The new child element contains the parent.");
             return false;
         }
         return true;
     }
 
     // This should never happen, but also protect release builds from tree corruption.
-    ASSERT(!newChild->isPseudoElement());
+    DCHECK(!newChild->isPseudoElement());
     if (newChild->isPseudoElement()) {
         exceptionState.throwDOMException(HierarchyRequestError, "The new child element is a pseudo-element.");
         return false;
     }
 
     return checkAcceptChildGuaranteedNodeTypes(*newChild, oldChild, exceptionState);
 }
 
 bool ContainerNode::checkAcceptChildGuaranteedNodeTypes(const Node& newChild, const Node* oldChild, ExceptionState& exceptionState) const
 {
     if (isDocumentNode())
         return toDocument(this)->canAcceptChild(newChild, oldChild, exceptionState);
     if (newChild.containsIncludingHostElements(*this)) {
         exceptionState.throwDOMException(HierarchyRequestError, "The new child element contains the parent.");
         return false;
     }
     if (!isChildTypeAllowed(newChild)) {
         exceptionState.throwDOMException(HierarchyRequestError, "Nodes of type '" + newChild.nodeName() + "' may not be inserted inside nodes of type '" + nodeName() + "'.");
         return false;
     }
     return true;
 }
 
 RawPtr<Node> ContainerNode::insertBefore(RawPtr<Node> newChild, Node* refChild, ExceptionState& exceptionState)
 {
 #if !ENABLE(OILPAN)
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
-    ASSERT(refCount() || parentOrShadowHostNode());
+    DCHECK(refCount() || parentOrShadowHostNode());
 #endif
 
     RawPtr<Node> protect(this);
 
     // insertBefore(node, 0) is equivalent to appendChild(node)
     if (!refChild) {
         return appendChild(newChild, exceptionState);
     }
 
     // Make sure adding the new child is OK.
     if (!checkAcceptChild(newChild.get(), 0, exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return newChild;
     }
-    ASSERT(newChild);
+    DCHECK(newChild);
 
     // NotFoundError: Raised if refChild is not a child of this node
     if (refChild->parentNode() != this) {
         exceptionState.throwDOMException(NotFoundError, "The node before which the new node is to be inserted is not a child of this node.");
         return nullptr;
     }
 
     // Nothing to do.
     if (refChild->previousSibling() == newChild || refChild == newChild)
         return newChild;
@@ skipping 11 matching lines @@
     if (!checkAcceptChildGuaranteedNodeTypes(*newChild, nullptr, exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return newChild;
     }
 
     InspectorInstrumentation::willInsertDOMNode(this);
 
     ChildListMutationScope mutation(*this);
     for (const auto& targetNode : targets) {
-        ASSERT(targetNode);
+        DCHECK(targetNode);
         Node& child = *targetNode;
 
         // Due to arbitrary code running in response to a DOM mutation event it's
         // possible that "next" is no longer a child of "this".
         // It's also possible that "child" has been inserted elsewhere.
         // In either of those cases, we'll just stop.
         if (next->parentNode() != this)
             break;
         if (child.parentNode())
             break;
@@ skipping 12 matching lines @@
     dispatchSubtreeModifiedEvent();
 
     return newChild;
 }
 
 void ContainerNode::insertBeforeCommon(Node& nextChild, Node& newChild)
 {
     EventDispatchForbiddenScope assertNoEventDispatch;
     ScriptForbiddenScope forbidScript;
 
-    ASSERT(!newChild.parentNode()); // Use insertBefore if you need to handle reparenting (and want DOM mutation events).
-    ASSERT(!newChild.nextSibling());
-    ASSERT(!newChild.previousSibling());
-    ASSERT(!newChild.isShadowRoot());
+    DCHECK(!newChild.parentNode()); // Use insertBefore if you need to handle reparenting (and want DOM mutation events).
+    DCHECK(!newChild.nextSibling());
+    DCHECK(!newChild.previousSibling());
+    DCHECK(!newChild.isShadowRoot());
 
     Node* prev = nextChild.previousSibling();
-    ASSERT(m_lastChild != prev);
+    DCHECK_NE(m_lastChild, prev);
     nextChild.setPreviousSibling(&newChild);
     if (prev) {
-        ASSERT(firstChild() != nextChild);
-        ASSERT(prev->nextSibling() == nextChild);
+        DCHECK_NE(firstChild(), nextChild);
+        DCHECK_EQ(prev->nextSibling(), nextChild);
         prev->setNextSibling(&newChild);
     } else {
-        ASSERT(firstChild() == nextChild);
+        DCHECK(firstChild() == nextChild);
         m_firstChild = &newChild;
     }
     newChild.setParentOrShadowHostNode(this);
     newChild.setPreviousSibling(prev);
     newChild.setNextSibling(&nextChild);
 }
 
 void ContainerNode::appendChildCommon(Node& child)
 {
     child.setParentOrShadowHostNode(this);
@@ skipping 12 matching lines @@
 {
     if (!isDocumentNode())
         return true;
     // TODO(esprehn): Are there other conditions where the parser can create
     // invalid trees?
     return toDocument(*this).canAcceptChild(newChild, nullptr, IGNORE_EXCEPTION);
 }
 
 void ContainerNode::parserInsertBefore(RawPtr<Node> newChild, Node& nextChild)
 {
-    ASSERT(newChild);
-    ASSERT(nextChild.parentNode() == this);
-    ASSERT(!newChild->isDocumentFragment());
-    ASSERT(!isHTMLTemplateElement(this));
+    DCHECK(newChild);
+    DCHECK_EQ(nextChild.parentNode(), this);
+    DCHECK(!newChild->isDocumentFragment());
+    DCHECK(!isHTMLTemplateElement(this));
 
     if (nextChild.previousSibling() == newChild || &nextChild == newChild) // nothing to do
         return;
 
     if (!checkParserAcceptChild(*newChild))
         return;
 
     RawPtr<Node> protect(this);
 
     // FIXME: parserRemoveChild can run script which could then insert the
     // newChild back into the page. Loop until the child is actually removed.
     // See: fast/parser/execute-script-during-adoption-agency-removal.html
     while (RawPtr<ContainerNode> parent = newChild->parentNode())
         parent->parserRemoveChild(*newChild);
 
     if (nextChild.parentNode() != this)
         return;
 
     if (document() != newChild->document())
         document().adoptNode(newChild.get(), ASSERT_NO_EXCEPTION);
 
     {
         EventDispatchForbiddenScope assertNoEventDispatch;
         ScriptForbiddenScope forbidScript;
 
         treeScope().adoptIfNeeded(*newChild);
         insertBeforeCommon(nextChild, *newChild);
-        ASSERT(newChild->connectedSubframeCount() == 0);
+        DCHECK_EQ(newChild->connectedSubframeCount(), 0u);
         ChildListMutationScope(*this).childAdded(*newChild);
     }
 
     notifyNodeInserted(*newChild, ChildrenChangeSourceParser);
 }
 
 RawPtr<Node> ContainerNode::replaceChild(RawPtr<Node> newChild, RawPtr<Node> oldChild, ExceptionState& exceptionState)
 {
 #if !ENABLE(OILPAN)
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
-    ASSERT(refCount() || parentOrShadowHostNode());
+    DCHECK(refCount() || parentOrShadowHostNode());
 #endif
 
     RawPtr<Node> protect(this);
 
     if (oldChild == newChild) // Nothing to do.
         return oldChild;
 
     if (!oldChild) {
         exceptionState.throwDOMException(NotFoundError, "The node to be replaced is null.");
         return nullptr;
@@ skipping 42 matching lines @@
     if (!checkAcceptChild(newChild.get(), child.get(), exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return child;
     }
 
     InspectorInstrumentation::willInsertDOMNode(this);
 
     // Add the new child(ren).
     for (const auto& targetNode : targets) {
-        ASSERT(targetNode);
+        DCHECK(targetNode);
         Node& child = *targetNode;
 
         // Due to arbitrary code running in response to a DOM mutation event it's
         // possible that "next" is no longer a child of "this".
         // It's also possible that "child" has been inserted elsewhere.
         // In either of those cases, we'll just stop.
         if (next && next->parentNode() != this)
             break;
         if (child.parentNode())
             break;
@@ skipping 11 matching lines @@
 
         updateTreeAfterInsertion(child);
     }
 
     dispatchSubtreeModifiedEvent();
     return child;
 }
 
 void ContainerNode::willRemoveChild(Node& child)
 {
-    ASSERT(child.parentNode() == this);
+    DCHECK_EQ(child.parentNode(), this);
     ChildListMutationScope(*this).willRemoveChild(child);
     child.notifyMutationObserversNodeWillDetach();
     dispatchChildRemovalEvents(child);
     ChildFrameDisconnector(child).disconnect();
     if (document() != child.document()) {
         // |child| was moved another document by DOM mutation event handler.
         return;
     }
 
     // |nodeWillBeRemoved()| must be run after |ChildFrameDisconnector|, because
     // |ChildFrameDisconnector| can run script which may cause state that is to
     // be invalidated by removing the node.
     ScriptForbiddenScope scriptForbiddenScope;
     EventDispatchForbiddenScope assertNoEventDispatch;
     // e.g. mutation event listener can create a new range.
     document().nodeWillBeRemoved(child);
 }
 
 void ContainerNode::willRemoveChildren()
 {
     NodeVector children;
     getChildNodes(*this, children);
 
     ChildListMutationScope mutation(*this);
     for (const auto& node : children) {
-        ASSERT(node);
+        DCHECK(node);
         Node& child = *node;
         mutation.willRemoveChild(child);
         child.notifyMutationObserversNodeWillDetach();
         dispatchChildRemovalEvents(child);
     }
 
     ChildFrameDisconnector(*this).disconnect(ChildFrameDisconnector::DescendantsOnly);
 }
 
 #if !ENABLE(OILPAN)
@@ skipping 71 matching lines @@
     visitor->trace(m_firstChild);
     visitor->trace(m_lastChild);
     Node::trace(visitor);
 }
 
 RawPtr<Node> ContainerNode::removeChild(RawPtr<Node> oldChild, ExceptionState& exceptionState)
 {
 #if !ENABLE(OILPAN)
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
-    ASSERT(refCount() || parentOrShadowHostNode());
+    DCHECK(refCount() || parentOrShadowHostNode());
 #endif
 
     RawPtr<Node> protect(this);
 
     // NotFoundError: Raised if oldChild is not a child of this node.
     // FIXME: We should never really get PseudoElements in here, but editing will sometimes
     // attempt to remove them still. We should fix that and enable this ASSERT.
-    // ASSERT(!oldChild->isPseudoElement())
+    // DCHECK(!oldChild->isPseudoElement())
     if (!oldChild || oldChild->parentNode() != this || oldChild->isPseudoElement()) {
         exceptionState.throwDOMException(NotFoundError, "The node to be removed is not a child of this node.");
         return nullptr;
     }
 
     RawPtr<Node> child = oldChild;
 
     document().removeFocusedElementOfSubtree(child.get());
 
     // Events fired when blurring currently focused node might have moved this
@@ skipping 22 matching lines @@
         childrenChanged(ChildrenChange::forRemoval(*child, prev, next, ChildrenChangeSourceAPI));
     }
     dispatchSubtreeModifiedEvent();
     return child;
 }
 
 void ContainerNode::removeBetween(Node* previousChild, Node* nextChild, Node& oldChild)
 {
     EventDispatchForbiddenScope assertNoEventDispatch;
 
-    ASSERT(oldChild.parentNode() == this);
+    DCHECK_EQ(oldChild.parentNode(), this);
 
     AttachContext context;
     context.clearInvalidation = true;
     if (!oldChild.needsAttach())
         oldChild.detach(context);
 
     if (nextChild)
         nextChild->setPreviousSibling(previousChild);
     if (previousChild)
         previousChild->setNextSibling(nextChild);
     if (m_firstChild == &oldChild)
         m_firstChild = nextChild;
     if (m_lastChild == &oldChild)
         m_lastChild = previousChild;
 
     oldChild.setPreviousSibling(nullptr);
     oldChild.setNextSibling(nullptr);
     oldChild.setParentOrShadowHostNode(nullptr);
 
     document().adoptIfNeeded(oldChild);
 }
 
 void ContainerNode::parserRemoveChild(Node& oldChild)
 {
-    ASSERT(oldChild.parentNode() == this);
-    ASSERT(!oldChild.isDocumentFragment());
+    DCHECK_EQ(oldChild.parentNode(), this);
+    DCHECK(!oldChild.isDocumentFragment());
 
     // This may cause arbitrary Javascript execution via onunload handlers.
     if (oldChild.connectedSubframeCount())
         ChildFrameDisconnector(oldChild).disconnect();
 
     if (oldChild.parentNode() != this)
         return;
 
     ChildListMutationScope(*this).willRemoveChild(oldChild);
     oldChild.notifyMutationObserversNodeWillDetach();
@@ skipping 73 matching lines @@
         dispatchSubtreeModifiedEvent();
 }
 
 RawPtr<Node> ContainerNode::appendChild(RawPtr<Node> newChild, ExceptionState& exceptionState)
 {
     RawPtr<ContainerNode> protect(this);
 
 #if !ENABLE(OILPAN)
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
-    ASSERT(refCount() || parentOrShadowHostNode());
+    DCHECK(refCount() || parentOrShadowHostNode());
 #endif
 
     // Make sure adding the new child is ok
     if (!checkAcceptChild(newChild.get(), 0, exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return newChild;
     }
-    ASSERT(newChild);
+    DCHECK(newChild);
 
     if (newChild == m_lastChild) // nothing to do
         return newChild;
 
     NodeVector targets;
     collectChildrenAndRemoveFromOldParent(*newChild, targets, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     if (targets.isEmpty())
         return newChild;
 
     // We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
     if (!checkAcceptChildGuaranteedNodeTypes(*newChild, nullptr, exceptionState)) {
         if (exceptionState.hadException())
             return nullptr;
         return newChild;
     }
 
     InspectorInstrumentation::willInsertDOMNode(this);
 
     // Now actually add the child(ren).
     ChildListMutationScope mutation(*this);
     for (const auto& targetNode : targets) {
-        ASSERT(targetNode);
+        DCHECK(targetNode);
         Node& child = *targetNode;
 
         // If the child has a parent again, just stop what we're doing, because
         // that means someone is doing something with DOM mutation -- can't re-parent
         // a child that already has a parent.
         if (child.parentNode())
             break;
 
         {
             EventDispatchForbiddenScope assertNoEventDispatch;
             ScriptForbiddenScope forbidScript;
 
             treeScope().adoptIfNeeded(child);
             appendChildCommon(child);
         }
 
         updateTreeAfterInsertion(child);
     }
 
     dispatchSubtreeModifiedEvent();
     return newChild;
 }
 
 void ContainerNode::parserAppendChild(RawPtr<Node> newChild)
 {
-    ASSERT(newChild);
-    ASSERT(!newChild->isDocumentFragment());
-    ASSERT(!isHTMLTemplateElement(this));
+    DCHECK(newChild);
+    DCHECK(!newChild->isDocumentFragment());
+    DCHECK(!isHTMLTemplateElement(this));
 
     if (!checkParserAcceptChild(*newChild))
         return;
 
     RawPtr<Node> protect(this);
 
     // FIXME: parserRemoveChild can run script which could then insert the
     // newChild back into the page. Loop until the child is actually removed.
     // See: fast/parser/execute-script-during-adoption-agency-removal.html
     while (RawPtr<ContainerNode> parent = newChild->parentNode())
         parent->parserRemoveChild(*newChild);
 
     if (document() != newChild->document())
         document().adoptNode(newChild.get(), ASSERT_NO_EXCEPTION);
 
     {
         EventDispatchForbiddenScope assertNoEventDispatch;
         ScriptForbiddenScope forbidScript;
 
         treeScope().adoptIfNeeded(*newChild);
         appendChildCommon(*newChild);
-        ASSERT(newChild->connectedSubframeCount() == 0);
+        DCHECK_EQ(newChild->connectedSubframeCount(), 0u);
         ChildListMutationScope(*this).childAdded(*newChild);
     }
 
     notifyNodeInserted(*newChild, ChildrenChangeSourceParser);
 }
 
 void ContainerNode::notifyNodeInserted(Node& root, ChildrenChangeSource source)
 {
-    ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
-    ASSERT(!root.isShadowRoot());
+#if DCHECK_IS_ON()
+    DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
+    DCHECK(!root.isShadowRoot());
 
     InspectorInstrumentation::didInsertDOMNode(&root);
 
     RawPtr<Node> protect(this);
     RawPtr<Node> protectNode(root);
 
     NodeVector postInsertionNotificationTargets;
     notifyNodeInsertedInternal(root, postInsertionNotificationTargets);
 
     childrenChanged(ChildrenChange::forInsertion(root, source));
@@ skipping 37 matching lines @@
             notifyNodeRemoved(*shadowRoot);
     }
 }
 
 void ContainerNode::attach(const AttachContext& context)
 {
     AttachContext childrenContext(context);
     childrenContext.resolvedStyle = nullptr;
 
     for (Node* child = firstChild(); child; child = child->nextSibling()) {
-        ASSERT(child->needsAttach() || childAttachedAllowedWhenAttachingChildren(this));
+#if DCHECK_IS_ON()
+        DCHECK(child->needsAttach() || childAttachedAllowedWhenAttachingChildren(this));
+#endif
         if (child->needsAttach())
             child->attach(childrenContext);
     }
 
     clearChildNeedsStyleRecalc();
     Node::attach(context);
 }
 
 void ContainerNode::detach(const AttachContext& context)
 {
@@ skipping 51 matching lines @@
             LayoutObject* next = nullptr;
             while (!next && o->parent()) {
                 o = o->parent();
                 next = o->nextSibling();
             }
             o = next;
 
             if (!o)
                 break;
         }
-        ASSERT(o);
+        DCHECK(o);
 
         if (!o->isInline() || o->isAtomicInlineLevel()) {
             point = o->localToAbsolute(FloatPoint(), UseTransforms);
             return true;
         }
 
         if (p->node() && p->node() == this && o->isText() && !o->isBR() && !toLayoutText(o)->hasTextBoxes()) {
             // Do nothing - skip unrendered whitespace that is a child or next sibling of the anchor.
             // FIXME: This fails to skip a whitespace sibling when there was also a whitespace child (because p has moved).
         } else if ((o->isText() && !o->isBR()) || o->isAtomicInlineLevel()) {
             point = FloatPoint();
             if (o->isText()) {
                 if (toLayoutText(o)->firstTextBox())
                     point.move(toLayoutText(o)->linesBoundingBox().x(), toLayoutText(o)->firstTextBox()->root().lineTop().toFloat());
                 point = o->localToAbsolute(point, UseTransforms);
             } else {
-                ASSERT(o->isBox());
+                DCHECK(o->isBox());
                 LayoutBox* box = toLayoutBox(o);
                 point.moveBy(box->location());
                 point = o->container()->localToAbsolute(point, UseTransforms);
             }
             return true;
         }
     }
 
     // If the target doesn't have any children or siblings that could be used to calculate the scroll position, we must be
     // at the end of the document. Scroll to the bottom. FIXME: who said anything about scrolling?
@@ skipping 61 matching lines @@
                 if (o == layoutObject()) {
                     return false;
                 }
                 o = o->parent();
                 if (!o)
                     return false;
                 prev = o->previousSibling();
             }
             o = prev;
         }
-        ASSERT(o);
+        DCHECK(o);
         if (o->isText() || o->isAtomicInlineLevel()) {
             point = FloatPoint();
             if (o->isText()) {
                 LayoutText* text = toLayoutText(o);
                 IntRect linesBox = text->linesBoundingBox();
                 if (!linesBox.maxX() && !linesBox.maxY())
                     continue;
                 point.moveBy(linesBox.maxXMaxYCorner());
                 point = o->localToAbsolute(point, UseTransforms);
             } else {
@@ skipping 172 matching lines @@
 
     NthIndexCache nthIndexCache(document());
     return selectorQuery->queryAll(*this);
 }
 
 static void dispatchChildInsertionEvents(Node& child)
 {
     if (child.isInShadowTree())
         return;
 
-    ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#if DCHECK_IS_ON()
+    DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
 
     RawPtr<Node> c(child);
     RawPtr<Document> document(child.document());
 
     if (c->parentNode() && document->hasListenerType(Document::DOMNODEINSERTED_LISTENER))
         c->dispatchScopedEvent(MutationEvent::create(EventTypeNames::DOMNodeInserted, true, c->parentNode()));
 
     // dispatch the DOMNodeInsertedIntoDocument event to all descendants
     if (c->inShadowIncludingDocument() && document->hasListenerType(Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER)) {
         for (; c; c = NodeTraversal::next(*c, &child))
             c->dispatchScopedEvent(MutationEvent::create(EventTypeNames::DOMNodeInsertedIntoDocument, false));
     }
 }
 
 static void dispatchChildRemovalEvents(Node& child)
 {
     if (child.isInShadowTree()) {
         InspectorInstrumentation::willRemoveDOMNode(&child);
         return;
     }
 
-    ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#if DCHECK_IS_ON()
+    DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
 
     InspectorInstrumentation::willRemoveDOMNode(&child);
 
     RawPtr<Node> c(child);
     RawPtr<Document> document(child.document());
 
     // Dispatch pre-removal mutation events.
     if (c->parentNode() && document->hasListenerType(Document::DOMNODEREMOVED_LISTENER)) {
         NodeChildRemovalTracker scope(child);
         c->dispatchScopedEvent(MutationEvent::create(EventTypeNames::DOMNodeRemoved, true, c->parentNode()));
     }
 
     // Dispatch the DOMNodeRemovedFromDocument event to all descendants.
     if (c->inShadowIncludingDocument() && document->hasListenerType(Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER)) {
         NodeChildRemovalTracker scope(child);
         for (; c; c = NodeTraversal::next(*c, &child))
             c->dispatchScopedEvent(MutationEvent::create(EventTypeNames::DOMNodeRemovedFromDocument, false));
     }
 }
 
 void ContainerNode::updateTreeAfterInsertion(Node& child)
 {
 #if !ENABLE(OILPAN)
-    ASSERT(refCount());
-    ASSERT(child.refCount());
+    DCHECK(refCount());
+    DCHECK(child.refCount());
 #endif
 
     ChildListMutationScope(*this).childAdded(child);
 
     notifyNodeInserted(child);
 
     dispatchChildInsertionEvents(child);
 }
 
 bool ContainerNode::hasRestyleFlagInternal(DynamicRestyleFlags mask) const
 {
     return rareData()->hasRestyleFlag(mask);
 }
 
 bool ContainerNode::hasRestyleFlagsInternal() const
 {
     return rareData()->hasRestyleFlags();
 }
 
 void ContainerNode::setRestyleFlag(DynamicRestyleFlags mask)
 {
-    ASSERT(isElementNode() || isShadowRoot());
+    DCHECK(isElementNode() || isShadowRoot());
     ensureRareData().setRestyleFlag(mask);
 }
 
 void ContainerNode::recalcChildStyle(StyleRecalcChange change)
 {
-    ASSERT(document().inStyleRecalc());
-    ASSERT(change >= UpdatePseudoElements || childNeedsStyleRecalc());
-    ASSERT(!needsStyleRecalc());
+    DCHECK(document().inStyleRecalc());
+    DCHECK(change >= UpdatePseudoElements || childNeedsStyleRecalc());
+    DCHECK(!needsStyleRecalc());
 
     // This loop is deliberately backwards because we use insertBefore in the layout tree, and want to avoid
     // a potentially n^2 loop to find the insertion point while resolving style. Having us start from the last
     // child and work our way back means in the common case, we'll find the insertion point in O(1) time.
     // See crbug.com/288225
     StyleResolver& styleResolver = document().ensureStyleResolver();
     Text* lastTextNode = nullptr;
     for (Node* child = lastChild(); child; child = child->previousSibling()) {
         if (child->isTextNode()) {
             toText(child)->recalcTextStyle(change, lastTextNode);
@@ skipping 26 matching lines @@
     if (((childrenAffectedByForwardPositionalRules() || childrenAffectedByIndirectAdjacentRules()) && nodeAfterChange)
         || (childrenAffectedByBackwardPositionalRules() && nodeBeforeChange)) {
         setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::SiblingSelector));
         return;
     }
 
     // :first-child. In the parser callback case, we don't have to check anything, since we were right the first time.
     // In the DOM case, we only need to do something if |afterChange| is not 0.
     // |afterChange| is 0 in the parser case, so it works out that we'll skip this block.
     if (childrenAffectedByFirstChildRules() && nodeAfterChange) {
-        ASSERT(changeType != FinishedParsingChildren);
+        DCHECK_NE(changeType, FinishedParsingChildren);
         // Find our new first child element.
         Element* firstChildElement = ElementTraversal::firstChild(*this);
 
         // Find the first element after the change.
         Element* elementAfterChange = nodeAfterChange->isElementNode() ? toElement(nodeAfterChange) : ElementTraversal::nextSibling(*nodeAfterChange);
 
         // This is the element insertion as first child element case.
         if (changeType == SiblingElementInserted && elementAfterChange && firstChildElement != elementAfterChange
             && (!nodeBeforeChange || !nodeBeforeChange->isElementNode()) && elementAfterChange->affectedByFirstChildRules()) {
             elementAfterChange->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::SiblingSelector));
@@ skipping 82 matching lines @@
 
 // Takes an AtomicString in argument because it is common for elements to share the same set of class names.
 // Therefore, the ClassNodeList factory function expects an AtomicString type.
 RawPtr<ClassCollection> ContainerNode::getElementsByClassName(const AtomicString& classNames)
 {
     return ensureCachedCollection<ClassCollection>(ClassCollectionType, classNames);
 }
 
 RawPtr<RadioNodeList> ContainerNode::radioNodeList(const AtomicString& name, bool onlyMatchImgElements)
 {
-    ASSERT(isHTMLFormElement(this) || isHTMLFieldSetElement(this));
+    DCHECK(isHTMLFormElement(this) || isHTMLFieldSetElement(this));
     CollectionType type = onlyMatchImgElements ? RadioImgNodeListType : RadioNodeListType;
     return ensureCachedCollection<RadioNodeList>(type, name);
 }
 
 Element* ContainerNode::getElementById(const AtomicString& id) const
 {
     if (isInTreeScope()) {
         // Fast path if we are in a tree scope: call getElementById() on tree scope
         // and check if the matching element is in our subtree.
         Element* element = treeScope().getElementById(id);
         if (!element)
             return nullptr;
         if (element->isDescendantOf(this))
             return element;
     }
 
     // Fall back to traversing our subtree. In case of duplicate ids, the first element found will be returned.
     for (Element& element : ElementTraversal::descendantsOf(*this)) {
         if (element.getIdAttribute() == id)
             return &element;
     }
     return nullptr;
 }
 
 NodeListsNodeData& ContainerNode::ensureNodeLists()
 {
     return ensureRareData().ensureNodeLists();
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool childAttachedAllowedWhenAttachingChildren(ContainerNode* node)
 {
     if (node->isShadowRoot())
         return true;
 
     if (node->isInsertionPoint())
         return true;
 
     if (isHTMLSlotElement(node))
         return true;
 
     if (node->isElementNode() && toElement(node)->shadow())
         return true;
 
     return false;
 }
 #endif
 
 } // namespace blink