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/CSSValueAnimationType.h"
 #include "core/animation/ColorStyleInterpolation.h"
 #include "core/animation/CompositorAnimations.h"
 #include "core/animation/ConstantStyleInterpolation.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 113 matching lines @@
     case CSSPropertyStrokeMiterlimit:
         return RangeGreaterThanOrEqualToOne;
     case CSSPropertyFontSizeAdjust:
         return RangeNonNegative;
     default:
         ASSERT_NOT_REACHED();
         return RangeAll;
     }
 }
 
+const Vector<const AnimationType*>* applicableTypesForProperty(CSSPropertyID property)
+{
+    using ApplicableTypesMap = HashMap<CSSPropertyID, const Vector<const AnimationType*>*>;
+    DEFINE_STATIC_LOCAL(ApplicableTypesMap, applicableTypesMap, ());
+    auto entry = applicableTypesMap.find(property);
+    if (entry != applicableTypesMap.end())
+        return entry->value;
+
+    // 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 CSSValueAnimationType(property));
+    applicableTypesMap.add(property, applicableTypes);
+    return applicableTypes;
+}
+
 } // namespace
 
 PassRefPtrWillBeRawPtr<Interpolation> StringKeyframe::CSSPropertySpecificKeyframe::maybeCreateInterpolation(PropertyHandle propertyHandle, Keyframe::PropertySpecificKeyframe& end, Element* element, const ComputedStyle* baseStyle) const
 {
     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 357 matching lines @@
     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