Replace ASSERT with DCHECK in core/svg/

third_party/WebKit/Source/core/svg/SVGLength.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 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.
  *
@@ skipping 17 matching lines @@
 #include "core/svg/SVGAnimationElement.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 SVGLength::SVGLength(SVGLengthMode mode)
     : m_value(
           CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::UserUnits)),
       m_unitMode(static_cast<unsigned>(mode)) {
-  ASSERT(unitMode() == mode);
+  DCHECK_EQ(unitMode(), mode);
 }
 
 SVGLength::SVGLength(const SVGLength& o)
     : m_value(o.m_value), m_unitMode(o.m_unitMode) {}
 
 DEFINE_TRACE(SVGLength) {
   visitor->trace(m_value);
   SVGPropertyBase::trace(visitor);
 }
 
@@ skipping 43 matching lines @@
 
 static bool isSupportedCSSUnitType(CSSPrimitiveValue::UnitType type) {
   return (CSSPrimitiveValue::isLength(type) ||
           type == CSSPrimitiveValue::UnitType::Number ||
           type == CSSPrimitiveValue::UnitType::Percentage ||
           isCalcCSSUnitType(type)) &&
          type != CSSPrimitiveValue::UnitType::QuirkyEms;
 }
 
 void SVGLength::setUnitType(CSSPrimitiveValue::UnitType type) {
-  ASSERT(isSupportedCSSUnitType(type));
+  DCHECK(isSupportedCSSUnitType(type));
   m_value = CSSPrimitiveValue::create(m_value->getFloatValue(), type);
 }
 
 float SVGLength::valueAsPercentage() const {
   // LengthTypePercentage is represented with 100% = 100.0. Good for accuracy
   // but could eventually be changed.
   if (m_value->isPercentage()) {
     // Note: This division is a source of floating point inaccuracy.
     return m_value->getFloatValue() / 100;
   }
@@ skipping 46 matching lines @@
   return m_value->customCSSText();
 }
 
 void SVGLength::newValueSpecifiedUnits(CSSPrimitiveValue::UnitType type,
                                        float value) {
   m_value = CSSPrimitiveValue::create(value, type);
 }
 
 void SVGLength::convertToSpecifiedUnits(CSSPrimitiveValue::UnitType type,
                                         const SVGLengthContext& context) {
-  ASSERT(isSupportedCSSUnitType(type));
+  DCHECK(isSupportedCSSUnitType(type));
 
   float valueInUserUnits = value(context);
   m_value = CSSPrimitiveValue::create(
       context.convertValueFromUserUnits(valueInUserUnits, unitMode(), type),
       type);
 }
 
 SVGLengthMode SVGLength::lengthModeForAnimatedLengthAttribute(
     const QualifiedName& attrName) {
   typedef HashMap<QualifiedName, SVGLengthMode> LengthModeForLengthAttributeMap;
@@ skipping 61 matching lines @@
   SVGLength* toLength = toSVGLength(toValue);
   SVGLength* toAtEndOfDurationLength = toSVGLength(toAtEndOfDurationValue);
 
   SVGLengthContext lengthContext(contextElement);
   float animatedNumber = value(lengthContext);
   animationElement->animateAdditiveNumber(
       percentage, repeatCount, fromLength->value(lengthContext),
       toLength->value(lengthContext),
       toAtEndOfDurationLength->value(lengthContext), animatedNumber);
 
-  ASSERT(unitMode() == lengthModeForAnimatedLengthAttribute(
-                           animationElement->attributeName()));
+  DCHECK_EQ(unitMode(), lengthModeForAnimatedLengthAttribute(
+                            animationElement->attributeName()));
 
   // TODO(shanmuga.m): Construct a calc() expression if the units fall in
   // different categories.
   CSSPrimitiveValue::UnitType newUnit = CSSPrimitiveValue::UnitType::UserUnits;
   if (percentage < 0.5) {
     if (!fromLength->isCalculated())
       newUnit = fromLength->typeWithCalcResolved();
   } else {
     if (!toLength->isCalculated())
       newUnit = toLength->typeWithCalcResolved();
   }
   animatedNumber = lengthContext.convertValueFromUserUnits(animatedNumber,
                                                            unitMode(), newUnit);
   m_value = CSSPrimitiveValue::create(animatedNumber, newUnit);
 }
 
 float SVGLength::calculateDistance(SVGPropertyBase* toValue,
                                    SVGElement* contextElement) {
   SVGLengthContext lengthContext(contextElement);
   SVGLength* toLength = toSVGLength(toValue);
 
   return fabsf(toLength->value(lengthContext) - value(lengthContext));
 }
 
 }  // namespace blink