[SVG] SVGLength{,List} migration to new SVG property impl.

Source/core/svg/SVGAnimatedNewPropertyAnimator.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/svg/SVGAnimatedNewPropertyAnimator.h"
 
 #include "core/svg/SVGAnimationElement.h"
 #include "core/svg/SVGElementInstance.h"
+#include "core/svg/SVGLength.h"
+#include "core/svg/SVGLengthList.h"
 
 namespace WebCore {
 
-SVGAnimatedNewPropertyAnimator::SVGAnimatedNewPropertyAnimator(SVGAnimationElement* animationElement, SVGElement* contextElement)
-    : SVGAnimatedTypeAnimator(AnimatedNewProperty, animationElement, contextElement)
+SVGAnimatedNewPropertyAnimator::SVGAnimatedNewPropertyAnimator(SVGAnimationElement* animationElement, SVGElement* contextElement, AnimatedPropertyType propertyType)
+    : SVGAnimatedTypeAnimator(propertyType, animationElement, contextElement)
+    , m_propertyType(propertyType)
 {
     ASSERT(m_animationElement);
     ASSERT(m_contextElement);
 
     const QualifiedName& attributeName = m_animationElement->attributeName();
     m_animatedProperty = m_contextElement->propertyFromAttribute(attributeName);
-    ASSERT(m_animatedProperty);
+
+    ASSERT(m_propertyType == AnimatedLength
+        || m_propertyType == AnimatedLengthList
+        || m_propertyType == AnimatedNewProperty); // FIXME
 }
 
 SVGAnimatedNewPropertyAnimator::~SVGAnimatedNewPropertyAnimator()
 {
 }
 
 PassRefPtr<NewSVGPropertyBase> SVGAnimatedNewPropertyAnimator::createPropertyForAnimation(const String& value)
 {
-    return m_animatedProperty->currentValueBase()->cloneForAnimation(value);
+    if (m_animatedProperty) {
+        // SVG DOM animVal animation code-path.
+        return m_animatedProperty->currentValueBase()->cloneForAnimation(value);
+    }
+
+    // CSS properties animation code-path.
+    // Create a basic instance of the corresponding SVG property.
+    // The instance will not have full context info. (e.g. SVGLengthMode)
+    if (m_propertyType == AnimatedLength) {
+        RefPtr<SVGLength> property = SVGLength::create(LengthModeOther);
+        property->setValueAsString(value, IGNORE_EXCEPTION);
+        return property.release();
+    }
+
+    if (m_propertyType == AnimatedLengthList) {
+        RefPtr<SVGLengthList> property = SVGLengthList::create(LengthModeOther);
+        property->setValueAsString(value, IGNORE_EXCEPTION);
+        return property.release();
+    }
+
+    ASSERT_NOT_REACHED();
+    return 0;
 }
 
 PassOwnPtr<SVGAnimatedType> SVGAnimatedNewPropertyAnimator::constructFromString(const String& value)
 {
-    return SVGAnimatedType::createNewProperty(createPropertyForAnimation(value));
+    return SVGAnimatedType::createNewProperty(createPropertyForAnimation(value), m_propertyType);
 }
 
-PassOwnPtr<SVGAnimatedType> SVGAnimatedNewPropertyAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList&)
+namespace {
+
+typedef void (NewSVGAnimatedPropertyBase::*NewSVGAnimatedPropertyMethod)();
+
+void invokeMethodOnAllTargetProperties(const SVGElementAnimatedPropertyList& list, const QualifiedName& attributeName, NewSVGAnimatedPropertyMethod method)
+{
+    SVGElementAnimatedPropertyList::const_iterator it = list.begin();
+    SVGElementAnimatedPropertyList::const_iterator itEnd = list.end();
+    for (; it != itEnd; ++it) {
+        RefPtr<NewSVGAnimatedPropertyBase> animatedProperty = it->element->propertyFromAttribute(attributeName);
+        (animatedProperty.get()->*method)();
+    }
+}
+
+void setAnimatedValueOnAllTargetProperties(const SVGElementAnimatedPropertyList& list, const QualifiedName& attributeName, PassRefPtr<NewSVGPropertyBase> passValue)
+{
+    RefPtr<NewSVGPropertyBase> value = passValue;
+
+    SVGElementAnimatedPropertyList::const_iterator it = list.begin();
+    SVGElementAnimatedPropertyList::const_iterator itEnd = list.end();
+    for (; it != itEnd; ++it) {
+        RefPtr<NewSVGAnimatedPropertyBase> animatedProperty = it->element->propertyFromAttribute(attributeName);
+        animatedProperty->setAnimatedValue(value);
+    }
+}
+
+}
+
+PassRefPtr<NewSVGPropertyBase> SVGAnimatedNewPropertyAnimator::resetAnimation(const SVGElementAnimatedPropertyList& list)
+{
+    ASSERT(m_animatedProperty);
+    RefPtr<NewSVGPropertyBase> animatedValue = m_animatedProperty->createAnimatedValue();
+    setAnimatedValueOnAllTargetProperties(list, m_animatedProperty->attributeName(), animatedValue);
+
+    return animatedValue.release();
+}
+
+PassOwnPtr<SVGAnimatedType> SVGAnimatedNewPropertyAnimator::startAnimValAnimation(const SVGElementAnimatedPropertyList& list)
 {
     SVGElementInstance::InstanceUpdateBlocker blocker(m_contextElement);
 
-    m_animatedProperty->animationStarted();
-    return SVGAnimatedType::createNewProperty(m_animatedProperty->currentValueBase());
+    ASSERT(m_animatedProperty);
+    invokeMethodOnAllTargetProperties(list, m_animatedProperty->attributeName(), &NewSVGAnimatedPropertyBase::animationStarted);
+
+    return SVGAnimatedType::createNewProperty(resetAnimation(list), m_propertyType);
 }
 
-void SVGAnimatedNewPropertyAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList&)
+void SVGAnimatedNewPropertyAnimator::stopAnimValAnimation(const SVGElementAnimatedPropertyList& list)
 {
     SVGElementInstance::InstanceUpdateBlocker blocker(m_contextElement);
 
-    m_animatedProperty->animationEnded();
+    ASSERT(m_animatedProperty);
+    invokeMethodOnAllTargetProperties(list, m_animatedProperty->attributeName(), &NewSVGAnimatedPropertyBase::animationEnded);
 }
 
-void SVGAnimatedNewPropertyAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList&, SVGAnimatedType* animated)
+void SVGAnimatedNewPropertyAnimator::resetAnimValToBaseVal(const SVGElementAnimatedPropertyList& list, SVGAnimatedType* animated)
 {
     SVGElementInstance::InstanceUpdateBlocker blocker(m_contextElement);
 
-    m_animatedProperty->resetToBaseVal();
-    animated->newProperty() = m_animatedProperty->currentValueBase();
+    animated->newProperty() = resetAnimation(list);
 }
 
-void SVGAnimatedNewPropertyAnimator::animValWillChange(const SVGElementAnimatedPropertyList&)
+void SVGAnimatedNewPropertyAnimator::animValWillChange(const SVGElementAnimatedPropertyList& list)
 {
     SVGElementInstance::InstanceUpdateBlocker blocker(m_contextElement);
 
-    m_animatedProperty->animValWillChange();
+    ASSERT(m_animatedProperty);
+    invokeMethodOnAllTargetProperties(list, m_animatedProperty->attributeName(), &NewSVGAnimatedPropertyBase::animValWillChange);
 }
 
-void SVGAnimatedNewPropertyAnimator::animValDidChange(const SVGElementAnimatedPropertyList&)
+void SVGAnimatedNewPropertyAnimator::animValDidChange(const SVGElementAnimatedPropertyList& list)
 {
     SVGElementInstance::InstanceUpdateBlocker blocker(m_contextElement);
 
-    m_animatedProperty->animValDidChange();
+    ASSERT(m_animatedProperty);
+    invokeMethodOnAllTargetProperties(list, m_animatedProperty->attributeName(), &NewSVGAnimatedPropertyBase::animValDidChange);
 }
 
 void SVGAnimatedNewPropertyAnimator::addAnimatedTypes(SVGAnimatedType* from, SVGAnimatedType* to)
 {
     to->newProperty()->add(from->newProperty(), m_contextElement);
 }
 
 class ParsePropertyFromString {
 public:
     explicit ParsePropertyFromString(SVGAnimatedNewPropertyAnimator* animator)
@@ skipping 31 matching lines @@
 float SVGAnimatedNewPropertyAnimator::calculateDistance(const String& fromString, const String& toString)
 {
     ASSERT(m_animationElement);
     ASSERT(m_contextElement);
     RefPtr<NewSVGPropertyBase> fromValue = createPropertyForAnimation(fromString);
     RefPtr<NewSVGPropertyBase> toValue = createPropertyForAnimation(toString);
     return fromValue->calculateDistance(toValue, m_contextElement);
 }
 
 } // namespace WebCore