SVG: remove |SVGAnimateElement::m_animatedPropertyType|

Source/core/svg/SVGAnimateElement.cpp

 /*
  * Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * 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
  * 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/css/parser/BisonCSSParser.h"
 #include "core/css/StylePropertySet.h"
 #include "core/dom/QualifiedName.h"
 #include "core/svg/SVGAnimatedTypeAnimator.h"
 #include "core/svg/SVGDocumentExtensions.h"
 
 namespace WebCore {
 
 SVGAnimateElement::SVGAnimateElement(const QualifiedName& tagName, Document& document)
     : SVGAnimationElement(tagName, document)
-    , m_animatedPropertyType(AnimatedString)
 {
     ASSERT(isSVGAnimateElement(*this));
     ScriptWrappable::init(this);
 }
 
 PassRefPtrWillBeRawPtr<SVGAnimateElement> SVGAnimateElement::create(Document& document)
 {
     return adoptRefWillBeRefCountedGarbageCollected(new SVGAnimateElement(SVGNames::animateTag, document));
 }
 
 SVGAnimateElement::~SVGAnimateElement()
 {
     // FIXME: Oilpan: Below prevent stopAnimValAnimation being called on |targetElement|. This should be moved to |removeFrom| equivalent.
 #if !ENABLE(OILPAN)
     if (targetElement())
         clearAnimatedType(targetElement());
 #endif
 }
 
+AnimatedPropertyType SVGAnimateElement::animatedPropertyType()
+{
+    return ensureAnimator()->type();
+}
+
 bool SVGAnimateElement::hasValidAttributeType()
 {
     SVGElement* targetElement = this->targetElement();
     if (!targetElement)
         return false;
 
-    return m_animatedPropertyType != AnimatedUnknown && !hasInvalidCSSAttributeType();
+    return animatedPropertyType() != AnimatedUnknown && !hasInvalidCSSAttributeType();
 }
 
 void SVGAnimateElement::calculateAnimatedValue(float percentage, unsigned repeatCount, SVGSMILElement* resultElement)
 {
     ASSERT(resultElement);
     SVGElement* targetElement = this->targetElement();
     if (!targetElement || !isSVGAnimateElement(*resultElement))
         return;
 
-    ASSERT(m_animatedPropertyType == determineAnimatedPropertyType());
-
     ASSERT(percentage >= 0 && percentage <= 1);
-    ASSERT(m_animatedPropertyType != AnimatedTransformList || isSVGAnimateTransformElement(*this));
-    ASSERT(m_animatedPropertyType != AnimatedUnknown);
     ASSERT(m_animator);
-    ASSERT(m_animator->type() == m_animatedPropertyType);
+    ASSERT(animatedPropertyType() != AnimatedTransformList || isSVGAnimateTransformElement(*this));
+    ASSERT(animatedPropertyType() != AnimatedUnknown);
     ASSERT(m_fromProperty);
-    ASSERT(m_fromProperty->type() == m_animatedPropertyType);
+    ASSERT(m_fromProperty->type() == animatedPropertyType());
     ASSERT(m_toProperty);
 
     SVGAnimateElement* resultAnimationElement = toSVGAnimateElement(resultElement);
     ASSERT(resultAnimationElement->m_animatedProperty);
-    ASSERT(resultAnimationElement->m_animatedPropertyType == m_animatedPropertyType);
+    ASSERT(resultAnimationElement->animatedPropertyType() == animatedPropertyType());
 
     if (isSVGSetElement(*this))
         percentage = 1;
 
     if (calcMode() == CalcModeDiscrete)
         percentage = percentage < 0.5 ? 0 : 1;
 
     // Target element might have changed.
     m_animator->setContextElement(targetElement);
 
@@ skipping 11 matching lines @@
 }
 
 bool SVGAnimateElement::calculateFromAndToValues(const String& fromString, const String& toString)
 {
     SVGElement* targetElement = this->targetElement();
     if (!targetElement)
         return false;
 
     determinePropertyValueTypes(fromString, toString);
     ensureAnimator()->calculateFromAndToValues(m_fromProperty, m_toProperty, fromString, toString);
-    ASSERT(m_animatedPropertyType == m_animator->type());
     return true;
 }
 
 bool SVGAnimateElement::calculateFromAndByValues(const String& fromString, const String& byString)
 {
     SVGElement* targetElement = this->targetElement();
     if (!targetElement)
         return false;
 
     if (animationMode() == ByAnimation && !isAdditive())
         return false;
 
     // from-by animation may only be used with attributes that support addition (e.g. most numeric attributes).
     if (animationMode() == FromByAnimation && !animatedPropertyTypeSupportsAddition())
         return false;
 
     ASSERT(!isSVGSetElement(*this));
 
     determinePropertyValueTypes(fromString, byString);
     ensureAnimator()->calculateFromAndByValues(m_fromProperty, m_toProperty, fromString, byString);
-    ASSERT(m_animatedPropertyType == m_animator->type());
     return true;
 }
 
 namespace {
 
 WillBeHeapVector<RawPtrWillBeMember<SVGElement> > findElementInstances(SVGElement* targetElement)
 {
     ASSERT(targetElement);
     WillBeHeapVector<RawPtrWillBeMember<SVGElement> > animatedElements;
 
     animatedElements.append(targetElement);
 
     const WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >& instances = targetElement->instancesForElement();
     const WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >::const_iterator end = instances.end();
     for (WillBeHeapHashSet<RawPtrWillBeWeakMember<SVGElement> >::const_iterator it = instances.begin(); it != end; ++it) {
         if (SVGElement* shadowTreeElement = *it)
             animatedElements.append(shadowTreeElement);
     }
 
     return animatedElements;
 }
 
 }
 
 void SVGAnimateElement::resetAnimatedType()
 {
     SVGAnimatedTypeAnimator* animator = ensureAnimator();
-    ASSERT(m_animatedPropertyType == animator->type());
 
     SVGElement* targetElement = this->targetElement();
     const QualifiedName& attributeName = this->attributeName();
     ShouldApplyAnimation shouldApply = shouldApplyAnimation(targetElement, attributeName);
 
     if (shouldApply == DontApplyAnimation)
         return;
 
     if (shouldApply == ApplyXMLAnimation) {
         // SVG DOM animVal animation code-path.
@@ skipping 133 matching lines @@
         WillBeHeapVector<RawPtrWillBeMember<SVGElement> > animatedElements = findElementInstances(targetElement);
         m_animator->stopAnimValAnimation(animatedElements);
         notifyTargetAndInstancesAboutAnimValChange(targetElement, attributeName());
     }
 
     m_animatedProperty.clear();
 }
 
 void SVGAnimateElement::applyResultsToTarget()
 {
-    ASSERT(m_animatedPropertyType != AnimatedTransformList || isSVGAnimateTransformElement(*this));
-    ASSERT(m_animatedPropertyType != AnimatedUnknown);
     ASSERT(m_animator);
+    ASSERT(animatedPropertyType() != AnimatedTransformList || isSVGAnimateTransformElement(*this));
+    ASSERT(animatedPropertyType() != AnimatedUnknown);
 
     // Early exit if our animated type got destructed by a previous endedActiveInterval().
     if (!m_animatedProperty)
         return;
 
-    if (ensureAnimator()->isAnimatingCSSProperty()) {
+    if (m_animator->isAnimatingCSSProperty()) {
         // CSS properties animation code-path.
         // Convert the result of the animation to a String and apply it as CSS property on the target & all instances.
         applyCSSPropertyToTargetAndInstances(targetElement(), attributeName(), m_animatedProperty->valueAsString());
         return;
     }
 
     // SVG DOM animVal animation code-path.
     // At this point the SVG DOM values are already changed, unlike for CSS.
     // We only have to trigger update notifications here.
     notifyTargetAndInstancesAboutAnimValChange(targetElement(), attributeName());
 }
 
-bool SVGAnimateElement::animatedPropertyTypeSupportsAddition() const
+bool SVGAnimateElement::animatedPropertyTypeSupportsAddition()
 {
     // Spec: http://www.w3.org/TR/SVG/animate.html#AnimationAttributesAndProperties.
-    switch (m_animatedPropertyType) {
+    switch (animatedPropertyType()) {
     case AnimatedBoolean:
     case AnimatedEnumeration:
     case AnimatedPreserveAspectRatio:
     case AnimatedString:
     case AnimatedUnknown:
         return false;
     default:
         return true;
     }
 }
 
-bool SVGAnimateElement::isAdditive() const
+bool SVGAnimateElement::isAdditive()
 {
     if (animationMode() == ByAnimation || animationMode() == FromByAnimation)
         if (!animatedPropertyTypeSupportsAddition())
             return false;
 
     return SVGAnimationElement::isAdditive();
 }
 
 float SVGAnimateElement::calculateDistance(const String& fromString, const String& toString)
 {
@@ skipping 17 matching lines @@
     resetAnimatedPropertyType();
 }
 
 void SVGAnimateElement::resetAnimatedPropertyType()
 {
     ASSERT(!m_animatedProperty);
     m_fromProperty.clear();
     m_toProperty.clear();
     m_toAtEndOfDurationProperty.clear();
     m_animator.clear();
-    m_animatedPropertyType = determineAnimatedPropertyType();
 }
 
 SVGAnimatedTypeAnimator* SVGAnimateElement::ensureAnimator()
 {
     if (!m_animator)
-        m_animator = SVGAnimatedTypeAnimator::create(m_animatedPropertyType, this, targetElement());
-    ASSERT(m_animatedPropertyType == m_animator->type());
+        m_animator = SVGAnimatedTypeAnimator::create(this, targetElement());
     return m_animator.get();
 }
 
 void SVGAnimateElement::trace(Visitor* visitor)
 {
     visitor->trace(m_animator);
     SVGAnimationElement::trace(visitor);
 }
 
 }