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

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

 /*
  * Copyright 2005 Frerich Raabe <raabe@kde.org>
  * Copyright (C) 2006 Apple Computer, Inc.
  * 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 83 matching lines @@
         return leftVal + rightVal;
     case OP_Sub:
         return leftVal - rightVal;
     case OP_Mul:
         return leftVal * rightVal;
     case OP_Div:
         return leftVal / rightVal;
     case OP_Mod:
         return fmod(leftVal, rightVal);
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return 0.0;
 }
 
 EqTestOp::EqTestOp(Opcode opcode, Expression* lhs, Expression* rhs)
     : m_opcode(opcode)
 {
     addSubExpression(lhs);
     addSubExpression(rhs);
 }
 
@@ skipping 42 matching lines @@
             return false;
         }
         if (rhs.isBoolean()) {
             // If one object to be compared is a node-set and the other is a
             // boolean, then the comparison will be true if and only if the
             // result of performing the comparison on the boolean and on the
             // result of converting the node-set to a boolean using the boolean
             // function is true.
             return compare(context, lhs.toBoolean(), rhs);
         }
-        ASSERT(0);
+        NOTREACHED();
     }
     if (rhs.isNodeSet()) {
         const NodeSet& rhsSet = rhs.toNodeSet(&context);
         if (lhs.isNumber()) {
             for (unsigned rindex = 0; rindex < rhsSet.size(); ++rindex) {
                 if (compare(context, lhs, Value(stringValue(rhsSet[rindex])).toNumber()))
                     return true;
             }
             return false;
         }
         if (lhs.isString()) {
             for (unsigned rindex = 0; rindex < rhsSet.size(); ++rindex) {
                 if (compare(context, lhs, stringValue(rhsSet[rindex])))
                     return true;
             }
             return false;
         }
         if (lhs.isBoolean())
             return compare(context, lhs, rhs.toBoolean());
-        ASSERT(0);
+        NOTREACHED();
     }
 
     // Neither side is a NodeSet.
     switch (m_opcode) {
     case OpcodeEqual:
     case OpcodeNotEqual:
         bool equal;
         if (lhs.isBoolean() || rhs.isBoolean())
             equal = lhs.toBoolean() == rhs.toBoolean();
         else if (lhs.isNumber() || rhs.isNumber())
             equal = lhs.toNumber() == rhs.toNumber();
         else
             equal = lhs.toString() == rhs.toString();
 
         if (m_opcode == OpcodeEqual)
             return equal;
         return !equal;
     case OpcodeGreaterThan:
         return lhs.toNumber() > rhs.toNumber();
     case OpcodeGreaterOrEqual:
         return lhs.toNumber() >= rhs.toNumber();
     case OpcodeLessThan:
         return lhs.toNumber() < rhs.toNumber();
     case OpcodeLessOrEqual:
         return lhs.toNumber() <= rhs.toNumber();
     }
-    ASSERT(0);
+    NOTREACHED();
     return false;
 }
 
 Value EqTestOp::evaluate(EvaluationContext& context) const
 {
     Value lhs(subExpr(0)->evaluate(context));
     Value rhs(subExpr(1)->evaluate(context));
 
     return compare(context, lhs, rhs);
 }
@@ skipping 53 matching lines @@
 {
 }
 
 DEFINE_TRACE(Predicate)
 {
     visitor->trace(m_expr);
 }
 
 bool Predicate::evaluate(EvaluationContext& context) const
 {
-    ASSERT(m_expr);
+    DCHECK(m_expr);
 
     Value result(m_expr->evaluate(context));
 
     // foo[3] means foo[position()=3]
     if (result.isNumber())
         return EqTestOp(EqTestOp::OpcodeEqual, createFunction("position"), new Number(result.toNumber())).evaluate(context).toBoolean();
 
     return result.toBoolean();
 }
 
 } // namespace XPath
 
 } // namespace blink