Animation: Fix loss of type information when interpolating value of 0

Source/core/animation/LengthStyleInterpolationTest.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/CSSPrimitiveValue.h"
 #include "core/css/StylePropertySet.h"
 
@@ skipping 42 matching lines @@
         return list.release();
     }
 
     void initLengthArray(CSSLengthArray& lengthArray)
     {
         lengthArray.resize(CSSPrimitiveValue::LengthUnitTypeCount);
         for (size_t i = 0; i < CSSPrimitiveValue::LengthUnitTypeCount; ++i)
             lengthArray.at(i) = 0;
     }
 
+    void initLengthTypeArray(CSSLengthTypeArray& lengthTypeArray)
+    {
+        lengthTypeArray.resize(CSSPrimitiveValue::LengthUnitTypeCount);
+        for (size_t i = 0; i < CSSPrimitiveValue::LengthUnitTypeCount; ++i)
+            lengthTypeArray.clear(i);
+    }
+

[samli, 2014/12/22 03:38:04]

Don't need these anymore!

[evemj (not active), 2014/12/22 06:09:05]

Done.

     CSSLengthArray& setLengthArray(CSSLengthArray& lengthArray, String text)
     {
+        CSSLengthTypeArray lengthTypeArray;
         initLengthArray(lengthArray);
+        initLengthTypeArray(lengthTypeArray);
         RefPtrWillBeRawPtr<MutableStylePropertySet> propertySet = MutableStylePropertySet::create();
         propertySet->setProperty(CSSPropertyLeft, text);
-        toCSSPrimitiveValue(propertySet->getPropertyCSSValue(CSSPropertyLeft).get())->accumulateLengthArray(lengthArray);
+        toCSSPrimitiveValue(propertySet->getPropertyCSSValue(CSSPropertyLeft).get())->accumulateLengthArray(lengthArray, lengthTypeArray);
         return lengthArray;
     }
 
     bool lengthArraysEqual(CSSLengthArray& a, CSSLengthArray& b)
     {
         for (size_t i = 0; i < CSSPrimitiveValue::LengthUnitTypeCount; ++i) {
             if (a.at(i) != b.at(i))
                 return false;
         }
         return true;
     }
 };
 
 TEST_F(AnimationLengthStyleInterpolationTest, ZeroLength)
 {
-    RefPtrWillBeRawPtr<CSSValue> value = roundTrip(CSSPrimitiveValue::create(0, CSSPrimitiveValue::CSS_PX));
-    testPrimitiveValue(value, 0, CSSPrimitiveValue::CSS_PX);
+    RefPtrWillBeRawPtr<CSSValue> value1 = roundTrip(CSSPrimitiveValue::create(0, CSSPrimitiveValue::CSS_PX));
+    testPrimitiveValue(value1, 0, CSSPrimitiveValue::CSS_PX);
 
-    value = roundTrip(CSSPrimitiveValue::create(0, CSSPrimitiveValue::CSS_EMS));
-    testPrimitiveValue(value, 0, CSSPrimitiveValue::CSS_PX);
+    RefPtrWillBeRawPtr<CSSValue> value2 = roundTrip(CSSPrimitiveValue::create(0, CSSPrimitiveValue::CSS_PERCENTAGE));
+    testPrimitiveValue(value2, 0, CSSPrimitiveValue::CSS_PERCENTAGE);
+
+    RefPtrWillBeRawPtr<CSSValue> value3 = roundTrip(CSSPrimitiveValue::create(0, CSSPrimitiveValue::CSS_EMS));
+    testPrimitiveValue(value3, 0, CSSPrimitiveValue::CSS_EMS);
+
 }
 
 TEST_F(AnimationLengthStyleInterpolationTest, SingleUnit)
 {
     RefPtrWillBeRawPtr<CSSValue> value = roundTrip(CSSPrimitiveValue::create(10, CSSPrimitiveValue::CSS_PX));
     testPrimitiveValue(value, 10, CSSPrimitiveValue::CSS_PX);
 
     value = roundTrip(CSSPrimitiveValue::create(30, CSSPrimitiveValue::CSS_PERCENTAGE));
     testPrimitiveValue(value, 30, CSSPrimitiveValue::CSS_PERCENTAGE);
 
-    value = roundTrip(CSSPrimitiveValue::create(-10, CSSPrimitiveValue::CSS_EMS));
-    testPrimitiveValue(value, -10, CSSPrimitiveValue::CSS_EMS);
+    value = roundTrip(CSSPrimitiveValue::create(10, CSSPrimitiveValue::CSS_EMS));
+    testPrimitiveValue(value, 10, CSSPrimitiveValue::CSS_EMS);
 }
 
 TEST_F(AnimationLengthStyleInterpolationTest, SingleClampedUnit)
 {
-    RefPtrWillBeRawPtr<CSSValue> value = CSSPrimitiveValue::create(-10, CSSPrimitiveValue::CSS_EMS);
-    value = interpolableValueToLength(lengthToInterpolableValue(*value).get(), ValueRangeNonNegative);
-    testPrimitiveValue(value, 0, CSSPrimitiveValue::CSS_EMS);
+    RefPtrWillBeRawPtr<CSSValue> value1 = CSSPrimitiveValue::create(-10, CSSPrimitiveValue::CSS_PX);
+    value1 = interpolableValueToLength(lengthToInterpolableValue(*value1).get(), ValueRangeNonNegative);
+    testPrimitiveValue(value1, 0, CSSPrimitiveValue::CSS_PX);
+
+    RefPtrWillBeRawPtr<CSSValue> value2 = CSSPrimitiveValue::create(-10, CSSPrimitiveValue::CSS_EMS);
+    value2 = interpolableValueToLength(lengthToInterpolableValue(*value2).get(), ValueRangeNonNegative);
+    testPrimitiveValue(value2, 0, CSSPrimitiveValue::CSS_EMS);
 }
 
 TEST_F(AnimationLengthStyleInterpolationTest, MultipleUnits)
 {
-    CSSLengthArray actual, expectation;
+    CSSLengthArray expectation, actual;
+    CSSLengthTypeArray expectedType, actualType;
     initLengthArray(expectation);
-    OwnPtrWillBeRawPtr<InterpolableList> list = createInterpolableLength(0, 10, 0, 10, 0, 10, 0, 10, 0, 10);
-    toCSSPrimitiveValue(interpolableValueToLength(list.get(), ValueRangeAll).get())->accumulateLengthArray(expectation);
+    initLengthTypeArray(expectedType);
+    OwnPtrWillBeRawPtr<InterpolableList> result = InterpolableList::create(2);
+    result->set(0, createInterpolableLength(0, 10, 0, 10, 0, 10, 0, 10, 0, 10));
+    result->set(1, createInterpolableLength(0, 1, 0, 1, 0, 1, 0, 1, 0, 1));
+    toCSSPrimitiveValue(interpolableValueToLength(result.get(), ValueRangeAll).get())->accumulateLengthArray(expectation, expectedType);
     EXPECT_TRUE(lengthArraysEqual(expectation, setLengthArray(actual, "calc(10% + 10ex + 10ch + 10vh + 10vmax)")));
 }
 
+TEST_F(AnimationLengthStyleInterpolationTest, MultipleUnitsWithSingleValues)
+{
+    CSSLengthArray expectation, actual;
+    CSSLengthTypeArray expectedType, actualType;
+    initLengthArray(expectation);
+    initLengthTypeArray(expectedType);
+    OwnPtrWillBeRawPtr<InterpolableList> result = InterpolableList::create(2);
+    result->set(0, createInterpolableLength(0, 10, 0, 10, 0, 10, 0, 10, 0, 10));
+    result->set(1, createInterpolableLength(0, 1, 0, 1, 0, 1, 0, 1, 0, 1));
+    toCSSPrimitiveValue(interpolableValueToLength(result.get(), ValueRangeAll).get())->accumulateLengthArray(expectation, expectedType);
+    EXPECT_TRUE(lengthArraysEqual(expectation, setLengthArray(actual, "calc(10% + 10ex + 10ch + 10vh + 10vmax)")));
+
 }
+
+TEST_F(AnimationLengthStyleInterpolationTest, MultipleUnitsWithMultipleValues)
+{
+    CSSLengthArray expectation, actual;
+    CSSLengthTypeArray expectedType, actualType;
+    initLengthArray(expectation);
+    initLengthTypeArray(expectedType);
+    OwnPtrWillBeRawPtr<InterpolableList> result = InterpolableList::create(2);
+    result->set(0, createInterpolableLength(0, 20, 0, 30, 0, 8, 0, 10, 0, 7));
+    result->set(1, createInterpolableLength(0, 1, 0, 1, 0, 1, 0, 1, 0, 1));
+    toCSSPrimitiveValue(interpolableValueToLength(result.get(), ValueRangeAll).get())->accumulateLengthArray(expectation, expectedType);
+    EXPECT_TRUE(lengthArraysEqual(expectation, setLengthArray(actual, "calc(20% + 30ex + 8ch + 10vh + 7vmax)")));
+
+}
+
+TEST_F(AnimationLengthStyleInterpolationTest, MultipleUnitsWithZeroValues)

[samli, 2014/12/22 03:38:04]

Only has one zero value. Add an extra test with multiple zeros.

+{
+    CSSLengthArray expectation, actual;
+    CSSLengthTypeArray expectedType, actualType;

[samli, 2014/12/22 03:38:04]

This isn't needed

[evemj (not active), 2014/12/22 06:09:05]

Done.

+    initLengthArray(expectation);
+    initLengthTypeArray(expectedType);
+    OwnPtrWillBeRawPtr<InterpolableList> result = InterpolableList::create(2);
+    result->set(0, createInterpolableLength(0, 10, 0, 10, 0, 10, 0, 10, 0, 10));
+    result->set(1, createInterpolableLength(1, 1, 0, 1, 0, 1, 0, 1, 0, 1));
+    toCSSPrimitiveValue(interpolableValueToLength(result.get(), ValueRangeAll).get())->accumulateLengthArray(expectation, expectedType);
+    EXPECT_TRUE(lengthArraysEqual(expectation, setLengthArray(actual, "calc(0px + 10% + 10ex + 10ch + 10vh + 10vmax)")));
+}
+
+}