Support keywords in LengthStyleInterpolation

Source/core/animation/LengthStyleInterpolation.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/LengthStyleInterpolation.h"
 
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/resolver/StyleBuilder.h"
 
 namespace blink {
 
-bool LengthStyleInterpolation::canCreateFrom(const CSSValue& value)
+namespace {
+
+bool pixelsForKeyword(CSSPropertyID property, CSSValueID valueID, double& result)
+{
+    switch (property) {
+    case CSSPropertyBorderBottomWidth:
+    case CSSPropertyBorderLeftWidth:
+    case CSSPropertyBorderRightWidth:
+    case CSSPropertyBorderTopWidth:
+    case CSSPropertyWebkitColumnRuleWidth:
+    case CSSPropertyOutlineWidth:
+        if (valueID == CSSValueThin) {
+            result = 1;
+            return true;
+        }
+        if (valueID == CSSValueMedium) {
+            result = 3;
+            return true;
+        }
+        if (valueID == CSSValueThick) {
+            result = 5;
+            return true;
+        }
+        return false;
+    case CSSPropertyLetterSpacing:
+        if (valueID == CSSValueNormal) {
+            result = 0;
+            return true;
+        }
+        return false;
+    case CSSPropertyPerspective:
+        if (valueID == CSSValueNone) {
+            result = 0;

[alancutter (OOO until 2018), 2015/03/09 00:34:15]

Actually we shouldn't be animating perspective: none, we should instead continue
to fall back to legacy and just remove the interpolation behaviour from AV (in a
separate patch).

[Eric Willigers, 2015/03/09 02:04:55]

Done.

+            return true;
+        }
+        return false;
+    default:
+        return false;
+    }
+}
+
+} // namespace
+
+bool LengthStyleInterpolation::canCreateFrom(const CSSValue& value, CSSPropertyID property)
 {
     if (value.isPrimitiveValue()) {
         const CSSPrimitiveValue& primitiveValue = blink::toCSSPrimitiveValue(value);
         if (primitiveValue.cssCalcValue())
             return true;
 
+        if (primitiveValue.isValueID()) {
+            CSSValueID valueID = primitiveValue.getValueID();
+            double pixels;
+            return pixelsForKeyword(property, valueID, pixels);
+        }
+
         CSSPrimitiveValue::LengthUnitType type;
         // Only returns true if the type is a primitive length unit.
         return CSSPrimitiveValue::unitTypeToLengthUnitType(primitiveValue.primitiveType(), type);
     }
     return value.isCalcValue();
 }
 
-PassOwnPtrWillBeRawPtr<InterpolableValue> LengthStyleInterpolation::toInterpolableValue(const CSSValue& value)
+PassOwnPtrWillBeRawPtr<InterpolableValue> LengthStyleInterpolation::toInterpolableValue(const CSSValue& value, CSSPropertyID id)
 {
-    ASSERT(canCreateFrom(value));
+    ASSERT(canCreateFrom(value, id));
     OwnPtrWillBeRawPtr<InterpolableList> listOfValuesAndTypes = InterpolableList::create(2);
     OwnPtrWillBeRawPtr<InterpolableList> listOfValues = InterpolableList::create(CSSPrimitiveValue::LengthUnitTypeCount);
     OwnPtrWillBeRawPtr<InterpolableList> listOfTypes = InterpolableList::create(CSSPrimitiveValue::LengthUnitTypeCount);
 
     const CSSPrimitiveValue& primitive = toCSSPrimitiveValue(value);
 
     CSSLengthArray arrayOfValues;
     CSSPrimitiveValue::CSSLengthTypeArray arrayOfTypes;
     for (size_t i = 0; i < CSSPrimitiveValue::LengthUnitTypeCount; i++)
         arrayOfValues.append(0);
 
     arrayOfTypes.ensureSize(CSSPrimitiveValue::LengthUnitTypeCount);
-    primitive.accumulateLengthArray(arrayOfValues, arrayOfTypes);
+    if (primitive.isValueID()) {
+        CSSValueID valueID = primitive.getValueID();
+        double pixels;
+        pixelsForKeyword(id, valueID, pixels);
+        arrayOfTypes.set(CSSPrimitiveValue::UnitTypePixels);
+        arrayOfValues[CSSPrimitiveValue::UnitTypePixels] = pixels;
+    } else {
+        primitive.accumulateLengthArray(arrayOfValues, arrayOfTypes);
+    }
 
     for (size_t i = 0; i < CSSPrimitiveValue::LengthUnitTypeCount; i++) {
         listOfValues->set(i, InterpolableNumber::create(arrayOfValues.at(i)));
         listOfTypes->set(i, InterpolableNumber::create(arrayOfTypes.get(i)));
     }
 
     listOfValuesAndTypes->set(0, listOfValues.release());
     listOfValuesAndTypes->set(1, listOfTypes.release());
 
     return listOfValuesAndTypes.release();
@@ skipping 66 matching lines @@
 {
     StyleBuilder::applyProperty(m_id, state, fromInterpolableValue(*m_cachedValue.get(), m_range).get());
 }
 
 DEFINE_TRACE(LengthStyleInterpolation)
 {
     StyleInterpolation::trace(visitor);
 }
 
 }