Web Animations - responsive interpolation

Source/core/animation/interpolation/DeferredLegacyStyleInterpolation.cpp

Index: Source/core/animation/interpolation/DeferredLegacyStyleInterpolation.cpp
diff --git a/Source/core/animation/interpolation/DeferredLegacyStyleInterpolation.cpp b/Source/core/animation/interpolation/DeferredLegacyStyleInterpolation.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6ec9f832be8a4cc4be5fa5eaee25ff0f7d16a4e7
--- /dev/null
+++ b/Source/core/animation/interpolation/DeferredLegacyStyleInterpolation.cpp
@@ -0,0 +1,270 @@
+// 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/interpolation/DeferredLegacyStyleInterpolation.h"
+
+#include "core/animation/interpolation/LegacyStyleInterpolation.h"
+#include "core/css/CSSPrimitiveValue.h"
+#include "core/css/CSSShadowValue.h"
+#include "core/css/CSSValueList.h"
+#include "core/css/Pair.h"
+#include "core/css/Rect.h"
+#include "core/css/resolver/StyleResolver.h"
+#include "core/css/resolver/StyleResolverState.h"
+
+namespace WebCore {
+
+void DeferredLegacyStyleInterpolation::apply(StyleResolverState& state) const
+{
+    RefPtrWillBeRawPtr<LegacyStyleInterpolation> innerInterpolation = LegacyStyleInterpolation::create(
+        StyleResolver::createAnimatableValueSnapshot(*state.element(), m_id, *m_startCSSValue, *state.style()),
+        StyleResolver::createAnimatableValueSnapshot(*state.element(), m_id, *m_endCSSValue, *state.style()),
+        m_id);
+    innerInterpolation->interpolate(m_cachedIteration, m_cachedFraction);
+    innerInterpolation->apply(state);
+}
+
+bool DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(const CSSValue& value)
+{
+    switch (value.cssValueType()) {
+    case CSSValue::CSS_INHERIT:
+        return true;
+    case CSSValue::CSS_PRIMITIVE_VALUE:
+        return interpolationRequiresStyleResolve(toCSSPrimitiveValue(value));
+    case CSSValue::CSS_VALUE_LIST:
+        return interpolationRequiresStyleResolve(toCSSValueList(value));
+    case CSSValue::CSS_CUSTOM:
+        if (value.isShadowValue())
+            return interpolationRequiresStyleResolve(toCSSShadowValue(value));
+        return true;

[dstockwell, 2014/05/26 11:20:40]

I think we need to handle transform here now.

+fixme, for everything else.

[alancutter (OOO until 2018), 2014/05/26 15:51:32]

Transforms are handled by the CSS_VALUE_LIST branch.

[dstockwell, 2014/05/26 23:40:15]

What does the list contain?

[alancutter (OOO until 2018), 2014/05/26 23:48:26]

The transform arguments.
https://chromium.googlesource.com/experimental/chromium/blink/+/master/Source...
https://chromium.googlesource.com/experimental/chromium/blink/+/master/Source...

+    case CSSValue::CSS_INITIAL:
+        // FIXME: should not require resolving styles for initial.
+        return true;
+    default:
+        ASSERT_NOT_REACHED();
+        return true;
+    }
+}
+
+bool DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(const CSSPrimitiveValue& primitiveValue)
+{
+    if (primitiveValue.isCalculated()) {
+        CSSLengthArray lengthArray(CSSPrimitiveValue::LengthUnitTypeCount);
+        primitiveValue.accumulateLengthArray(lengthArray);
+        return lengthArray[CSSPrimitiveValue::UnitTypeFontSize] != 0
+            || lengthArray[CSSPrimitiveValue::UnitTypeFontXSize] != 0
+            || lengthArray[CSSPrimitiveValue::UnitTypeRootFontSize] != 0
+            || lengthArray[CSSPrimitiveValue::UnitTypeZeroCharacterWidth] != 0
+            || lengthArray[CSSPrimitiveValue::UnitTypeViewportWidth] != 0
+            || lengthArray[CSSPrimitiveValue::UnitTypeViewportHeight] != 0
+            || lengthArray[CSSPrimitiveValue::UnitTypeViewportMin] != 0
+            || lengthArray[CSSPrimitiveValue::UnitTypeViewportMax] != 0;
+    }
+
+    if (primitiveValue.isLength())
+        return primitiveValue.isFontRelativeLength() || primitiveValue.isViewportPercentageLength();
+
+    if (Pair* pair = primitiveValue.getPairValue()) {
+        return interpolationRequiresStyleResolve(*pair->first())
+            || interpolationRequiresStyleResolve(*pair->second());
+    }
+
+    if (Rect* rect = primitiveValue.getRectValue()) {
+        return interpolationRequiresStyleResolve(*rect->top())
+            || interpolationRequiresStyleResolve(*rect->right())
+            || interpolationRequiresStyleResolve(*rect->bottom())
+            || interpolationRequiresStyleResolve(*rect->left());
+    }
+
+    if (Quad* quad = primitiveValue.getQuadValue()) {
+        return interpolationRequiresStyleResolve(*quad->top())
+            || interpolationRequiresStyleResolve(*quad->right())
+            || interpolationRequiresStyleResolve(*quad->bottom())
+            || interpolationRequiresStyleResolve(*quad->left());
+    }
+
+    switch (primitiveValue.getValueID()) {
+    case CSSValueAqua:
+    case CSSValueBlack:
+    case CSSValueBlue:
+    case CSSValueFuchsia:
+    case CSSValueGray:
+    case CSSValueGreen:
+    case CSSValueLime:
+    case CSSValueMaroon:
+    case CSSValueNavy:
+    case CSSValueOlive:
+    case CSSValueOrange:
+    case CSSValuePurple:
+    case CSSValueRed:
+    case CSSValueSilver:
+    case CSSValueTeal:
+    case CSSValueWhite:
+    case CSSValueYellow:
+    case CSSValueAliceblue:
+    case CSSValueAlpha:
+    case CSSValueAntiquewhite:
+    case CSSValueAquamarine:
+    case CSSValueAzure:
+    case CSSValueBeige:
+    case CSSValueBisque:
+    case CSSValueBlanchedalmond:
+    case CSSValueBlueviolet:
+    case CSSValueBrown:
+    case CSSValueBurlywood:
+    case CSSValueCadetblue:
+    case CSSValueChartreuse:
+    case CSSValueChocolate:
+    case CSSValueCoral:
+    case CSSValueCornflowerblue:
+    case CSSValueCornsilk:
+    case CSSValueCrimson:
+    case CSSValueCyan:
+    case CSSValueDarkblue:
+    case CSSValueDarkcyan:
+    case CSSValueDarkgoldenrod:
+    case CSSValueDarkgray:
+    case CSSValueDarkgreen:
+    case CSSValueDarkgrey:
+    case CSSValueDarkkhaki:
+    case CSSValueDarkmagenta:
+    case CSSValueDarkolivegreen:
+    case CSSValueDarkorange:
+    case CSSValueDarkorchid:
+    case CSSValueDarkred:
+    case CSSValueDarksalmon:
+    case CSSValueDarkseagreen:
+    case CSSValueDarkslateblue:
+    case CSSValueDarkslategray:
+    case CSSValueDarkslategrey:
+    case CSSValueDarkturquoise:
+    case CSSValueDarkviolet:
+    case CSSValueDeeppink:
+    case CSSValueDeepskyblue:
+    case CSSValueDimgray:
+    case CSSValueDimgrey:
+    case CSSValueDodgerblue:
+    case CSSValueFirebrick:
+    case CSSValueFloralwhite:
+    case CSSValueForestgreen:
+    case CSSValueGainsboro:
+    case CSSValueGhostwhite:
+    case CSSValueGold:
+    case CSSValueGoldenrod:
+    case CSSValueGreenyellow:
+    case CSSValueHoneydew:
+    case CSSValueHotpink:
+    case CSSValueIndianred:
+    case CSSValueIndigo:
+    case CSSValueIvory:
+    case CSSValueKhaki:
+    case CSSValueLavender:
+    case CSSValueLavenderblush:
+    case CSSValueLawngreen:
+    case CSSValueLemonchiffon:
+    case CSSValueLightblue:
+    case CSSValueLightcoral:
+    case CSSValueLightcyan:
+    case CSSValueLightgoldenrodyellow:
+    case CSSValueLightgray:
+    case CSSValueLightgreen:
+    case CSSValueLightgrey:
+    case CSSValueLightpink:
+    case CSSValueLightsalmon:
+    case CSSValueLightseagreen:
+    case CSSValueLightskyblue:
+    case CSSValueLightslategray:
+    case CSSValueLightslategrey:
+    case CSSValueLightsteelblue:
+    case CSSValueLightyellow:
+    case CSSValueLimegreen:
+    case CSSValueLinen:
+    case CSSValueLuminance:
+    case CSSValueMagenta:
+    case CSSValueMediumaquamarine:
+    case CSSValueMediumblue:
+    case CSSValueMediumorchid:
+    case CSSValueMediumpurple:
+    case CSSValueMediumseagreen:
+    case CSSValueMediumslateblue:
+    case CSSValueMediumspringgreen:
+    case CSSValueMediumturquoise:
+    case CSSValueMediumvioletred:
+    case CSSValueMidnightblue:
+    case CSSValueMistyrose:
+    case CSSValueMoccasin:
+    case CSSValueNavajowhite:
+    case CSSValueOldlace:
+    case CSSValueOlivedrab:
+    case CSSValueOrangered:
+    case CSSValueOrchid:
+    case CSSValuePalegoldenrod:
+    case CSSValuePalegreen:
+    case CSSValuePaleturquoise:
+    case CSSValuePalevioletred:
+    case CSSValuePapayawhip:
+    case CSSValuePeachpuff:
+    case CSSValuePeru:
+    case CSSValuePink:
+    case CSSValuePlum:
+    case CSSValuePowderblue:
+    case CSSValueRosybrown:
+    case CSSValueRoyalblue:
+    case CSSValueSaddlebrown:
+    case CSSValueSalmon:
+    case CSSValueSandybrown:
+    case CSSValueSeagreen:
+    case CSSValueSeashell:
+    case CSSValueSienna:
+    case CSSValueSkyblue:
+    case CSSValueSlateblue:
+    case CSSValueSlategray:
+    case CSSValueSlategrey:
+    case CSSValueSnow:
+    case CSSValueSpringgreen:
+    case CSSValueSteelblue:
+    case CSSValueTan:
+    case CSSValueThistle:
+    case CSSValueTomato:
+    case CSSValueTurquoise:
+    case CSSValueViolet:
+    case CSSValueWheat:
+    case CSSValueWhitesmoke:
+    case CSSValueYellowgreen:

[alancutter (OOO until 2018), 2014/05/26 10:12:10]

This makes me sad. ):
I personally think the smaller negated switch statement is more reasonable,
especially if this is inaccurate for the sake of simplification.

[shans, 2014/05/26 10:47:48]

Are these contiguous? Comparisons with the min and max might keep everyone
happy?

[dstockwell, 2014/05/26 11:20:40]

I suppose we could just return true for all IDs for now, is there any particular
case that we need to optimize now?

+        return false;
+
+    default:
+        return true;
+    }
+}
+
+bool DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(const CSSShadowValue& shadowValue)
+{
+    return (shadowValue.x && interpolationRequiresStyleResolve(*shadowValue.x))
+        || (shadowValue.y && interpolationRequiresStyleResolve(*shadowValue.y))
+        || (shadowValue.blur && interpolationRequiresStyleResolve(*shadowValue.blur))
+        || (shadowValue.spread && interpolationRequiresStyleResolve(*shadowValue.spread))
+        || (shadowValue.style && interpolationRequiresStyleResolve(*shadowValue.style))
+        || (shadowValue.color && interpolationRequiresStyleResolve(*shadowValue.color));
+}
+
+bool DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(const CSSValueList& valueList)
+{
+    size_t length = valueList.length();
+    for (size_t index = 0; index < length; ++index) {
+        if (interpolationRequiresStyleResolve(*valueList.item(index)))
+            return true;
+    }
+    return false;
+}
+
+void DeferredLegacyStyleInterpolation::trace(Visitor* visitor)
+{
+    StyleInterpolation::trace(visitor);
+    visitor->trace(m_startCSSValue);
+    visitor->trace(m_endCSSValue);
+}
+
+}