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

third_party/WebKit/Source/core/dom/shadow/FlatTreeTraversal.cpp

 /*
  * Copyright (C) 2012 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.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 55 matching lines @@
         }
         if (node->isInV0ShadowTree())
             return v0ResolveDistributionStartingAt(*sibling, direction);
         return const_cast<Node*>(sibling);
     }
     return nullptr;
 }
 
 Node* FlatTreeTraversal::v0ResolveDistributionStartingAt(const Node& node, TraversalDirection direction)
 {
-    ASSERT(!isHTMLSlotElement(node));
+    DCHECK(!isHTMLSlotElement(node));
     for (const Node* sibling = &node; sibling; sibling = (direction == TraversalDirectionForward ? sibling->nextSibling() : sibling->previousSibling())) {
         if (!isActiveInsertionPoint(*sibling))
             return const_cast<Node*>(sibling);
         const InsertionPoint& insertionPoint = toInsertionPoint(*sibling);
         if (Node* found = (direction == TraversalDirectionForward ? insertionPoint.firstDistributedNode() : insertionPoint.lastDistributedNode()))
             return found;
-        ASSERT(isHTMLShadowElement(insertionPoint) || (isHTMLContentElement(insertionPoint) && !insertionPoint.hasChildren()));
+        DCHECK(isHTMLShadowElement(insertionPoint) || (isHTMLContentElement(insertionPoint) && !insertionPoint.hasChildren()));
     }
     return nullptr;
 }
 
 static HTMLSlotElement* finalDestinationSlotFor(const Node& node)
 {
     HTMLSlotElement* slot = node.assignedSlot();
     if (!slot)
         return nullptr;
     for (HTMLSlotElement* next = slot->assignedSlot(); next; next = next->assignedSlot()) {
@@ skipping 16 matching lines @@
         return found;
 
     if (!node.isInV0ShadowTree())
         return nullptr;
 
     // For v0 older shadow tree
     if (node.parentNode() && node.parentNode()->isShadowRoot()) {
         ShadowRoot* parentShadowRoot = toShadowRoot(node.parentNode());
         if (!parentShadowRoot->isYoungest()) {
             HTMLShadowElement* assignedInsertionPoint = parentShadowRoot->shadowInsertionPointOfYoungerShadowRoot();
-            ASSERT(assignedInsertionPoint);
+            DCHECK(assignedInsertionPoint);
             return traverseSiblings(*assignedInsertionPoint, direction);
         }
     }
     return nullptr;
 }
 
 Node* FlatTreeTraversal::traverseSiblingsForV1HostChild(const Node& node, TraversalDirection direction)
 {
     HTMLSlotElement* slot = finalDestinationSlotFor(node);
     if (!slot)
@@ skipping 31 matching lines @@
     if (parent && isHTMLSlotElement(parent)) {
         HTMLSlotElement& slot = toHTMLSlotElement(*parent);
         if (!slot.getAssignedNodes().isEmpty())
             return nullptr;
         return traverseParent(slot, details);
     }
 
     if (canBeDistributedToInsertionPoint(node))
         return traverseParentForV0(node, details);
 
-    ASSERT(!shadowWhereNodeCanBeDistributed(node));
+    DCHECK(!shadowWhereNodeCanBeDistributed(node));
     return traverseParentOrHost(node);
 }
 
 ContainerNode* FlatTreeTraversal::traverseParentForV0(const Node& node, ParentTraversalDetails* details)
 {
     if (shadowWhereNodeCanBeDistributed(node)) {
         if (const InsertionPoint* insertionPoint = resolveReprojection(&node)) {
             if (details)
                 details->didTraverseInsertionPoint(insertionPoint);
             // The node is distributed. But the distribution was stopped at this insertion point.
@@ skipping 10 matching lines @@
 }
 
 ContainerNode* FlatTreeTraversal::traverseParentOrHost(const Node& node)
 {
     ContainerNode* parent = node.parentNode();
     if (!parent)
         return nullptr;
     if (!parent->isShadowRoot())
         return parent;
     ShadowRoot* shadowRoot = toShadowRoot(parent);
-    ASSERT(!shadowRoot->shadowInsertionPointOfYoungerShadowRoot());
+    DCHECK(!shadowRoot->shadowInsertionPointOfYoungerShadowRoot());
     if (!shadowRoot->isYoungest())
         return nullptr;
     return shadowRoot->host();
 }
 
 Node* FlatTreeTraversal::childAt(const Node& node, unsigned index)
 {
     assertPrecondition(node);
     Node* child = traverseFirstChild(node);
     while (child && index--)
@@ skipping 24 matching lines @@
 
 Node* FlatTreeTraversal::previousSkippingChildren(const Node& node)
 {
     if (Node* previousSibling = traversePreviousSibling(node))
         return previousSibling;
     return traversePreviousAncestorSibling(node);
 }
 
 static Node* previousAncestorSiblingPostOrder(const Node& current, const Node* stayWithin)
 {
-    ASSERT(!FlatTreeTraversal::previousSibling(current));
+    DCHECK(!FlatTreeTraversal::previousSibling(current));
     for (Node* parent = FlatTreeTraversal::parent(current); parent; parent = FlatTreeTraversal::parent(*parent)) {
         if (parent == stayWithin)
             return nullptr;
         if (Node* previousSibling = FlatTreeTraversal::previousSibling(*parent))
             return previousSibling;
     }
     return nullptr;
 }
 
 // TODO(yosin) We should consider introducing template class to share code
@@ skipping 37 matching lines @@
         [](const Node& node)
         {
             return FlatTreeTraversal::parent(node);
         });
     assertPostcondition(result);
     return result;
 }
 
 Node* FlatTreeTraversal::traverseNextAncestorSibling(const Node& node)
 {
-    ASSERT(!traverseNextSibling(node));
+    DCHECK(!traverseNextSibling(node));
     for (Node* parent = traverseParent(node); parent; parent = traverseParent(*parent)) {
         if (Node* nextSibling = traverseNextSibling(*parent))
             return nextSibling;
     }
     return nullptr;
 }
 
 Node* FlatTreeTraversal::traversePreviousAncestorSibling(const Node& node)
 {
-    ASSERT(!traversePreviousSibling(node));
+    DCHECK(!traversePreviousSibling(node));
     for (Node* parent = traverseParent(node); parent; parent = traverseParent(*parent)) {
         if (Node* previousSibling = traversePreviousSibling(*parent))
             return previousSibling;
     }
     return nullptr;
 }
 
 unsigned FlatTreeTraversal::index(const Node& node)
 {
     assertPrecondition(node);
@@ skipping 25 matching lines @@
 Node& FlatTreeTraversal::lastWithinOrSelf(const Node& node)
 {
     assertPrecondition(node);
     Node* lastDescendant = lastWithin(node);
     Node& result = lastDescendant ? *lastDescendant : const_cast<Node&>(node);
     assertPostcondition(&result);
     return result;
 }
 
 } // namespace blink