Push animation value 'inherit' handling into 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.
  *
  * 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/SVGAnimatedTypeAnimator.h"
 #include "core/svg/properties/SVGProperty.h"
 
 namespace blink {
 
+namespace {
+
+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());
+
+  // Don't include any properties resulting from CSS Transitions/Animations or
+  // SMIL animations, as we want to retrieve the "base value".
+  element->setUseOverrideComputedStyle(true);
+  String value =
+      CSSComputedStyleDeclaration::create(element)->getPropertyValue(id);
+  element->setUseOverrideComputedStyle(false);
+  return value;
+}
+
+AnimatedPropertyValueType propertyValueType(const QualifiedName& attributeName,
+                                            const String& value) {
+  DEFINE_STATIC_LOCAL(const AtomicString, inherit, ("inherit"));
+  if (value.isEmpty() || value != inherit ||
+      !SVGElement::isAnimatableCSSProperty(attributeName))
+    return RegularPropertyValue;
+  return InheritValue;
+}
+
+}  // unnamed namespace
+
 SVGAnimateElement::SVGAnimateElement(const QualifiedName& tagName,
                                      Document& document)
-    : SVGAnimationElement(tagName, document), m_animator(this) {}
+    : SVGAnimationElement(tagName, document),
+      m_animator(this),
+      m_fromPropertyValueType(RegularPropertyValue),
+      m_toPropertyValueType(RegularPropertyValue) {}
 
 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 ||
@@ skipping 26 matching lines @@
 
 bool SVGAnimateElement::hasValidAttributeType() {
   SVGElement* targetElement = this->targetElement();
   if (!targetElement)
     return false;
 
   return animatedPropertyType() != AnimatedUnknown &&
          !hasInvalidCSSAttributeType();
 }
 
-namespace {
-
-class ParsePropertyFromString {
-  STACK_ALLOCATED();
-
- public:
-  explicit ParsePropertyFromString(SVGAnimatedTypeAnimator* animator)
-      : m_animator(animator) {}
-
-  SVGPropertyBase* operator()(SVGAnimationElement*, const String& value) {
-    return m_animator->createPropertyForAnimation(value);
-  }
-
- private:
-  SVGAnimatedTypeAnimator* m_animator;
-};
+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
+  // 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()));
+  return m_animator.createPropertyForAnimation(value);
 }
 
 void SVGAnimateElement::calculateAnimatedValue(float percentage,
                                                unsigned repeatCount,
                                                SVGSMILElement* resultElement) {
   ASSERT(resultElement);
   SVGElement* targetElement = this->targetElement();
   if (!targetElement || !isSVGAnimateElement(*resultElement))
     return;
 
@@ skipping 23 matching lines @@
   // 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;
 
   // Apply CSS inheritance rules.
-  ParsePropertyFromString parsePropertyFromString(&m_animator);
-  adjustForInheritance<SVGPropertyBase*, ParsePropertyFromString>(
-      parsePropertyFromString, fromPropertyValueType(), fromValue,
-      targetElement);
-  adjustForInheritance<SVGPropertyBase*, ParsePropertyFromString>(
-      parsePropertyFromString, toPropertyValueType(), toValue, targetElement);
+  fromValue = adjustForInheritance(fromValue, m_fromPropertyValueType);
+  toValue = adjustForInheritance(toValue, m_toPropertyValueType);
 
   animatedValue->calculateAnimatedValue(this, percentage, repeatCount,
                                         fromValue, toValue,
                                         toAtEndOfDurationValue, targetElement);
 }
 
 bool SVGAnimateElement::calculateToAtEndOfDurationValue(
     const String& toAtEndOfDurationString) {
   if (toAtEndOfDurationString.isEmpty())
     return false;
   m_toAtEndOfDurationProperty =
       m_animator.createPropertyForAnimation(toAtEndOfDurationString);
   return true;
 }
 
 bool SVGAnimateElement::calculateFromAndToValues(const String& fromString,
                                                  const String& toString) {
   SVGElement* targetElement = this->targetElement();
   if (!targetElement)
     return false;
 
-  determinePropertyValueTypes(fromString, toString);
   m_fromProperty = m_animator.createPropertyForAnimation(fromString);
+  m_fromPropertyValueType = propertyValueType(attributeName(), fromString);
   m_toProperty = m_animator.createPropertyForAnimation(toString);
+  m_toPropertyValueType = propertyValueType(attributeName(), toString);
   return true;
 }
 
 bool SVGAnimateElement::calculateFromAndByValues(const String& fromString,
                                                  const String& byString) {
   SVGElement* targetElement = this->targetElement();
   if (!targetElement)
     return false;
 
   if (getAnimationMode() == ByAnimation && !isAdditive())
     return false;
 
-  // from-by animation may only be used with attributes that support addition (e.g. most numeric attributes).
+  // from-by animation may only be used with attributes that support addition
+  // (e.g. most numeric attributes).
   if (getAnimationMode() == FromByAnimation &&
       !animatedPropertyTypeSupportsAddition())
     return false;
 
-  ASSERT(!isSVGSetElement(*this));
+  DCHECK(!isSVGSetElement(*this));
 
-  determinePropertyValueTypes(fromString, byString);
   m_fromProperty = m_animator.createPropertyForAnimation(fromString);
+  m_fromPropertyValueType = propertyValueType(attributeName(), fromString);
   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);
 
   ShouldApplyAnimationType shouldApply =
       shouldApplyAnimation(targetElement, attributeName);
   if (shouldApply == DontApplyAnimation)
     return;
   if (shouldApply == ApplyXMLAnimation ||
       shouldApply == ApplyXMLandCSSAnimation) {
     // SVG DOM animVal animation code-path.
     m_animatedProperty = m_animator.createAnimatedValue();
     targetElement->setAnimatedAttribute(attributeName, m_animatedProperty);
     return;
   }
   DCHECK_EQ(shouldApply, ApplyCSSAnimation);
 
   // CSS properties animation code-path.
-  String baseValue;
   DCHECK(isTargetAttributeCSSProperty(targetElement, attributeName));
-  computeCSSPropertyValue(targetElement,
-                          cssPropertyID(attributeName.localName()), baseValue);
-
+  String baseValue = computeCSSPropertyValue(
+      targetElement, cssPropertyID(attributeName.localName()));
   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.
+  // 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());
@@ skipping 18 matching lines @@
 
   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().
+  // Early exit if our animated type got destructed by a previous
+  // endedActiveInterval().
   if (!m_animatedProperty)
     return;
 
-  // We do update the style and the animation property independent of each other.
+  // 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()) {
     // CSS properties animation code-path.
-    // Convert the result of the animation to a String and apply it as CSS property on the target.
+    // 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))
       targetElement()->setNeedsStyleRecalc(
           LocalStyleChange,
           StyleChangeReasonForTracing::create(StyleChangeReason::Animation));
   }
   if (shouldApply == ApplyXMLandCSSAnimation ||
       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() {
-  // Spec: http://www.w3.org/TR/SVG/animate.html#AnimationAttributesAndProperties.
+  // http://www.w3.org/TR/SVG/animate.html#AnimationAttributesAndProperties.
   switch (animatedPropertyType()) {
     case AnimatedBoolean:
     case AnimatedEnumeration:
     case AnimatedPreserveAspectRatio:
     case AnimatedString:
     case AnimatedUnknown:
       return false;
     default:
       return true;
   }
 }
 
 bool SVGAnimateElement::isAdditive() {
   if (getAnimationMode() == ByAnimation ||
       getAnimationMode() == FromByAnimation) {
     if (!animatedPropertyTypeSupportsAddition())
       return false;
   }
 
   return SVGAnimationElement::isAdditive();
 }
 
 float SVGAnimateElement::calculateDistance(const String& fromString,
                                            const String& toString) {
-  // FIXME: A return value of float is not enough to support paced animations on lists.
+  // FIXME: A return value of float is not enough to support paced animations on
+  // lists.
   SVGElement* targetElement = this->targetElement();
   if (!targetElement)
     return -1;
   SVGPropertyBase* fromValue =
       m_animator.createPropertyForAnimation(fromString);
   SVGPropertyBase* toValue = m_animator.createPropertyForAnimation(toString);
   return fromValue->calculateDistance(toValue, targetElement);
 }
 
 void SVGAnimateElement::setTargetElement(SVGElement* target) {
@@ skipping 17 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