Push animation value 'inherit' handling into SVGAnimateElement

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

 /*
  * Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Cameron McCormack <cam@mcc.id.au>
  * Copyright (C) Research In Motion Limited 2011. 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 10 matching lines @@
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef SVGAnimationElement_h
 #define SVGAnimationElement_h
 
 #include "core/CoreExport.h"
 #include "core/svg/animation/SVGSMILElement.h"
 #include "ui/gfx/geometry/cubic_bezier.h"
-#include "wtf/Functional.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 class ExceptionState;
 
 enum AnimationMode {
   NoAnimation,
   FromToAnimation,
   FromByAnimation,
   ToAnimation,
   ByAnimation,
   ValuesAnimation,
   PathAnimation  // Used by AnimateMotion.
 };
 
-// If we have 'inherit' as animation value, we need to grab the value
-// during the animation since the value can be animated itself.
-enum AnimatedPropertyValueType { RegularPropertyValue, InheritValue };
-
 enum CalcMode {
   CalcModeDiscrete,
   CalcModeLinear,
   CalcModePaced,
   CalcModeSpline
 };
 
 class CORE_EXPORT SVGAnimationElement : public SVGSMILElement {
   DEFINE_WRAPPERTYPEINFO();
 
@@ skipping 23 matching lines @@
     DontApplyAnimation,
     ApplyCSSAnimation,
     ApplyXMLAnimation,
     ApplyXMLandCSSAnimation
   };
 
   ShouldApplyAnimationType shouldApplyAnimation(
       SVGElement* targetElement,
       const QualifiedName& attributeName);
 
-  AnimatedPropertyValueType fromPropertyValueType() const {
-    return m_fromPropertyValueType;
-  }
-  AnimatedPropertyValueType toPropertyValueType() const {
-    return m_toPropertyValueType;
-  }
-
-  template <typename AnimatedType, typename ParseTypeFromStringType>
-  void adjustForInheritance(ParseTypeFromStringType parseTypeFromString,
-                            AnimatedPropertyValueType valueType,
-                            AnimatedType& animatedType,
-                            SVGElement* contextElement) {
-    if (valueType != InheritValue)
-      return;
-    // Replace 'inherit' by its computed property value.
-    String typeString;
-    adjustForInheritance(contextElement, attributeName(), typeString);
-    animatedType = parseTypeFromString(this, typeString);
-  }
-
   template <typename AnimatedType>
   void animateDiscreteType(float percentage,
                            const AnimatedType& fromType,
                            const AnimatedType& toType,
                            AnimatedType& animatedType) {
     if ((getAnimationMode() == FromToAnimation && percentage > 0.5) ||
         getAnimationMode() == ToAnimation || percentage == 1) {
       animatedType = AnimatedType(toType);
       return;
     }
@@ skipping 17 matching lines @@
 
     if (isAdditive() && getAnimationMode() != ToAnimation)
       animatedNumber += number;
     else
       animatedNumber = number;
   }
 
  protected:
   SVGAnimationElement(const QualifiedName&, Document&);
 
-  void computeCSSPropertyValue(SVGElement*, CSSPropertyID, String& value);
-  void determinePropertyValueTypes(const String& from, const String& to);
-
   void parseAttribute(const QualifiedName&,
                       const AtomicString&,
                       const AtomicString&) override;
   void svgAttributeChanged(const QualifiedName&) override;
 
   enum AttributeType { AttributeTypeCSS, AttributeTypeXML, AttributeTypeAuto };
   AttributeType getAttributeType() const { return m_attributeType; }
 
   String toValue() const;
   String byValue() const;
   String fromValue() const;
 
   // from SVGSMILElement
   void startedActiveInterval() override;
   void updateAnimation(float percent,
                        unsigned repeat,
                        SVGSMILElement* resultElement) override;
 
-  AnimatedPropertyValueType m_fromPropertyValueType;
-  AnimatedPropertyValueType m_toPropertyValueType;
-
   void setTargetElement(SVGElement*) override;
   void setAttributeName(const QualifiedName&) override;
 
   bool hasInvalidCSSAttributeType() const {
     return m_hasInvalidCSSAttributeType;
   }
 
   virtual void updateAnimationMode();
   void setAnimationMode(AnimationMode animationMode) {
     m_animationMode = animationMode;
@@ skipping 36 matching lines @@
   void calculateKeyTimesForCalcModePaced();
   float calculatePercentFromKeyPoints(float percent) const;
   void currentValuesFromKeyPoints(float percent,
                                   float& effectivePercent,
                                   String& from,
                                   String& to) const;
   float calculatePercentForSpline(float percent, unsigned splineIndex) const;
   float calculatePercentForFromTo(float percent) const;
   unsigned calculateKeyTimesIndex(float percent) const;
 
-  void adjustForInheritance(SVGElement* targetElement,
-                            const QualifiedName& attributeName,
-                            String&);
-
   void setCalcMode(const AtomicString&);
 
   bool m_animationValid;
 
   AttributeType m_attributeType;
   Vector<String> m_values;
   // FIXME: We should probably use doubles for this, but there's no point
   // making such a change unless all SVG logic for sampling animations is
   // changed to use doubles.
   Vector<float> m_keyTimes;
   Vector<float> m_keyPoints;
   Vector<gfx::CubicBezier> m_keySplines;
   String m_lastValuesAnimationFrom;
   String m_lastValuesAnimationTo;
   bool m_hasInvalidCSSAttributeType;
   CalcMode m_calcMode;
   AnimationMode m_animationMode;
 };
 
 }  // namespace blink
 
 #endif  // SVGAnimationElement_h