Move handling of 'attributeType' to SVGAnimateElement

third_party/WebKit/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 47 matching lines @@
   return InheritValue;
 }
 
 }  // unnamed namespace
 
 SVGAnimateElement::SVGAnimateElement(const QualifiedName& tagName,
                                      Document& document)
     : SVGAnimationElement(tagName, document),
       m_animator(this),
       m_fromPropertyValueType(RegularPropertyValue),
-      m_toPropertyValueType(RegularPropertyValue) {}
+      m_toPropertyValueType(RegularPropertyValue),
+      m_attributeType(AttributeTypeAuto),
+      m_hasInvalidCSSAttributeType(false) {}
 
 SVGAnimateElement* SVGAnimateElement::create(Document& document) {
   return new SVGAnimateElement(SVGNames::animateTag, document);
 }
 
 SVGAnimateElement::~SVGAnimateElement() {}
 
 bool SVGAnimateElement::isSVGAnimationAttributeSettingJavaScriptURL(
     const Attribute& attribute) const {
   if ((attribute.name() == SVGNames::fromAttr ||
        attribute.name() == SVGNames::toAttr) &&
       attributeValueIsJavaScriptURL(attribute))
     return true;
 
   if (attribute.name() == SVGNames::valuesAttr) {
     Vector<String> parts;
     if (!parseValues(attribute.value(), parts)) {
       // Assume the worst.
       return true;
     }
     for (const auto& part : parts) {
       if (protocolIsJavaScript(part))
         return true;
     }
   }
 
   return SVGSMILElement::isSVGAnimationAttributeSettingJavaScriptURL(attribute);
 }
 
+void SVGAnimateElement::parseAttribute(const QualifiedName& name,
+                                       const AtomicString& oldValue,
+                                       const AtomicString& value) {
+  if (name == SVGNames::attributeTypeAttr) {
+    setAttributeType(value);
+    return;
+  }
+  SVGAnimationElement::parseAttribute(name, oldValue, value);
+}
+
+void SVGAnimateElement::svgAttributeChanged(const QualifiedName& attrName) {
+  if (attrName == SVGNames::attributeTypeAttr) {
+    animationAttributeChanged();
+    return;
+  }
+  SVGAnimationElement::svgAttributeChanged(attrName);
+}
+
 AnimatedPropertyType SVGAnimateElement::animatedPropertyType() {
   if (!targetElement())
     return AnimatedUnknown;
 
   m_animator.reset(targetElement());
   return m_animator.type();
 }
 
 bool SVGAnimateElement::hasValidAttributeType() {
   SVGElement* targetElement = this->targetElement();
@@ skipping 275 matching lines @@
   // FIXME: A return value of float is not enough to support paced animations on
   // lists.
   SVGPropertyBase* fromValue =
       m_animator.createPropertyForAnimation(fromString);
   SVGPropertyBase* toValue = m_animator.createPropertyForAnimation(toString);
   return fromValue->calculateDistance(toValue, targetElement());
 }
 
 void SVGAnimateElement::setTargetElement(SVGElement* target) {
   SVGAnimationElement::setTargetElement(target);
+  checkInvalidCSSAttributeType();
   resetAnimatedPropertyType();
 }
 
 void SVGAnimateElement::setAttributeName(const QualifiedName& attributeName) {
   SVGAnimationElement::setAttributeName(attributeName);
+  checkInvalidCSSAttributeType();
   resetAnimatedPropertyType();
 }
 
+void SVGAnimateElement::setAttributeType(const AtomicString& attributeType) {
+  if (attributeType == "CSS")
+    m_attributeType = AttributeTypeCSS;
+  else if (attributeType == "XML")
+    m_attributeType = AttributeTypeXML;
+  else
+    m_attributeType = AttributeTypeAuto;
+  checkInvalidCSSAttributeType();
+}
+
+void SVGAnimateElement::checkInvalidCSSAttributeType() {
+  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();
+}
+
 void SVGAnimateElement::resetAnimatedPropertyType() {
   ASSERT(!m_animatedProperty);
   m_fromProperty.clear();
   m_toProperty.clear();
   m_toAtEndOfDurationProperty.clear();
   m_animator.clear();
 }
 
 DEFINE_TRACE(SVGAnimateElement) {
   visitor->trace(m_fromProperty);
   visitor->trace(m_toProperty);
   visitor->trace(m_toAtEndOfDurationProperty);
   visitor->trace(m_animatedProperty);
   visitor->trace(m_animator);
   SVGAnimationElement::trace(visitor);
 }
 
 }  // namespace blink