Add foundation for removing AnimatableValues from StyleInterpolation

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/animation/AngleSVGInterpolation.h"
+#include "core/animation/AnimationType.h"
 #include "core/animation/ColorStyleInterpolation.h"
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/ConstantStyleInterpolation.h"
+#include "core/animation/DefaultAnimationType.h"
 #include "core/animation/DefaultSVGInterpolation.h"
 #include "core/animation/DeferredLegacyStyleInterpolation.h"
 #include "core/animation/DoubleStyleInterpolation.h"
 #include "core/animation/FilterStyleInterpolation.h"
 #include "core/animation/ImageSliceStyleInterpolation.h"
 #include "core/animation/ImageStyleInterpolation.h"
 #include "core/animation/IntegerOptionalIntegerSVGInterpolation.h"
 #include "core/animation/IntegerSVGInterpolation.h"
+#include "core/animation/InvalidatableStyleInterpolation.h"
 #include "core/animation/LegacyStyleInterpolation.h"
 #include "core/animation/LengthBoxStyleInterpolation.h"
 #include "core/animation/LengthPairStyleInterpolation.h"
 #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"
@@ skipping 51 matching lines @@
         properties.add(PropertyHandle(*key));
 
     return properties;
 }
 
 PassRefPtrWillBeRawPtr<Keyframe> StringKeyframe::clone() const
 {
     return adoptRefWillBeNoop(new StringKeyframe(*this));
 }
 
-PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::createPropertySpecificKeyframe(PropertyHandle property) const
+PassRefPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::createPropertySpecificKeyframe(PropertyHandle property) const
 {
     if (property.isCSSProperty())
-        return adoptPtrWillBeNoop(new CSSPropertySpecificKeyframe(offset(), &easing(), cssPropertyValue(property.cssProperty()), composite()));
+        return adoptRefWillBeNoop(new CSSPropertySpecificKeyframe(offset(), &easing(), cssPropertyValue(property.cssProperty()), composite()));
 
     ASSERT(property.isSVGAttribute());
-    return adoptPtrWillBeNoop(new SVGPropertySpecificKeyframe(offset(), &easing(), svgPropertyValue(*property.svgAttribute()), composite()));
+    return adoptRefWillBeNoop(new SVGPropertySpecificKeyframe(offset(), &easing(), svgPropertyValue(*property.svgAttribute()), composite()));
 }
 
 DEFINE_TRACE(StringKeyframe)
 {
     visitor->trace(m_propertySet);
     Keyframe::trace(visitor);
 }
 
 StringKeyframe::CSSPropertySpecificKeyframe::CSSPropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, CSSValue* value, EffectModel::CompositeOperation op)
     : Keyframe::PropertySpecificKeyframe(offset, easing, op)
@@ skipping 35 matching lines @@
     case CSSPropertyStrokeMiterlimit:
         return RangeGreaterThanOrEqualToOne;
     case CSSPropertyFontSizeAdjust:
         return RangeNonNegative;
     default:
         ASSERT_NOT_REACHED();
         return RangeAll;
     }
 }
 
+const Vector<const AnimationType*>* applicableTypesForProperty(CSSPropertyID property)

[shans, 2015/05/28 05:48:14]

This can be deferred until we support anything that isAnimatableProperty.

[alancutter (OOO until 2018), 2015/06/01 07:35:29]

This code serves the AnimationTypes as per property singleton objects in line
with the overall design. This will allow different Interpolations to determine
whether they can composite together or not by sharing the same AnimationType
object between them.

Unfortunately it can't be replaced with something simple like
    if (!isAnimatableProperty(property))
        return InvalidatableStyleInterpolation::create(...);
because this is missing an owner of the AnimationType object. Adding one would
bring us back to the code that's currently here or something equally lengthy
that goes against the memory model that AnimationTypes have been designed for.

+{
+    using ApplicableTypesMap = HashMap<CSSPropertyID, const Vector<const AnimationType*>*>;
+    DEFINE_STATIC_LOCAL(ApplicableTypesMap, applicableTypesMap, ());
+    if (applicableTypesMap.contains(property))
+        return applicableTypesMap.get(property);
+
+    // TODO(alancutter): Support all animatable CSS properties here so we can stop falling back to the old StyleInterpolation implementation.
+    if (CSSPropertyMetadata::isAnimatableProperty(property))
+        return nullptr;
+
+    auto applicableTypes = new Vector<const AnimationType*>();
+    applicableTypes->append(new DefaultAnimationType(property));
+    applicableTypesMap.add(property, applicableTypes);
+    return applicableTypes;
+}
+
 } // namespace
 
-PassRefPtrWillBeRawPtr<Interpolation> StringKeyframe::CSSPropertySpecificKeyframe::maybeCreateInterpolation(PropertyHandle propertyHandle, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle) const
+PassRefPtrWillBeRawPtr<Interpolation> StringKeyframe::CSSPropertySpecificKeyframe::maybeCreateInterpolation(PropertyHandle propertyHandle, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle)
 {
     CSSPropertyID property = propertyHandle.cssProperty();
+    const Vector<const AnimationType*>* applicableTypes = applicableTypesForProperty(property);
+    if (applicableTypes)
+        return InvalidatableStyleInterpolation::create(*applicableTypes, this, toCSSPropertySpecificKeyframe(&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.
     CSSValue* fromCSSValue = m_value.get();
     CSSValue* toCSSValue = toCSSPropertySpecificKeyframe(end).value();
     InterpolationRange range = RangeAll;
     bool fallBackToLegacy = false;
 
     // 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);
 
     ASSERT(fromCSSValue && toCSSValue);
 
     if (!CSSPropertyMetadata::isAnimatableProperty(property)) {
         if (fromCSSValue == toCSSValue)
             return ConstantStyleInterpolation::create(fromCSSValue, property);
 
         return nullptr;
     }
 
-    // FIXME: Generate this giant switch statement.
     switch (property) {
     case CSSPropertyLineHeight:
         if (LengthStyleInterpolation::canCreateFrom(*fromCSSValue) && LengthStyleInterpolation::canCreateFrom(*toCSSValue))
             return LengthStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, RangeNonNegative);
 
         if (DoubleStyleInterpolation::canCreateFrom(*fromCSSValue) && DoubleStyleInterpolation::canCreateFrom(*toCSSValue))
             return DoubleStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, CSSPrimitiveValue::CSS_NUMBER, RangeNonNegative);
 
         break;
     case CSSPropertyBorderBottomWidth:
@@ skipping 239 matching lines @@
     }
 
     ASSERT(AnimatableValue::usesDefaultInterpolation(
         StyleResolver::createAnimatableValueSnapshot(*element, baseStyle, property, fromCSSValue).get(),
         StyleResolver::createAnimatableValueSnapshot(*element, baseStyle, property, toCSSValue).get()));
 
     return nullptr;
 
 }
 
-PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::CSSPropertySpecificKeyframe::neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const
+PassRefPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::CSSPropertySpecificKeyframe::neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const
 {
-    return adoptPtrWillBeNoop(new CSSPropertySpecificKeyframe(offset, easing, static_cast<CSSValue*>(0), EffectModel::CompositeAdd));
+    return adoptRefWillBeNoop(new CSSPropertySpecificKeyframe(offset, easing, static_cast<CSSValue*>(0), EffectModel::CompositeAdd));
 }
 
-PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::CSSPropertySpecificKeyframe::cloneWithOffset(double offset) const
+PassRefPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::CSSPropertySpecificKeyframe::cloneWithOffset(double offset) const
 {
     Keyframe::PropertySpecificKeyframe* theClone = new CSSPropertySpecificKeyframe(offset, m_easing, m_value.get());
     toCSSPropertySpecificKeyframe(theClone)->m_animatableValueCache = m_animatableValueCache;
-    return adoptPtrWillBeNoop(theClone);
+    return adoptRefWillBeNoop(theClone);
 }
 
 DEFINE_TRACE(StringKeyframe::CSSPropertySpecificKeyframe)
 {
     visitor->trace(m_value);
     visitor->trace(m_animatableValueCache);
     Keyframe::PropertySpecificKeyframe::trace(visitor);
 }
 
 SVGPropertySpecificKeyframe::SVGPropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, const String& value, EffectModel::CompositeOperation op)
     : Keyframe::PropertySpecificKeyframe(offset, easing, op)
     , m_value(value)
 {
 }
 
 SVGPropertySpecificKeyframe::SVGPropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, const String& value)
     : Keyframe::PropertySpecificKeyframe(offset, easing, EffectModel::CompositeReplace)
     , m_value(value)
 {
     ASSERT(!isNull(m_offset));
 }
 
 DEFINE_TRACE(StringKeyframe::SVGPropertySpecificKeyframe)
 {
     Keyframe::PropertySpecificKeyframe::trace(visitor);
 }
 
-PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> SVGPropertySpecificKeyframe::cloneWithOffset(double offset) const
+PassRefPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> SVGPropertySpecificKeyframe::cloneWithOffset(double offset) const
 {
-    return adoptPtrWillBeNoop(new SVGPropertySpecificKeyframe(offset, m_easing, m_value));
+    return adoptRefWillBeNoop(new SVGPropertySpecificKeyframe(offset, m_easing, m_value));
 }
 
-PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> SVGPropertySpecificKeyframe::neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const
+PassRefPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> SVGPropertySpecificKeyframe::neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const
 {
-    return adoptPtrWillBeNoop(new SVGPropertySpecificKeyframe(offset, easing, "", EffectModel::CompositeAdd));
+    return adoptRefWillBeNoop(new SVGPropertySpecificKeyframe(offset, easing, "", EffectModel::CompositeAdd));
 }
 
 namespace {
 
 PassRefPtrWillBeRawPtr<Interpolation> createSVGInterpolation(SVGPropertyBase* fromValue, SVGPropertyBase* toValue, SVGAnimatedPropertyBase* attribute)
 {
     RefPtrWillBeRawPtr<Interpolation> interpolation = nullptr;
     ASSERT(fromValue->type() == toValue->type());
     switch (fromValue->type()) {
     case AnimatedAngle:
@@ skipping 37 matching lines @@
         break;
     }
     if (interpolation)
         return interpolation.release();
 
     return DefaultSVGInterpolation::create(fromValue, toValue, attribute);
 }
 
 } // namespace
 
-PassRefPtrWillBeRawPtr<Interpolation> SVGPropertySpecificKeyframe::maybeCreateInterpolation(PropertyHandle propertyHandle, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle) const
+PassRefPtrWillBeRawPtr<Interpolation> SVGPropertySpecificKeyframe::maybeCreateInterpolation(PropertyHandle propertyHandle, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle)
 {
     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