Animation: Add template for ListStyleInterpolation

Source/core/animation/ShadowStyleInterpolation.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/ShadowStyleInterpolation.h"
 
 #include "core/animation/ColorStyleInterpolation.h"
 #include "core/animation/LengthStyleInterpolation.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/resolver/StyleBuilder.h"
 
 namespace blink {
 
-bool ShadowStyleInterpolation::canCreateFrom(const CSSValue& value)
+bool ShadowStyleInterpolation::canCreateFrom(const CSSValue& start, const CSSValue& end)
 {
-    return value.isShadowValue();
+    return start.isShadowValue() && end.isShadowValue()
+        && toCSSShadowValue(start).style == toCSSShadowValue(end).style;
 }
-PassOwnPtrWillBeRawPtr<InterpolableValue> ShadowStyleInterpolation::shadowToInterpolableValue(const CSSValue& value)
+
+PassOwnPtrWillBeRawPtr<InterpolableValue> ShadowStyleInterpolation::lengthToInterpolableValue(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> value)
 {
-    OwnPtrWillBeRawPtr<InterpolableList> result = InterpolableList::create(6);
+    if (value && LengthStyleInterpolation::canCreateFrom(*value))

[dstockwell, 2015/02/02 06:10:11]

When can LengthStyleInterpolation::canCreateFrom return false here?

[evemj (not active), 2015/02/03 00:25:55]

Done.

(Never oops)

+        return LengthStyleInterpolation::toInterpolableValue(*value);
+    return InterpolableBool::create(false);

[dstockwell, 2015/02/02 06:10:12]

Using an InterpolableBool seems a bit of a hack. Maybe we need a new
InterpolableValue to represent these skipped entries.

[shans, 2015/02/02 23:49:11]

We should use an InterpolableValue that represents a length 0 in this case, so
that we can animate from a missing value to a provided value.

[evemj (not active), 2015/02/03 00:25:55]

Done.

Additionally we are now not handling the case where Color is not specified as
part of the shadow value

+}
+
+PassOwnPtrWillBeRawPtr<InterpolableValue> ShadowStyleInterpolation::toInterpolableValue(const CSSValue& value, NonInterpolableType& nonInterpolableData)
+{
+    OwnPtrWillBeRawPtr<InterpolableList> result = InterpolableList::create(5);
     const CSSShadowValue* shadowValue = toCSSShadowValue(&value);
     ASSERT(shadowValue);
 
-    result->set(0, LengthStyleInterpolation::lengthToInterpolableValue(*shadowValue->x));
-    result->set(1, LengthStyleInterpolation::lengthToInterpolableValue(*shadowValue->y));
-    result->set(2, LengthStyleInterpolation::lengthToInterpolableValue(*shadowValue->blur));
-    result->set(3, LengthStyleInterpolation::lengthToInterpolableValue(*shadowValue->spread));
-    result->set(4, ColorStyleInterpolation::colorToInterpolableValue(*shadowValue->color));
+    result->set(0, lengthToInterpolableValue(shadowValue->x));
+    result->set(1, lengthToInterpolableValue(shadowValue->y));
+    result->set(2, lengthToInterpolableValue(shadowValue->blur));
+    result->set(3, lengthToInterpolableValue(shadowValue->spread));
+
+    if (shadowValue->color && ColorStyleInterpolation::canCreateFrom(*shadowValue->color))
+        result->set(4, ColorStyleInterpolation::colorToInterpolableValue(*shadowValue->color));
+    else
+        result->set(4, InterpolableBool::create(false));

[dstockwell, 2015/02/02 06:10:11]

Is there any reason to set this to a bool over switching on the length of the
list?

+
+    if (shadowValue->style)
+        nonInterpolableData = (shadowValue->style->getValueID() == CSSValueInset);
 
     return result.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> ShadowStyleInterpolation::interpolableValueToShadow(InterpolableValue* value, bool styleFlag)
+PassRefPtrWillBeRawPtr<CSSPrimitiveValue> ShadowStyleInterpolation::interpolableValueToLength(const InterpolableValue* value, InterpolationRange range)
 {
-    InterpolableList* shadow = toInterpolableList(value);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> x = LengthStyleInterpolation::interpolableValueToLength(shadow->get(0), RangeNonNegative);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> y = LengthStyleInterpolation::interpolableValueToLength(shadow->get(1), RangeNonNegative);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> blur = LengthStyleInterpolation::interpolableValueToLength(shadow->get(2), RangeNonNegative);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> spread = LengthStyleInterpolation::interpolableValueToLength(shadow->get(3), RangeNonNegative);
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> color = ColorStyleInterpolation::interpolableValueToColor(*(shadow->get(4)));
+    if (!value->isBool())
+        return LengthStyleInterpolation::fromInterpolableValue(*value, range);
+    return nullptr;
+}
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> style = styleFlag ? CSSPrimitiveValue::createIdentifier(CSSValueInset) : CSSPrimitiveValue::createIdentifier(CSSValueNone);
+PassRefPtrWillBeRawPtr<CSSValue> ShadowStyleInterpolation::fromInterpolableValue(const InterpolableValue& value, NonInterpolableType nonInterpolableData, InterpolationRange range)
+{
+    const InterpolableList* shadow = toInterpolableList(&value);
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> x = interpolableValueToLength(shadow->get(0));
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> y = interpolableValueToLength(shadow->get(1));
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> blur = interpolableValueToLength(shadow->get(2), RangeNonNegative);
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> spread = interpolableValueToLength(shadow->get(3));
+
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> color = (!shadow->get(4)->isBool()) ? ColorStyleInterpolation::interpolableValueToColor(*shadow->get(4)) : nullptr;

[dstockwell, 2015/02/02 06:10:12]

outer parens not needed

[evemj (not active), 2015/02/03 00:25:56]

Done.

+    RefPtrWillBeRawPtr<CSSPrimitiveValue> style = nonInterpolableData ? CSSPrimitiveValue::createIdentifier(CSSValueInset) : CSSPrimitiveValue::createIdentifier(CSSValueNone);
 
     RefPtrWillBeRawPtr<CSSShadowValue> result = CSSShadowValue::create(x, y, blur, spread, style, color);
     return result.release();
 }
 
-PassRefPtrWillBeRawPtr<ShadowStyleInterpolation> ShadowStyleInterpolation::maybeCreateFromShadow(const CSSValue& start, const CSSValue& end, CSSPropertyID id)
+bool ShadowStyleInterpolation::usesDefaultStyleInterpolation(const CSSValue& start, const CSSValue& end)
 {
-    if (canCreateFrom(start) && canCreateFrom(end)) {
-        if (toCSSShadowValue(start).style == toCSSShadowValue(end).style) {
-            bool styleFlag = (toCSSShadowValue(start).style->getValueID() == CSSValueInset) ? true : false;
-            return ShadowStyleInterpolation::create(start, end, id, styleFlag);
+    if (start.isValueList() && end.isValueList() && toCSSValueList(start).length() == toCSSValueList(end).length()) {
+        for (size_t i = 0; i < toCSSValueList(start).length(); i++) {
+            if (!canCreateFrom(*toCSSValueList(start).item(i), *toCSSValueList(end).item(i)))
+                return true;
+            }
         }

[dstockwell, 2015/02/02 06:10:11]

these braces aren't indented correctly

[evemj (not active), 2015/02/03 00:25:55]

Done.

-    }
-    return nullptr;
+    return false;
 }
 
-
-void ShadowStyleInterpolation::apply(StyleResolverState& state) const
-{
-    StyleBuilder::applyProperty(m_id, state, interpolableValueToShadow(m_cachedValue.get(), m_styleFlag).get());
-}
-
-void ShadowStyleInterpolation::trace(Visitor* visitor)
-{
-    StyleInterpolation::trace(visitor);
-}
-
-}
+} // namespace blink