Replace ASSERT*() with DCHECK*() in core/xml/.

third_party/WebKit/Source/core/xml/XPathStep.cpp

 /*
  * Copyright (C) 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 72 matching lines @@
     swap(remainingPredicates, m_predicates);
 }
 
 bool optimizeStepPair(Step* first, Step* second)
 {
     if (first->m_axis == Step::DescendantOrSelfAxis
         && first->nodeTest().getKind() == Step::NodeTest::AnyNodeTest
         && !first->m_predicates.size()
         && !first->nodeTest().mergedPredicates().size()) {
 
-        ASSERT(first->nodeTest().data().isEmpty());
-        ASSERT(first->nodeTest().namespaceURI().isEmpty());
+        DCHECK(first->nodeTest().data().isEmpty());
+        DCHECK(first->nodeTest().namespaceURI().isEmpty());
 
         // Optimize the common case of "//" AKA
         // /descendant-or-self::node()/child::NodeTest to /descendant::NodeTest.
         if (second->m_axis == Step::ChildAxis && second->predicatesAreContextListInsensitive()) {
             first->m_axis = Step::DescendantAxis;
             first->nodeTest() = Step::NodeTest(second->nodeTest().getKind(), second->nodeTest().data(), second->nodeTest().namespaceURI());
             swap(second->nodeTest().mergedPredicates(), first->nodeTest().mergedPredicates());
             swap(second->m_predicates, first->m_predicates);
             first->optimize();
             return true;
@@ skipping 115 matching lines @@
                 // compared case-insensitively.
                 return equalIgnoringCase(element.localName(), name) && (namespaceURI.isNull() || namespaceURI == element.namespaceURI());
             }
             // An expression without any prefix shouldn't match no-namespace
             // nodes (because HTML5 says so).
             return element.hasLocalName(name) && namespaceURI == element.namespaceURI() && !namespaceURI.isNull();
         }
         return element.hasLocalName(name) && namespaceURI == element.namespaceURI();
     }
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return false;
 }
 
 static inline bool nodeMatches(EvaluationContext& evaluationContext, Node* node, Step::Axis axis, const Step::NodeTest& nodeTest)
 {
     if (!nodeMatchesBasicTest(node, axis, nodeTest))
         return false;
 
     // Only the first merged predicate may depend on position.
     ++evaluationContext.position;
 
     const HeapVector<Member<Predicate>>& mergedPredicates = nodeTest.mergedPredicates();
     for (unsigned i = 0; i < mergedPredicates.size(); i++) {
         Predicate* predicate = mergedPredicates[i].get();
 
         evaluationContext.node = node;
         // No need to set context size - we only get here when evaluating
         // predicates that do not depend on it.
         if (!predicate->evaluate(evaluationContext))
             return false;
     }
 
     return true;
 }
 
 // Result nodes are ordered in axis order. Node test (including merged
 // predicates) is applied.
 void Step::nodesInAxis(EvaluationContext& evaluationContext, Node* context, NodeSet& nodes) const
 {
-    ASSERT(nodes.isEmpty());
+    DCHECK(nodes.isEmpty());
     switch (m_axis) {
     case ChildAxis:
         // In XPath model, attribute nodes do not have children.
         if (context->isAttributeNode())
             return;
 
         for (Node* n = context->firstChild(); n; n = n->nextSibling()) {
             if (nodeMatches(evaluationContext, n, ChildAxis, nodeTest()))
                 nodes.append(n);
         }
@@ skipping 153 matching lines @@
                 nodes.append(n);
         }
         for (n = n->parentNode(); n; n = n->parentNode()) {
             if (nodeMatches(evaluationContext, n, AncestorOrSelfAxis, nodeTest()))
                 nodes.append(n);
         }
         nodes.markSorted(false);
         return;
     }
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
 }
 
 } // namespace XPath
 
 } // namespace blink