Animation: Implement DoubleStyleInterpolation in StringKeyframe

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/ColorStyleInterpolation.h"
 #include "core/animation/ConstantStyleInterpolation.h"
 #include "core/animation/DefaultStyleInterpolation.h"
@@ skipping 57 matching lines @@
     , m_value(value)
 { }
 
 StringKeyframe::PropertySpecificKeyframe::PropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, CSSValue* value)
     : Keyframe::PropertySpecificKeyframe(offset, easing, AnimationEffect::CompositeReplace)
     , m_value(value)
 {
     ASSERT(!isNull(m_offset));
 }
 
+namespace {
+void setRange(InterpolationRange* range, InterpolationRange setTo)

[alancutter (OOO until 2018), 2015/02/06 07:26:12]

This should be a reference.

[dstockwell, 2015/02/06 10:44:47]

This is not what I meant. Instead I was suggesting that we should create a
function of the form:

    InterpolationRange range(CSSPropertyID)

That way we can avoid the hard to read & error-prone fall-through logic.

[jadeg, 2015/02/09 00:07:13]

Done.

+{
+    if (*range == RangeAll)
+        *range = setTo; 
+}
+
+} // namespace
+
 // FIXME: Refactor this into a generic piece that lives in InterpolationEffect, and a template parameter specific converter.
 PassRefPtrWillBeRawPtr<Interpolation> StringKeyframe::PropertySpecificKeyframe::maybeCreateInterpolation(CSSPropertyID property, Keyframe::PropertySpecificKeyframe& end, Element* element) const
 {
     CSSValue* fromCSSValue = m_value.get();
     CSSValue* toCSSValue = toStringPropertySpecificKeyframe(end).value();
     InterpolationRange range = RangeAll;
     bool fallBackToLegacy = false;
 
     if (!CSSPropertyMetadata::isAnimatableProperty(property)) {
         // FIXME: Remove this once TimingFunction partitioning is implemented for all types.
         if (!RuntimeEnabledFeatures::webAnimationsAPITimingFunctionPartitioningEnabled())
             return DefaultStyleInterpolation::create(fromCSSValue, toCSSValue, 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;
+        // Fall through
     case CSSPropertyBorderBottomWidth:
     case CSSPropertyBorderLeftWidth:
     case CSSPropertyBorderRightWidth:
     case CSSPropertyBorderTopWidth:
     case CSSPropertyFontSize:
     case CSSPropertyHeight:
     case CSSPropertyMaxHeight:
     case CSSPropertyMaxWidth:
     case CSSPropertyMinHeight:
     case CSSPropertyMinWidth:
@@ skipping 19 matching lines @@
     case CSSPropertyRight:
     case CSSPropertyTop:
     case CSSPropertyVerticalAlign:
     case CSSPropertyWordSpacing:
         if (LengthStyleInterpolation::canCreateFrom(*fromCSSValue) && LengthStyleInterpolation::canCreateFrom(*toCSSValue))
             return LengthStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, range);
 
         // FIXME: Handle keywords e.g. 'none'.
         if (property == CSSPropertyPerspective)
             fallBackToLegacy = true;
-
         // FIXME: Handle keywords e.g. 'smaller', 'larger'.
         if (property == CSSPropertyFontSize)
             fallBackToLegacy = true;
 
         // FIXME: Handle keywords e.g. 'normal'
         if (property == CSSPropertyLetterSpacing)
             fallBackToLegacy = true;
 
         // FIXME: Handle keywords e.g. 'thick'
         if (property == CSSPropertyOutlineWidth)
             fallBackToLegacy = true;
+        break;
+    case CSSPropertyFlexGrow:
+    case CSSPropertyFlexShrink:
+        setRange(&range, RangeNonNegative);
+        // Fall through
+    case CSSPropertyWidows:
+    case CSSPropertyOrphans:
+    case CSSPropertyZIndex:
+        setRange(&range, RangeRound);
+        // Fall through
+    case CSSPropertyWebkitColumnCount:
+        setRange(&range, RangeFloor);

[dstockwell, 2015/02/06 10:44:48]

RangeFloor seems wrong, in AnimatedStyleBuilder.cpp this is rounded and clamped
>= 1

[jadeg, 2015/02/09 00:07:13]

Done.

+        // Fall through
+    case CSSPropertyShapeImageThreshold:
+        setRange(&range, RangeZeroToOne);
+        // Fall through
+    case CSSPropertyFillOpacity:

[dstockwell, 2015/02/06 10:44:48]

Flood/Stop/Stroke should be ZeroToOne (as in AnimatedStyleBuilder.cpp)

CSSPropertyOpacity should remain ZeroToLessThanOne, but this should still be
called RangeOpacityFIXME. It's called *FIXME because it should really be
RangeZeroToOne but can't be due to other limitations.

[jadeg, 2015/02/09 00:07:13]

Done.

+    case CSSPropertyFloodOpacity:
+    case CSSPropertyOpacity:
+    case CSSPropertyStopOpacity:
+    case CSSPropertyStrokeOpacity:
+        setRange(&range, RangeZeroToLessThanOne);
+        // Fall through
+    case CSSPropertyStrokeMiterlimit:
+        setRange(&range, RangeGreaterThanOrEqualToOne);
+        // Fall through
+    case CSSPropertyZoom:
+        setRange(&range, RangePositive);
+        // Fall through
+    case CSSPropertyWebkitColumnRuleWidth:

[dstockwell, 2015/02/06 10:44:47]

CSSPropertyColumnRuleWidth should be rounded (as in AnimatedStyleBuilder.cpp)

[jadeg, 2015/02/09 00:07:13]

Done.

+        if (DoubleStyleInterpolation::canCreateFrom(*fromCSSValue) && DoubleStyleInterpolation::canCreateFrom(*toCSSValue)) {
+            if (property == CSSPropertyOpacity)
+                StringKeyframe::PropertySpecificKeyframe::ensureAnimatableValueCaches(property, end, element, *fromCSSValue, *toCSSValue);
+            return DoubleStyleInterpolation::create(*fromCSSValue, *toCSSValue, property, toCSSPrimitiveValue(fromCSSValue)->primitiveType(), range);
+        }
+        break;
 
-        break;
-    case CSSPropertyMotionRotation:
-        {
-            RefPtrWillBeRawPtr<Interpolation> interpolation = DoubleStyleInterpolation::maybeCreateFromMotionRotation(*fromCSSValue, *toCSSValue, property);
-            if (interpolation)
-                return interpolation.release();
-
+    case CSSPropertyMotionRotation: {
+        RefPtrWillBeRawPtr<Interpolation> interpolation = DoubleStyleInterpolation::maybeCreateFromMotionRotation(*fromCSSValue, *toCSSValue, property);
+        if (interpolation)
+            return interpolation.release();
             break;
         }
     case CSSPropertyVisibility:
         if (VisibilityStyleInterpolation::canCreateFrom(*fromCSSValue) && VisibilityStyleInterpolation::canCreateFrom(*toCSSValue) && (VisibilityStyleInterpolation::isVisible(*fromCSSValue) || VisibilityStyleInterpolation::isVisible(*toCSSValue)))
             return VisibilityStyleInterpolation::create(*fromCSSValue, *toCSSValue, property);
 
         break;
 
     case CSSPropertyBackgroundColor:
     case CSSPropertyBorderBottomColor:
@@ skipping 78 matching lines @@
     if (fromCSSValue->isUnsetValue() || fromCSSValue->isInheritedValue() || fromCSSValue->isInitialValue()
         || toCSSValue->isUnsetValue() || toCSSValue->isInheritedValue() || toCSSValue->isInitialValue())
         fallBackToLegacy = true;
 
     if (fallBackToLegacy) {
         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, RenderStyles and Elements here.
-        // FIXME: Remove this cache
-        ASSERT(element);
-        if (!m_animatableValueCache)
-            m_animatableValueCache = StyleResolver::createAnimatableValueSnapshot(*element, property, *fromCSSValue);
+        StringKeyframe::PropertySpecificKeyframe::ensureAnimatableValueCaches(property, end, element, *fromCSSValue, *toCSSValue);
 
-        RefPtrWillBeRawPtr<AnimatableValue> to = StyleResolver::createAnimatableValueSnapshot(*element, property, *toCSSValue);
-        toStringPropertySpecificKeyframe(end).m_animatableValueCache = to;
-
-        return LegacyStyleInterpolation::create(m_animatableValueCache.get(), to.release(), property);
+        return LegacyStyleInterpolation::create(m_animatableValueCache.get(), toStringPropertySpecificKeyframe(end).m_animatableValueCache.release(), property);
     }
 
     ASSERT(AnimatableValue::usesDefaultInterpolation(
         StyleResolver::createAnimatableValueSnapshot(*element, property, *fromCSSValue).get(),
         StyleResolver::createAnimatableValueSnapshot(*element, property, *toCSSValue).get()));
 
-
     // FIXME: Remove this once TimingFunction partitioning is implemented for all types.
     if (!RuntimeEnabledFeatures::webAnimationsAPITimingFunctionPartitioningEnabled())
         return DefaultStyleInterpolation::create(fromCSSValue, toCSSValue, property);
 
     if (fromCSSValue == toCSSValue)
         return ConstantStyleInterpolation::create(fromCSSValue, property);
 
     return nullptr;
 
 }
 
+// FIXME: Remove the use of AnimatableValues, RenderStyles and Elements here.
+// FIXME: Remove this cache
+void StringKeyframe::PropertySpecificKeyframe::ensureAnimatableValueCaches(CSSPropertyID property, Keyframe::PropertySpecificKeyframe& end, Element* element, CSSValue& fromCSSValue, CSSValue& toCSSValue) const
+{
+    ASSERT(element);
+    if (!m_animatableValueCache)
+        m_animatableValueCache = StyleResolver::createAnimatableValueSnapshot(*element, property, fromCSSValue);
+    RefPtrWillBeRawPtr<AnimatableValue> to = StyleResolver::createAnimatableValueSnapshot(*element, property, toCSSValue);
+    toStringPropertySpecificKeyframe(end).m_animatableValueCache = to;
+}
+
+
 PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::PropertySpecificKeyframe::neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const
 {
     return adoptPtrWillBeNoop(new PropertySpecificKeyframe(offset, easing, 0, AnimationEffect::CompositeAdd));
 }
 
 PassOwnPtrWillBeRawPtr<Keyframe::PropertySpecificKeyframe> StringKeyframe::PropertySpecificKeyframe::cloneWithOffset(double offset) const
 {
     Keyframe::PropertySpecificKeyframe* theClone = new PropertySpecificKeyframe(offset, m_easing, m_value.get());
     toStringPropertySpecificKeyframe(theClone)->m_animatableValueCache = m_animatableValueCache;
     return adoptPtrWillBeNoop(theClone);
 }
 
 void StringKeyframe::PropertySpecificKeyframe::trace(Visitor* visitor)
 {
     visitor->trace(m_value);
     visitor->trace(m_animatableValueCache);
     Keyframe::PropertySpecificKeyframe::trace(visitor);
 }
 
 }