SVG Web Animations: Add SVGInterpolationType pipeline

third_party/WebKit/Source/core/animation/StringKeyframe.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/animation/StringKeyframe.h"
 
+#include "core/XLinkNames.h"
 #include "core/animation/AngleSVGInterpolation.h"
 #include "core/animation/CSSColorInterpolationType.h"
 #include "core/animation/CSSImageInterpolationType.h"
 #include "core/animation/CSSImageListInterpolationType.h"
 #include "core/animation/CSSLengthInterpolationType.h"
 #include "core/animation/CSSNumberInterpolationType.h"
 #include "core/animation/CSSPaintInterpolationType.h"
 #include "core/animation/CSSShadowListInterpolationType.h"
 #include "core/animation/CSSValueInterpolationType.h"
 #include "core/animation/CompositorAnimations.h"
@@ skipping 13 matching lines @@
 #include "core/animation/LengthSVGInterpolation.h"
 #include "core/animation/LengthStyleInterpolation.h"
 #include "core/animation/ListSVGInterpolation.h"
 #include "core/animation/ListStyleInterpolation.h"
 #include "core/animation/NumberOptionalNumberSVGInterpolation.h"
 #include "core/animation/NumberSVGInterpolation.h"
 #include "core/animation/PathSVGInterpolation.h"
 #include "core/animation/PointSVGInterpolation.h"
 #include "core/animation/RectSVGInterpolation.h"
 #include "core/animation/SVGStrokeDasharrayStyleInterpolation.h"
+#include "core/animation/SVGValueInterpolationType.h"
 #include "core/animation/TransformSVGInterpolation.h"
 #include "core/animation/VisibilityStyleInterpolation.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/style/ComputedStyle.h"
 #include "core/svg/SVGElement.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
@@ skipping 72 matching lines @@
     if (!baseStyle && (!m_value || DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(*m_value)))
         return false;
     if (!element.document().frame())
         return false;
     m_animatableValueCache = StyleResolver::createAnimatableValueSnapshot(element, baseStyle, property, m_value.get());
     return true;
 }
 
 namespace {
 
-const Vector<const InterpolationType*>* applicableTypesForProperty(CSSPropertyID property)
+// TODO(alancutter): Move this into its own file.
+const Vector<const InterpolationType*>* applicableTypesForProperty(PropertyHandle property)
 {
-    using ApplicableTypesMap = HashMap<CSSPropertyID, const Vector<const InterpolationType*>*>;
+    // TODO(alancutter): Initialise this entire HashMap once instead of initialising each property individually.
+    using ApplicableTypesMap = HashMap<PropertyHandle, const Vector<const InterpolationType*>*>;
     DEFINE_STATIC_LOCAL(ApplicableTypesMap, applicableTypesMap, ());
     auto entry = applicableTypesMap.find(property);
     if (entry != applicableTypesMap.end())
         return entry->value;
 
+    bool fallbackToLegacy = false;
     auto applicableTypes = new Vector<const InterpolationType*>();
-    switch (property) {
-    case CSSPropertyBaselineShift:
-    case CSSPropertyBorderBottomWidth:
-    case CSSPropertyBorderLeftWidth:
-    case CSSPropertyBorderRightWidth:
-    case CSSPropertyBorderTopWidth:
-    case CSSPropertyBottom:
-    case CSSPropertyCx:
-    case CSSPropertyCy:
-    case CSSPropertyFlexBasis:
-    case CSSPropertyHeight:
-    case CSSPropertyLeft:
-    case CSSPropertyLetterSpacing:
-    case CSSPropertyMarginBottom:
-    case CSSPropertyMarginLeft:
-    case CSSPropertyMarginRight:
-    case CSSPropertyMarginTop:
-    case CSSPropertyMaxHeight:
-    case CSSPropertyMaxWidth:
-    case CSSPropertyMinHeight:
-    case CSSPropertyMinWidth:
-    case CSSPropertyMotionOffset:
-    case CSSPropertyOutlineOffset:
-    case CSSPropertyOutlineWidth:
-    case CSSPropertyPaddingBottom:
-    case CSSPropertyPaddingLeft:
-    case CSSPropertyPaddingRight:
-    case CSSPropertyPaddingTop:
-    case CSSPropertyPerspective:
-    case CSSPropertyR:
-    case CSSPropertyRight:
-    case CSSPropertyRx:
-    case CSSPropertyRy:
-    case CSSPropertyShapeMargin:
-    case CSSPropertyStrokeDashoffset:
-    case CSSPropertyStrokeWidth:
-    case CSSPropertyTop:
-    case CSSPropertyVerticalAlign:
-    case CSSPropertyWebkitBorderHorizontalSpacing:
-    case CSSPropertyWebkitBorderVerticalSpacing:
-    case CSSPropertyWebkitColumnGap:
-    case CSSPropertyWebkitColumnRuleWidth:
-    case CSSPropertyWebkitColumnWidth:
-    case CSSPropertyWebkitPerspectiveOriginX:
-    case CSSPropertyWebkitPerspectiveOriginY:
-    case CSSPropertyWebkitTransformOriginX:
-    case CSSPropertyWebkitTransformOriginY:
-    case CSSPropertyWebkitTransformOriginZ:
-    case CSSPropertyWidth:
-    case CSSPropertyWordSpacing:
-    case CSSPropertyX:
-    case CSSPropertyY:
-        applicableTypes->append(new CSSLengthInterpolationType(property));
-        break;
-    case CSSPropertyFlexGrow:
-    case CSSPropertyFlexShrink:
-    case CSSPropertyFillOpacity:
-    case CSSPropertyFloodOpacity:
-    case CSSPropertyFontSizeAdjust:
-    case CSSPropertyOpacity:
-    case CSSPropertyOrphans:
-    case CSSPropertyShapeImageThreshold:
-    case CSSPropertyStopOpacity:
-    case CSSPropertyStrokeMiterlimit:
-    case CSSPropertyStrokeOpacity:
-    case CSSPropertyWebkitColumnCount:
-    case CSSPropertyWidows:
-    case CSSPropertyZIndex:
-        applicableTypes->append(new CSSNumberInterpolationType(property));
-        break;
-    case CSSPropertyLineHeight:
-        applicableTypes->append(new CSSLengthInterpolationType(property));
-        applicableTypes->append(new CSSNumberInterpolationType(property));
-        break;
-    case CSSPropertyBackgroundColor:
-    case CSSPropertyBorderBottomColor:
-    case CSSPropertyBorderLeftColor:
-    case CSSPropertyBorderRightColor:
-    case CSSPropertyBorderTopColor:
-    case CSSPropertyColor:
-    case CSSPropertyFloodColor:
-    case CSSPropertyLightingColor:
-    case CSSPropertyOutlineColor:
-    case CSSPropertyStopColor:
-    case CSSPropertyTextDecorationColor:
-    case CSSPropertyWebkitColumnRuleColor:
-    case CSSPropertyWebkitTextStrokeColor:
-        applicableTypes->append(new CSSColorInterpolationType(property));
-        break;
-    case CSSPropertyFill:
-    case CSSPropertyStroke:
-        applicableTypes->append(new CSSPaintInterpolationType(property));
-        break;
-    case CSSPropertyBoxShadow:
-    case CSSPropertyTextShadow:
-        applicableTypes->append(new CSSShadowListInterpolationType(property));
-        break;
-    case CSSPropertyBorderImageSource:
-    case CSSPropertyListStyleImage:
-    case CSSPropertyWebkitMaskBoxImageSource:
-        applicableTypes->append(new CSSImageInterpolationType(property));
-        break;
-    case CSSPropertyBackgroundImage:
-    case CSSPropertyWebkitMaskImage:
-        applicableTypes->append(new CSSImageListInterpolationType(property));
-        break;
-    default:
-        // TODO(alancutter): Support all interpolable CSS properties here so we can stop falling back to the old StyleInterpolation implementation.
-        if (CSSPropertyMetadata::isInterpolableProperty(property)) {
-            delete applicableTypes;
-            applicableTypesMap.add(property, nullptr);
-            return nullptr;
+
+    if (property.isCSSProperty()) {
+        CSSPropertyID cssProperty = property.cssProperty();
+        switch (cssProperty) {
+        case CSSPropertyBaselineShift:
+        case CSSPropertyBorderBottomWidth:
+        case CSSPropertyBorderLeftWidth:
+        case CSSPropertyBorderRightWidth:
+        case CSSPropertyBorderTopWidth:
+        case CSSPropertyBottom:
+        case CSSPropertyCx:
+        case CSSPropertyCy:
+        case CSSPropertyFlexBasis:
+        case CSSPropertyHeight:
+        case CSSPropertyLeft:
+        case CSSPropertyLetterSpacing:
+        case CSSPropertyMarginBottom:
+        case CSSPropertyMarginLeft:
+        case CSSPropertyMarginRight:
+        case CSSPropertyMarginTop:
+        case CSSPropertyMaxHeight:
+        case CSSPropertyMaxWidth:
+        case CSSPropertyMinHeight:
+        case CSSPropertyMinWidth:
+        case CSSPropertyMotionOffset:
+        case CSSPropertyOutlineOffset:
+        case CSSPropertyOutlineWidth:
+        case CSSPropertyPaddingBottom:
+        case CSSPropertyPaddingLeft:
+        case CSSPropertyPaddingRight:
+        case CSSPropertyPaddingTop:
+        case CSSPropertyPerspective:
+        case CSSPropertyR:
+        case CSSPropertyRight:
+        case CSSPropertyRx:
+        case CSSPropertyRy:
+        case CSSPropertyShapeMargin:
+        case CSSPropertyStrokeDashoffset:
+        case CSSPropertyStrokeWidth:
+        case CSSPropertyTop:
+        case CSSPropertyVerticalAlign:
+        case CSSPropertyWebkitBorderHorizontalSpacing:
+        case CSSPropertyWebkitBorderVerticalSpacing:
+        case CSSPropertyWebkitColumnGap:
+        case CSSPropertyWebkitColumnRuleWidth:
+        case CSSPropertyWebkitColumnWidth:
+        case CSSPropertyWebkitPerspectiveOriginX:
+        case CSSPropertyWebkitPerspectiveOriginY:
+        case CSSPropertyWebkitTransformOriginX:
+        case CSSPropertyWebkitTransformOriginY:
+        case CSSPropertyWebkitTransformOriginZ:
+        case CSSPropertyWidth:
+        case CSSPropertyWordSpacing:
+        case CSSPropertyX:
+        case CSSPropertyY:
+            applicableTypes->append(new CSSLengthInterpolationType(cssProperty));
+            break;
+        case CSSPropertyFlexGrow:
+        case CSSPropertyFlexShrink:
+        case CSSPropertyFillOpacity:
+        case CSSPropertyFloodOpacity:
+        case CSSPropertyFontSizeAdjust:
+        case CSSPropertyOpacity:
+        case CSSPropertyOrphans:
+        case CSSPropertyShapeImageThreshold:
+        case CSSPropertyStopOpacity:
+        case CSSPropertyStrokeMiterlimit:
+        case CSSPropertyStrokeOpacity:
+        case CSSPropertyWebkitColumnCount:
+        case CSSPropertyWidows:
+        case CSSPropertyZIndex:
+            applicableTypes->append(new CSSNumberInterpolationType(cssProperty));
+            break;
+        case CSSPropertyLineHeight:
+            applicableTypes->append(new CSSLengthInterpolationType(cssProperty));
+            applicableTypes->append(new CSSNumberInterpolationType(cssProperty));
+            break;
+        case CSSPropertyBackgroundColor:
+        case CSSPropertyBorderBottomColor:
+        case CSSPropertyBorderLeftColor:
+        case CSSPropertyBorderRightColor:
+        case CSSPropertyBorderTopColor:
+        case CSSPropertyColor:
+        case CSSPropertyFloodColor:
+        case CSSPropertyLightingColor:
+        case CSSPropertyOutlineColor:
+        case CSSPropertyStopColor:
+        case CSSPropertyTextDecorationColor:
+        case CSSPropertyWebkitColumnRuleColor:
+        case CSSPropertyWebkitTextStrokeColor:
+            applicableTypes->append(new CSSColorInterpolationType(cssProperty));
+            break;
+        case CSSPropertyFill:
+        case CSSPropertyStroke:
+            applicableTypes->append(new CSSPaintInterpolationType(cssProperty));
+            break;
+        case CSSPropertyBoxShadow:
+        case CSSPropertyTextShadow:
+            applicableTypes->append(new CSSShadowListInterpolationType(cssProperty));
+            break;
+        case CSSPropertyBorderImageSource:
+        case CSSPropertyListStyleImage:
+        case CSSPropertyWebkitMaskBoxImageSource:
+            applicableTypes->append(new CSSImageInterpolationType(cssProperty));
+            break;
+        case CSSPropertyBackgroundImage:
+        case CSSPropertyWebkitMaskImage:
+            applicableTypes->append(new CSSImageListInterpolationType(cssProperty));
+            break;
+        default:
+            // TODO(alancutter): Support all interpolable CSS properties here so we can stop falling back to the old StyleInterpolation implementation.
+            if (CSSPropertyMetadata::isInterpolableProperty(cssProperty))
+                fallbackToLegacy = true;
+            break;
         }
-        break;
+        applicableTypes->append(new CSSValueInterpolationType(cssProperty));
+    } else {
+        const QualifiedName& attribute = property.svgAttribute();
+        if (attribute == HTMLNames::classAttr
+            || attribute == SVGNames::clipPathUnitsAttr
+            || attribute == SVGNames::edgeModeAttr
+            || attribute == SVGNames::filterUnitsAttr
+            || attribute == SVGNames::gradientUnitsAttr
+            || attribute == SVGNames::inAttr
+            || attribute == SVGNames::in2Attr
+            || attribute == SVGNames::lengthAdjustAttr
+            || attribute == SVGNames::markerUnitsAttr
+            || attribute == SVGNames::maskContentUnitsAttr
+            || attribute == SVGNames::maskUnitsAttr
+            || attribute == SVGNames::methodAttr
+            || attribute == SVGNames::modeAttr
+            || attribute == SVGNames::operatorAttr
+            || attribute == SVGNames::patternContentUnitsAttr
+            || attribute == SVGNames::patternUnitsAttr
+            || attribute == SVGNames::preserveAlphaAttr
+            || attribute == SVGNames::preserveAspectRatioAttr
+            || attribute == SVGNames::primitiveUnitsAttr
+            || attribute == SVGNames::resultAttr
+            || attribute == SVGNames::spacingAttr
+            || attribute == SVGNames::spreadMethodAttr
+            || attribute == SVGNames::stitchTilesAttr
+            || attribute == SVGNames::targetAttr
+            || attribute == SVGNames::typeAttr
+            || attribute == SVGNames::xChannelSelectorAttr
+            || attribute == SVGNames::yChannelSelectorAttr
+            || attribute == XLinkNames::hrefAttr) {
+            applicableTypes->append(new SVGValueInterpolationType(attribute));
+        } else {
+            fallbackToLegacy = true;
+        }
     }
-    applicableTypes->append(new CSSValueInterpolationType(property));
+
+    if (fallbackToLegacy) {
+        delete applicableTypes;
+        applicableTypesMap.add(property, nullptr);
+        return nullptr;
+    }
+
     applicableTypesMap.add(property, applicableTypes);
     return applicableTypes;
 }
 
 } // namespace
 
 PassRefPtr<Interpolation> StringKeyframe::CSSPropertySpecificKeyframe::createLegacyStyleInterpolation(CSSPropertyID property, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle) const
 {
     CSSValue& fromCSSValue = *m_value.get();
     CSSValue& toCSSValue = *toCSSPropertySpecificKeyframe(end).value();
     if (DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(fromCSSValue) || DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(toCSSValue)) {
         // FIXME: Handle these cases outside of DeferredLegacyStyleInterpolation.
         return DeferredLegacyStyleInterpolation::create(&fromCSSValue, &toCSSValue, property);
     }
 
     // FIXME: Remove the use of AnimatableValues and Elements here.
     ASSERT(element);
     populateAnimatableValue(property, *element, baseStyle, false);
     end.populateAnimatableValue(property, *element, baseStyle, false);
     return LegacyStyleInterpolation::create(getAnimatableValue(), end.getAnimatableValue(), property);
 }
 
 PassRefPtr<Interpolation> StringKeyframe::CSSPropertySpecificKeyframe::maybeCreateInterpolation(PropertyHandle propertyHandle, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle) const
 {
-    CSSPropertyID property = propertyHandle.cssProperty();
-    const Vector<const InterpolationType*>* applicableTypes = applicableTypesForProperty(property);
+    const Vector<const InterpolationType*>* applicableTypes = applicableTypesForProperty(propertyHandle);
     if (applicableTypes)
         return InvalidatableInterpolation::create(*applicableTypes, *this, end);
 
     // TODO(alancutter): Remove the remainder of this function.
 
     // FIXME: Refactor this into a generic piece that lives in InterpolationEffect, and a template parameter specific converter.
+    CSSPropertyID property = propertyHandle.cssProperty();
     CSSValue* fromCSSValue = m_value.get();
     CSSValue* toCSSValue = toCSSPropertySpecificKeyframe(end).value();
     InterpolationRange range = RangeAll;
 
     // FIXME: Remove this flag once we can rely on legacy's behaviour being correct.
     bool forceDefaultInterpolation = false;
 
     // FIXME: Remove this check once neutral keyframes are implemented in StringKeyframes.
     if (!fromCSSValue || !toCSSValue)
         return DeferredLegacyStyleInterpolation::create(fromCSSValue, toCSSValue, property);
@@ skipping 220 matching lines @@
     if (interpolation)
         return interpolation.release();
 
     return DefaultSVGInterpolation::create(fromValue, toValue, attribute);
 }
 
 } // namespace
 
 PassRefPtr<Interpolation> SVGPropertySpecificKeyframe::maybeCreateInterpolation(PropertyHandle propertyHandle, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle) const
 {
+    const Vector<const InterpolationType*>* applicableTypes = applicableTypesForProperty(propertyHandle);
+    if (applicableTypes)
+        return InvalidatableInterpolation::create(*applicableTypes, *this, end);
+
     ASSERT(element);
     RefPtrWillBeRawPtr<SVGAnimatedPropertyBase> attribute = toSVGElement(element)->propertyFromAttribute(propertyHandle.svgAttribute());
     ASSERT(attribute);
 
     RefPtrWillBeRawPtr<SVGPropertyBase> fromValue = attribute->currentValueBase()->cloneForAnimation(m_value);
     RefPtrWillBeRawPtr<SVGPropertyBase> toValue = attribute->currentValueBase()->cloneForAnimation(toSVGPropertySpecificKeyframe(end).value());
 
     if (!fromValue || !toValue)
         return nullptr;
 
     return createSVGInterpolation(fromValue.get(), toValue.get(), attribute.get());
 }
 
 } // namespace blink