Move handling of 'attributeType' to SVGAnimateElement

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 19 matching lines @@
 #include "core/svg/SVGAnimateElement.h"
 #include "core/svg/SVGParserUtilities.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 SVGAnimationElement::SVGAnimationElement(const QualifiedName& tagName,
                                          Document& document)
     : SVGSMILElement(tagName, document),
       m_animationValid(false),
-      m_attributeType(AttributeTypeAuto),
-      m_hasInvalidCSSAttributeType(false),
       m_calcMode(CalcModeLinear),
       m_animationMode(NoAnimation) {
   ASSERT(RuntimeEnabledFeatures::smilEnabled());
   UseCounter::count(document, UseCounter::SVGAnimationElement);
 }
 
 bool SVGAnimationElement::parseValues(const String& value,
                                       Vector<String>& result) {
   // Per the SMIL specification, leading and trailing white space, and white
   // space before and after semicolon separators, is allowed and will be
@@ skipping 129 matching lines @@
     }
     return;
   }
 
   if (name == SVGNames::keySplinesAttr) {
     if (!parseKeySplines(value, m_keySplines))
       reportAttributeParsingError(SVGParseStatus::ParsingFailed, name, value);
     return;
   }
 
-  if (name == SVGNames::attributeTypeAttr) {
-    setAttributeType(value);
-    return;
-  }
-
   if (name == SVGNames::calcModeAttr) {
     setCalcMode(value);
     return;
   }
 
   if (name == SVGNames::fromAttr || name == SVGNames::toAttr ||
       name == SVGNames::byAttr) {
     updateAnimationMode();
     return;
   }
 
   SVGSMILElement::parseAttribute(name, oldValue, value);
 }
 
 void SVGAnimationElement::svgAttributeChanged(const QualifiedName& attrName) {
   if (attrName == SVGNames::valuesAttr || attrName == SVGNames::byAttr ||
       attrName == SVGNames::fromAttr || attrName == SVGNames::toAttr ||
       attrName == SVGNames::calcModeAttr ||
-      attrName == SVGNames::attributeTypeAttr ||
       attrName == SVGNames::keySplinesAttr ||
       attrName == SVGNames::keyPointsAttr ||
       attrName == SVGNames::keyTimesAttr) {
     animationAttributeChanged();
     return;
   }
 
   SVGSMILElement::svgAttributeChanged(attrName);
 }
 
@@ skipping 80 matching lines @@
     // else paced is the default.
     setCalcMode(CalcModePaced);
   } else if (calcMode == spline) {
     UseCounter::count(document(), UseCounter::SVGCalcModeSpline);
     setCalcMode(CalcModeSpline);
   } else
     setCalcMode(isSVGAnimateMotionElement(*this) ? CalcModePaced
                                                  : CalcModeLinear);
 }
 
-void SVGAnimationElement::setAttributeType(const AtomicString& attributeType) {
-  DEFINE_STATIC_LOCAL(const AtomicString, css, ("CSS"));
-  DEFINE_STATIC_LOCAL(const AtomicString, xml, ("XML"));
-  if (attributeType == css)
-    m_attributeType = AttributeTypeCSS;
-  else if (attributeType == xml)
-    m_attributeType = AttributeTypeXML;
-  else
-    m_attributeType = AttributeTypeAuto;
-  checkInvalidCSSAttributeType();
-}
-
 String SVGAnimationElement::toValue() const {
   return fastGetAttribute(SVGNames::toAttr);
 }
 
 String SVGAnimationElement::byValue() const {
   return fastGetAttribute(SVGNames::byAttr);
 }
 
 String SVGAnimationElement::fromValue() const {
   return fastGetAttribute(SVGNames::fromAttr);
@@ skipping 313 matching lines @@
     effectivePercent =
         calculatePercentForSpline(percent, calculateKeyTimesIndex(percent));
   else if (animationMode == FromToAnimation || animationMode == ToAnimation)
     effectivePercent = calculatePercentForFromTo(percent);
   else
     effectivePercent = percent;
 
   calculateAnimatedValue(effectivePercent, repeatCount, resultElement);
 }
 
-void SVGAnimationElement::setTargetElement(SVGElement* target) {
-  SVGSMILElement::setTargetElement(target);
-  checkInvalidCSSAttributeType();
-}
-
-void SVGAnimationElement::setAttributeName(const QualifiedName& attributeName) {
-  SVGSMILElement::setAttributeName(attributeName);
-  checkInvalidCSSAttributeType();
-}
-
-void SVGAnimationElement::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();
-}
-
 }  // namespace blink