Refactor CSS property mapping for SMIL Animation

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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/svg/SVGAnimateElement.h"
 
-#include "core/CSSPropertyNames.h"
 #include "core/css/CSSComputedStyleDeclaration.h"
 #include "core/css/StylePropertySet.h"
 #include "core/dom/Document.h"
 #include "core/dom/QualifiedName.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/svg/properties/SVGProperty.h"
 
 namespace blink {
 
 namespace {
 
-bool isTargetAttributeCSSProperty(SVGElement& targetElement,
+bool isTargetAttributeCSSProperty(const SVGElement& targetElement,
                                   const QualifiedName& attributeName) {
   return SVGElement::isAnimatableCSSProperty(attributeName) ||
          targetElement.isPresentationAttribute(attributeName);
 }
 
 String computeCSSPropertyValue(SVGElement* element, CSSPropertyID id) {
   DCHECK(element);
   // TODO(fs): StyleEngine doesn't support document without a frame.
   // Refer to comment in Element::computedStyle.
   DCHECK(element->inActiveDocument());
@@ skipping 70 matching lines @@
     animationAttributeChanged();
     return;
   }
   SVGAnimationElement::svgAttributeChanged(attrName);
 }
 
 AnimatedPropertyType SVGAnimateElement::animatedPropertyType() {
   if (!targetElement())
     return AnimatedUnknown;
 
-  m_animator.reset(targetElement());
+  m_animator.reset(*targetElement());
   return m_animator.type();
 }
 
 bool SVGAnimateElement::hasValidTarget() {
   return SVGAnimationElement::hasValidTarget() && hasValidAttributeName() &&
          hasValidAttributeType();
 }
 
 bool SVGAnimateElement::hasValidAttributeName() const {
   return attributeName() != anyQName();
 }
 
 bool SVGAnimateElement::hasValidAttributeType() {
   if (!targetElement())
     return false;
   return animatedPropertyType() != AnimatedUnknown &&
          !hasInvalidCSSAttributeType();
 }
 
-SVGAnimateElement::ShouldApplyAnimationType
-SVGAnimateElement::shouldApplyAnimation(SVGElement* targetElement,
-                                        const QualifiedName& attributeName) {
-  if (!hasValidTarget() || !targetElement->parentNode())
-    return DontApplyAnimation;
+bool SVGAnimateElement::shouldApplyAnimation(
+    const SVGElement& targetElement,
+    const QualifiedName& attributeName) {
+  if (!hasValidTarget() || !targetElement.parentNode())
+    return false;
 
   // Always animate CSS properties using the ApplyCSSAnimation code path,
   // regardless of the attributeType value.
-  if (isTargetAttributeCSSProperty(*targetElement, attributeName)) {
-    if (targetElement->isPresentationAttributeWithSVGDOM(attributeName))
-      return ApplyXMLandCSSAnimation;
+  if (isTargetAttributeCSSProperty(targetElement, attributeName))
+    return true;
 
-    return ApplyCSSAnimation;
-  }
   // If attributeType="CSS" and attributeName doesn't point to a CSS property,
   // ignore the animation.
-  if (getAttributeType() == AttributeTypeCSS)
-    return DontApplyAnimation;
-
-  return ApplyXMLAnimation;
+  return getAttributeType() != AttributeTypeCSS;
 }
 
 SVGPropertyBase* SVGAnimateElement::adjustForInheritance(
     SVGPropertyBase* propertyValue,
     AnimatedPropertyValueType valueType) const {
   if (valueType != InheritValue)
     return propertyValue;
   // TODO(fs): At the moment the computed style gets returned as a String and
-  // needs to get parsed again.  In the future we might want to work with the
+  // needs to get parsed again. In the future we might want to work with the
   // value type directly to avoid the String parsing.
   DCHECK(targetElement());
   Element* parent = targetElement()->parentElement();
   if (!parent || !parent->isSVGElement())
     return propertyValue;
   SVGElement* svgParent = toSVGElement(parent);
   // Replace 'inherit' by its computed property value.
-  String value = computeCSSPropertyValue(
-      svgParent, cssPropertyID(attributeName().localName()));
+  String value = computeCSSPropertyValue(svgParent, m_animator.cssProperty());
   return m_animator.createPropertyForAnimation(value);
 }
 
 void SVGAnimateElement::calculateAnimatedValue(float percentage,
                                                unsigned repeatCount,
                                                SVGSMILElement* resultElement) {
   DCHECK(resultElement);
   DCHECK(targetElement());
   if (!isSVGAnimateElement(*resultElement))
     return;
@@ skipping 13 matching lines @@
          animatedPropertyType());
 
   if (isSVGSetElement(*this))
     percentage = 1;
 
   if (getCalcMode() == CalcModeDiscrete)
     percentage = percentage < 0.5 ? 0 : 1;
 
   // Target element might have changed.
   SVGElement* targetElement = this->targetElement();
-  m_animator.setContextElement(targetElement);
 
   // Values-animation accumulates using the last values entry corresponding to
   // the end of duration time.
   SVGPropertyBase* animatedValue = resultAnimationElement->m_animatedProperty;
   SVGPropertyBase* toAtEndOfDurationValue =
       m_toAtEndOfDurationProperty ? m_toAtEndOfDurationProperty : m_toProperty;
   SVGPropertyBase* fromValue =
       getAnimationMode() == ToAnimation ? animatedValue : m_fromProperty.get();
   SVGPropertyBase* toValue = m_toProperty;
 
@@ skipping 45 matching lines @@
   m_toProperty = m_animator.createPropertyForAnimation(byString);
   m_toPropertyValueType = propertyValueType(attributeName(), byString);
   m_toProperty->add(m_fromProperty, targetElement());
   return true;
 }
 
 void SVGAnimateElement::resetAnimatedType() {
   SVGElement* targetElement = this->targetElement();
   const QualifiedName& attributeName = this->attributeName();
 
-  m_animator.reset(targetElement);
+  m_animator.reset(*targetElement);
 
-  ShouldApplyAnimationType shouldApply =
-      shouldApplyAnimation(targetElement, attributeName);
-  if (shouldApply == DontApplyAnimation)
+  if (!shouldApplyAnimation(*targetElement, attributeName))
     return;
-  if (shouldApply == ApplyXMLAnimation ||
-      shouldApply == ApplyXMLandCSSAnimation) {
+  if (m_animator.isAnimatingSVGDom()) {
     // SVG DOM animVal animation code-path.
     m_animatedProperty = m_animator.createAnimatedValue();
     targetElement->setAnimatedAttribute(attributeName, m_animatedProperty);
     return;
   }
-  DCHECK_EQ(shouldApply, ApplyCSSAnimation);
+  DCHECK(m_animator.isAnimatingCSSProperty());
+  // Presentation attributes which has an SVG DOM representation should use the
+  // "SVG DOM" code-path (above.)
+  DCHECK(SVGElement::isAnimatableCSSProperty(attributeName));
 
   // CSS properties animation code-path.
-  DCHECK(isTargetAttributeCSSProperty(*targetElement, attributeName));
-  String baseValue = computeCSSPropertyValue(
-      targetElement, cssPropertyID(attributeName.localName()));
+  String baseValue =
+      computeCSSPropertyValue(targetElement, m_animator.cssProperty());
   m_animatedProperty = m_animator.createPropertyForAnimation(baseValue);
 }
 
 void SVGAnimateElement::clearAnimatedType() {
   if (!m_animatedProperty)
     return;
 
   // The animated property lock is held for the "result animation" (see
   // SMILTimeContainer::updateAnimations()) while we're processing an animation
   // group. We will very likely crash later if we clear the animated type while
   // the lock is held. See crbug.com/581546.
   DCHECK(!animatedTypeIsLocked());
 
   SVGElement* targetElement = this->targetElement();
   if (!targetElement) {
     m_animatedProperty.clear();
     return;
   }
 
-  ShouldApplyAnimationType shouldApply =
-      shouldApplyAnimation(targetElement, attributeName());
-  if (shouldApply == ApplyXMLandCSSAnimation ||
-      m_animator.isAnimatingCSSProperty()) {
+  bool shouldApply = shouldApplyAnimation(*targetElement, attributeName());
+  if (m_animator.isAnimatingCSSProperty()) {
     // CSS properties animation code-path.
-    if (shouldApply != DontApplyAnimation) {
-      CSSPropertyID id = cssPropertyID(attributeName().localName());
-      targetElement->ensureAnimatedSMILStyleProperties()->removeProperty(id);
-      targetElement->setNeedsStyleRecalc(
-          LocalStyleChange,
-          StyleChangeReasonForTracing::create(StyleChangeReason::Animation));
+    if (shouldApply) {
+      MutableStylePropertySet* propertySet =
+          targetElement->ensureAnimatedSMILStyleProperties();
+      if (propertySet->removeProperty(m_animator.cssProperty())) {
+        targetElement->setNeedsStyleRecalc(
+            LocalStyleChange,
+            StyleChangeReasonForTracing::create(StyleChangeReason::Animation));
+      }
     }
   }
-  if (shouldApply == ApplyXMLandCSSAnimation ||
-      m_animator.isAnimatingSVGDom()) {
+  if (m_animator.isAnimatingSVGDom()) {
     // SVG DOM animVal animation code-path.
     targetElement->clearAnimatedAttribute(attributeName());
-    if (shouldApply != DontApplyAnimation)
+    if (shouldApply)
       targetElement->invalidateAnimatedAttribute(attributeName());
   }
 
   m_animatedProperty.clear();
   m_animator.clear();
 }
 
 void SVGAnimateElement::applyResultsToTarget() {
   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 (!shouldApplyAnimation(*targetElement(), attributeName()))
+    return;
+
   // We do update the style and the animation property independent of each
   // other.
-  ShouldApplyAnimationType shouldApply =
-      shouldApplyAnimation(targetElement(), attributeName());
-  if (shouldApply == DontApplyAnimation)
-    return;
-  if (shouldApply == ApplyXMLandCSSAnimation ||
-      m_animator.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.
-    CSSPropertyID id = cssPropertyID(attributeName().localName());
     MutableStylePropertySet* propertySet =
         targetElement()->ensureAnimatedSMILStyleProperties();
-    if (propertySet->setProperty(id, m_animatedProperty->valueAsString(), false,
-                                 0))
+    if (propertySet->setProperty(m_animator.cssProperty(),
+                                 m_animatedProperty->valueAsString(), false,
+                                 0)) {
       targetElement()->setNeedsStyleRecalc(
           LocalStyleChange,
           StyleChangeReasonForTracing::create(StyleChangeReason::Animation));
+    }
   }
-  if (shouldApply == ApplyXMLandCSSAnimation ||
-      m_animator.isAnimatingSVGDom()) {
+  if (m_animator.isAnimatingSVGDom()) {
     // 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.
     targetElement()->invalidateAnimatedAttribute(attributeName());
   }
 }
 
 bool SVGAnimateElement::animatedPropertyTypeSupportsAddition() {
   // http://www.w3.org/TR/SVG/animate.html#AnimationAttributesAndProperties.
   switch (animatedPropertyType()) {
@@ skipping 83 matching lines @@
 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