Replace ASSERT with DCHECK in core/svg/

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

 /*
  * Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
  * Copyright (C) Research In Motion Limited 2010. 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
@@ skipping 21 matching lines @@
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 SVGAnimationElement::SVGAnimationElement(const QualifiedName& tagName,
                                          Document& document)
     : SVGSMILElement(tagName, document),
       m_animationValid(false),
       m_calcMode(CalcModeLinear),
       m_animationMode(NoAnimation) {
-  ASSERT(RuntimeEnabledFeatures::smilEnabled());
+  DCHECK(RuntimeEnabledFeatures::smilEnabled());
   UseCounter::count(document, UseCounter::SVGAnimationElement);
 }
 
 bool SVGAnimationElement::parseValues(const String& value,
                                       Vector<String>& result) {
   // Per the SMIL specification, leading and trailing white space, and white
   // space before and after semicolon separators, is allowed and will be
   // ignored.
   // http://www.w3.org/TR/SVG11/animate.html#ValuesAttribute
   result.clear();
@@ skipping 266 matching lines @@
   return value == sum || getAnimationMode() == ByAnimation;
 }
 
 bool SVGAnimationElement::isAccumulated() const {
   DEFINE_STATIC_LOCAL(const AtomicString, sum, ("sum"));
   const AtomicString& value = fastGetAttribute(SVGNames::accumulateAttr);
   return value == sum && getAnimationMode() != ToAnimation;
 }
 
 void SVGAnimationElement::calculateKeyTimesForCalcModePaced() {
-  ASSERT(getCalcMode() == CalcModePaced);
-  ASSERT(getAnimationMode() == ValuesAnimation);
+  DCHECK_EQ(getCalcMode(), CalcModePaced);
+  DCHECK_EQ(getAnimationMode(), ValuesAnimation);
 
   unsigned valuesCount = m_values.size();
-  ASSERT(valuesCount >= 1);
+  DCHECK_GE(valuesCount, static_cast<unsigned>(1));

[fs, 2017/03/14 21:50:23]

Nit: 1u

   if (valuesCount == 1)
     return;
 
   // FIXME, webkit.org/b/109010: m_keyTimes should not be modified in this
   // function.
   m_keyTimes.clear();
 
   Vector<float> keyTimesForPaced;
   float totalDistance = 0;
   keyTimesForPaced.push_back(0);
@@ skipping 33 matching lines @@
   for (index = 1; index < keyTimesCount; ++index) {
     if (m_keyTimes[index] > percent)
       break;
   }
   return --index;
 }
 
 float SVGAnimationElement::calculatePercentForSpline(
     float percent,
     unsigned splineIndex) const {
-  ASSERT(getCalcMode() == CalcModeSpline);
+  DCHECK_EQ(getCalcMode(), CalcModeSpline);
   SECURITY_DCHECK(splineIndex < m_keySplines.size());
   gfx::CubicBezier bezier = m_keySplines[splineIndex];
   SMILTime duration = simpleDuration();
   if (!duration.isFinite())
     duration = 100.0;
   return clampTo<float>(
       bezier.SolveWithEpsilon(percent, solveEpsilon(duration.value())));
 }
 
 float SVGAnimationElement::calculatePercentFromKeyPoints(float percent) const {
-  ASSERT(!m_keyPoints.isEmpty());
-  ASSERT(getCalcMode() != CalcModePaced);
-  ASSERT(m_keyTimes.size() > 1);
-  ASSERT(m_keyPoints.size() == m_keyTimes.size());
+  DCHECK(!m_keyPoints.isEmpty());
+  DCHECK_NE(getCalcMode(), CalcModePaced);
+  DCHECK_GT(m_keyTimes.size(), static_cast<unsigned>(1));

[fs, 2017/03/14 21:50:23]

Nit: 1u

+  DCHECK_EQ(m_keyPoints.size(), m_keyTimes.size());
 
   if (percent == 1)
     return m_keyPoints[m_keyPoints.size() - 1];
 
   unsigned index = calculateKeyTimesIndex(percent);
   float fromKeyPoint = m_keyPoints[index];
 
   if (getCalcMode() == CalcModeDiscrete)
     return fromKeyPoint;
 
-  ASSERT(index + 1 < m_keyTimes.size());
+  DCHECK_LT(index + 1, m_keyTimes.size());
   float fromPercent = m_keyTimes[index];
   float toPercent = m_keyTimes[index + 1];
   float toKeyPoint = m_keyPoints[index + 1];
   float keyPointPercent = (percent - fromPercent) / (toPercent - fromPercent);
 
   if (getCalcMode() == CalcModeSpline) {
-    ASSERT(m_keySplines.size() == m_keyPoints.size() - 1);
+    DCHECK_EQ(m_keySplines.size(), m_keyPoints.size() - 1);
     keyPointPercent = calculatePercentForSpline(keyPointPercent, index);
   }
   return (toKeyPoint - fromKeyPoint) * keyPointPercent + fromKeyPoint;
 }
 
 float SVGAnimationElement::calculatePercentForFromTo(float percent) const {
   if (getCalcMode() == CalcModeDiscrete && m_keyTimes.size() == 2)
     return percent > m_keyTimes[1] ? 1 : 0;
 
   return percent;
 }
 
 void SVGAnimationElement::currentValuesFromKeyPoints(float percent,
                                                      float& effectivePercent,
                                                      String& from,
                                                      String& to) const {
-  ASSERT(!m_keyPoints.isEmpty());
-  ASSERT(m_keyPoints.size() == m_keyTimes.size());
-  ASSERT(getCalcMode() != CalcModePaced);
+  DCHECK(!m_keyPoints.isEmpty());
+  DCHECK_EQ(m_keyPoints.size(), m_keyTimes.size());
+  DCHECK_NE(getCalcMode(), CalcModePaced);
   effectivePercent = calculatePercentFromKeyPoints(percent);
   unsigned index =
       effectivePercent == 1
           ? m_values.size() - 2
           : static_cast<unsigned>(effectivePercent * (m_values.size() - 1));
   from = m_values[index];
   to = m_values[index + 1];
 }
 
 void SVGAnimationElement::currentValuesForValuesAnimation(
     float percent,
     float& effectivePercent,
     String& from,
     String& to) {
   unsigned valuesCount = m_values.size();
-  ASSERT(m_animationValid);
-  ASSERT(valuesCount >= 1);
+  DCHECK(m_animationValid);
+  DCHECK_GE(valuesCount, static_cast<unsigned>(1));

[fs, 2017/03/14 21:50:23]

1u

 
   if (percent == 1 || valuesCount == 1) {
     from = m_values[valuesCount - 1];
     to = m_values[valuesCount - 1];
     effectivePercent = 1;
     return;
   }
 
   CalcMode calcMode = this->getCalcMode();
   if (isSVGAnimateElement(*this)) {
     SVGAnimateElement& animateElement = toSVGAnimateElement(*this);
     if (!animateElement.animatedPropertyTypeSupportsAddition())
       calcMode = CalcModeDiscrete;
   }
   if (!m_keyPoints.isEmpty() && calcMode != CalcModePaced)
     return currentValuesFromKeyPoints(percent, effectivePercent, from, to);
 
   unsigned keyTimesCount = m_keyTimes.size();
-  ASSERT(!keyTimesCount || valuesCount == keyTimesCount);
-  ASSERT(!keyTimesCount || (keyTimesCount > 1 && !m_keyTimes[0]));
+  DCHECK(!keyTimesCount || valuesCount == keyTimesCount);
+  DCHECK(!keyTimesCount || (keyTimesCount > 1 && !m_keyTimes[0]));
 
   unsigned index = calculateKeyTimesIndex(percent);
   if (calcMode == CalcModeDiscrete) {
     if (!keyTimesCount)
       index = static_cast<unsigned>(percent * valuesCount);
     from = m_values[index];
     to = m_values[index];
     effectivePercent = 0;
     return;
   }
 
   float fromPercent;
   float toPercent;
   if (keyTimesCount) {
     fromPercent = m_keyTimes[index];
     toPercent = m_keyTimes[index + 1];
   } else {
     index = static_cast<unsigned>(floorf(percent * (valuesCount - 1)));
     fromPercent = static_cast<float>(index) / (valuesCount - 1);
     toPercent = static_cast<float>(index + 1) / (valuesCount - 1);
   }
 
   if (index == valuesCount - 1)
     --index;
   from = m_values[index];
   to = m_values[index + 1];
-  ASSERT(toPercent > fromPercent);
+  DCHECK_GT(toPercent, fromPercent);
   effectivePercent = (percent - fromPercent) / (toPercent - fromPercent);
 
   if (calcMode == CalcModeSpline) {
-    ASSERT(m_keySplines.size() == m_values.size() - 1);
+    DCHECK_EQ(m_keySplines.size(), m_values.size() - 1);
     effectivePercent = calculatePercentForSpline(effectivePercent, index);
   }
 }
 
 void SVGAnimationElement::startedActiveInterval() {
   m_animationValid = false;
 
   if (!isValid() || !hasValidTarget())
     return;
 
@@ skipping 94 matching lines @@
         calculatePercentForSpline(percent, calculateKeyTimesIndex(percent));
   else if (animationMode == FromToAnimation || animationMode == ToAnimation)
     effectivePercent = calculatePercentForFromTo(percent);
   else
     effectivePercent = percent;
 
   calculateAnimatedValue(effectivePercent, repeatCount, resultElement);
 }
 
 }  // namespace blink