Rename enums/functions that collide in chromium style in core/svg,xml

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 331 matching lines @@
 
 String SVGAnimationElement::fromValue() const
 {
     return fastGetAttribute(SVGNames::fromAttr);
 }
 
 bool SVGAnimationElement::isAdditive()
 {
     DEFINE_STATIC_LOCAL(const AtomicString, sum, ("sum", AtomicString::ConstructFromLiteral));
     const AtomicString& value = fastGetAttribute(SVGNames::additiveAttr);
-    return value == sum || animationMode() == ByAnimation;
+    return value == sum || getAnimationMode() == ByAnimation;
 }
 
 bool SVGAnimationElement::isAccumulated() const
 {
     DEFINE_STATIC_LOCAL(const AtomicString, sum, ("sum", AtomicString::ConstructFromLiteral));
     const AtomicString& value = fastGetAttribute(SVGNames::accumulateAttr);
-    return value == sum && animationMode() != ToAnimation;
+    return value == sum && getAnimationMode() != ToAnimation;
 }
 
 bool SVGAnimationElement::isTargetAttributeCSSProperty(SVGElement* targetElement, const QualifiedName& attributeName)
 {
     ASSERT(targetElement);
 
     return SVGElement::isAnimatableCSSProperty(attributeName) || targetElement->isPresentationAttribute(attributeName);
 }
 
 SVGAnimationElement::ShouldApplyAnimation SVGAnimationElement::shouldApplyAnimation(SVGElement* targetElement, const QualifiedName& attributeName)
 {
     if (!hasValidAttributeType() || !targetElement || attributeName == anyQName() || !targetElement->inActiveDocument())
         return DontApplyAnimation;
 
     // Always animate CSS properties, using the ApplyCSSAnimation code path, regardless of the attributeType value.
     if (isTargetAttributeCSSProperty(targetElement, attributeName)) {
         if (targetElement->isPresentationAttributeWithSVGDOM(attributeName))
             return ApplyXMLandCSSAnimation;
 
         return ApplyCSSAnimation;
     }
     // If attributeType="CSS" and attributeName doesn't point to a CSS property, ignore the animation.
-    if (attributeType() == AttributeTypeCSS)
+    if (getAttributeType() == AttributeTypeCSS)
         return DontApplyAnimation;
 
     return ApplyXMLAnimation;
 }
 
 void SVGAnimationElement::calculateKeyTimesForCalcModePaced()
 {
-    ASSERT(calcMode() == CalcModePaced);
-    ASSERT(animationMode() == ValuesAnimation);
+    ASSERT(getCalcMode() == CalcModePaced);
+    ASSERT(getAnimationMode() == ValuesAnimation);
 
     unsigned valuesCount = m_values.size();
     ASSERT(valuesCount >= 1);
     if (valuesCount == 1)
         return;
 
     // FIXME, webkit.org/b/109010: m_keyTimes should not be modified in this function.
     m_keyTimes.clear();
 
     Vector<float> keyTimesForPaced;
@@ skipping 21 matching lines @@
 
 static inline double solveEpsilon(double duration) { return 1 / (200 * duration); }
 
 unsigned SVGAnimationElement::calculateKeyTimesIndex(float percent) const
 {
     unsigned index;
     unsigned keyTimesCount = m_keyTimes.size();
     // For linear and spline animations, the last value must be '1'. In those
     // cases we don't need to consider the last value, since |percent| is never
     // greater than one.
-    if (keyTimesCount && calcMode() != CalcModeDiscrete)
+    if (keyTimesCount && getCalcMode() != CalcModeDiscrete)
         keyTimesCount--;
     for (index = 1; index < keyTimesCount; ++index) {
         if (m_keyTimes[index] > percent)
             break;
     }
     return --index;
 }
 
 float SVGAnimationElement::calculatePercentForSpline(float percent, unsigned splineIndex) const
 {
-    ASSERT(calcMode() == CalcModeSpline);
+    ASSERT(getCalcMode() == CalcModeSpline);
     ASSERT_WITH_SECURITY_IMPLICATION(splineIndex < m_keySplines.size());
     UnitBezier bezier = m_keySplines[splineIndex];
     SMILTime duration = simpleDuration();
     if (!duration.isFinite())
         duration = 100.0;
     return narrowPrecisionToFloat(bezier.solve(percent, solveEpsilon(duration.value())));
 }
 
 float SVGAnimationElement::calculatePercentFromKeyPoints(float percent) const
 {
     ASSERT(!m_keyPoints.isEmpty());
-    ASSERT(calcMode() != CalcModePaced);
+    ASSERT(getCalcMode() != CalcModePaced);
     ASSERT(m_keyTimes.size() > 1);
     ASSERT(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 (calcMode() == CalcModeDiscrete)
+    if (getCalcMode() == CalcModeDiscrete)
         return fromKeyPoint;
 
     ASSERT(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 (calcMode() == CalcModeSpline) {
+    if (getCalcMode() == CalcModeSpline) {
         ASSERT(m_keySplines.size() == m_keyPoints.size() - 1);
         keyPointPercent = calculatePercentForSpline(keyPointPercent, index);
     }
     return (toKeyPoint - fromKeyPoint) * keyPointPercent + fromKeyPoint;
 }
 
 float SVGAnimationElement::calculatePercentForFromTo(float percent) const
 {
-    if (calcMode() == CalcModeDiscrete && m_keyTimes.size() == 2)
+    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(calcMode() != CalcModePaced);
+    ASSERT(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);
 
     if (percent == 1 || valuesCount == 1) {
         from = m_values[valuesCount - 1];
         to = m_values[valuesCount - 1];
         effectivePercent = 1;
         return;
     }
 
-    CalcMode calcMode = this->calcMode();
+    CalcMode calcMode = this->getCalcMode();
     if (isSVGAnimateElement(*this)) {
         SVGAnimateElement& animateElement = toSVGAnimateElement(*this);
         if (!animateElement.animatedPropertyTypeSupportsAddition()) {
             ASSERT(animateElement.animatedPropertyType() != AnimatedTransformList || isSVGAnimateTransformElement(*this));
             ASSERT(animateElement.animatedPropertyType() != AnimatedUnknown);
             calcMode = CalcModeDiscrete;
         }
     }
     if (!m_keyPoints.isEmpty() && calcMode != CalcModePaced)
         return currentValuesFromKeyPoints(percent, effectivePercent, from, to);
@@ skipping 43 matching lines @@
     if (!isValid())
         return;
 
     if (!hasValidAttributeType())
         return;
 
     // These validations are appropriate for all animation modes.
     if (fastHasAttribute(SVGNames::keyPointsAttr) && m_keyPoints.size() != m_keyTimes.size())
         return;
 
-    AnimationMode animationMode = this->animationMode();
-    CalcMode calcMode = this->calcMode();
+    AnimationMode animationMode = this->getAnimationMode();
+    CalcMode calcMode = this->getCalcMode();
     if (calcMode == CalcModeSpline) {
         unsigned splinesCount = m_keySplines.size();
         if (!splinesCount
             || (fastHasAttribute(SVGNames::keyPointsAttr) && m_keyPoints.size() - 1 != splinesCount)
             || (animationMode == ValuesAnimation && m_values.size() - 1 != splinesCount)
             || (fastHasAttribute(SVGNames::keyTimesAttr) && m_keyTimes.size() - 1 != splinesCount))
             return;
     }
 
     String from = fromValue();
@@ skipping 28 matching lines @@
         m_animationValid = calcMode == CalcModePaced || !fastHasAttribute(SVGNames::keyPointsAttr) || (m_keyTimes.size() > 1 && m_keyTimes.size() == m_keyPoints.size());
     }
 }
 
 void SVGAnimationElement::updateAnimation(float percent, unsigned repeatCount, SVGSMILElement* resultElement)
 {
     if (!m_animationValid)
         return;
 
     float effectivePercent;
-    CalcMode calcMode = this->calcMode();
-    AnimationMode animationMode = this->animationMode();
+    CalcMode calcMode = this->getCalcMode();
+    AnimationMode animationMode = this->getAnimationMode();
     if (animationMode == ValuesAnimation) {
         String from;
         String to;
         currentValuesForValuesAnimation(percent, effectivePercent, from, to);
         if (from != m_lastValuesAnimationFrom || to != m_lastValuesAnimationTo) {
             m_animationValid = calculateFromAndToValues(from, to);
             if (!m_animationValid)
                 return;
             m_lastValuesAnimationFrom = from;
             m_lastValuesAnimationTo = to;
@@ skipping 66 matching lines @@
 }
 
 void SVGAnimationElement::setAttributeName(const QualifiedName& attributeName)
 {
     SVGSMILElement::setAttributeName(attributeName);
     checkInvalidCSSAttributeType();
 }
 
 void SVGAnimationElement::checkInvalidCSSAttributeType()
 {
-    bool hasInvalidCSSAttributeType = targetElement() && hasValidAttributeName() && attributeType() == AttributeTypeCSS && !isTargetAttributeCSSProperty(targetElement(), attributeName());
+    bool hasInvalidCSSAttributeType = targetElement() && hasValidAttributeName() && getAttributeType() == AttributeTypeCSS && !isTargetAttributeCSSProperty(targetElement(), attributeName());
 
     if (hasInvalidCSSAttributeType != m_hasInvalidCSSAttributeType) {
         if (hasInvalidCSSAttributeType)
             unscheduleIfScheduled();
 
         m_hasInvalidCSSAttributeType = hasInvalidCSSAttributeType;
 
         if (!hasInvalidCSSAttributeType)
             schedule();
     }
 
     // Clear values that may depend on the previous target.
     if (targetElement())
         clearAnimatedType();
 }
 
 } // namespace blink