Rename animatable to interpolable in CSSProperties.in

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/CSSValueInterpolationType.h"
 #include "core/animation/ColorStyleInterpolation.h"
@@ skipping 37 matching lines @@
 StringKeyframe::StringKeyframe(const StringKeyframe& copyFrom)
     : Keyframe(copyFrom.m_offset, copyFrom.m_composite, copyFrom.m_easing)
     , m_propertySet(copyFrom.m_propertySet->mutableCopy())
     , m_svgPropertyMap(copyFrom.m_svgPropertyMap)
 {
 }
 
 void StringKeyframe::setPropertyValue(CSSPropertyID property, const String& value, Element* element, StyleSheetContents* styleSheetContents)
 {
     ASSERT(property != CSSPropertyInvalid);
-    if (CSSAnimations::isAllowedAnimation(property))
+    if (CSSAnimations::isAnimatableProperty(property))
         m_propertySet->setProperty(property, value, false, styleSheetContents);
 }
 
 void StringKeyframe::setPropertyValue(CSSPropertyID property, PassRefPtrWillBeRawPtr<CSSValue> value)
 {
     ASSERT(property != CSSPropertyInvalid);
-    ASSERT(CSSAnimations::isAllowedAnimation(property));
+    ASSERT(CSSAnimations::isAnimatableProperty(property));
     m_propertySet->setProperty(property, value, false);
 }
 
 void StringKeyframe::setPropertyValue(const QualifiedName& attributeName, const String& value, Element* element)
 {
     ASSERT(element->isSVGElement());
     m_svgPropertyMap.set(&attributeName, value);
 }
 
 PropertyHandleSet StringKeyframe::properties() const
@@ skipping 78 matching lines @@
 }
 
 const Vector<const InterpolationType*>* applicableTypesForProperty(CSSPropertyID property)
 {
     using ApplicableTypesMap = HashMap<CSSPropertyID, const Vector<const InterpolationType*>*>;
     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))
+    // TODO(alancutter): Support all interpolable CSS properties here so we can stop falling back to the old StyleInterpolation implementation.
+    if (CSSPropertyMetadata::isInterpolableProperty(property))
         return nullptr;
 
     auto applicableTypes = new Vector<const InterpolationType*>();
     applicableTypes->append(new CSSValueInterpolationType(property));
     applicableTypesMap.add(property, applicableTypes);
     return applicableTypes;
 }
 
 } // namespace
 
@@ skipping 14 matching lines @@
 
     // 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 (!CSSPropertyMetadata::isInterpolableProperty(property)) {
         if (fromCSSValue == toCSSValue)
             return ConstantStyleInterpolation::create(fromCSSValue, property);
 
         return nullptr;
     }
 
     switch (property) {
     case CSSPropertyLineHeight:
         if (LengthStyleInterpolation::canCreateFrom(*fromCSSValue) && LengthStyleInterpolation::canCreateFrom(*toCSSValue))
             return LengthStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, RangeNonNegative);
@@ skipping 383 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