Add additive animation support for border-radius CSS properties

third_party/WebKit/Source/core/animation/LengthListPropertyFunctions.cpp

 // Copyright 2015 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 "core/animation/LengthListPropertyFunctions.h"
 
 #include "core/style/ComputedStyle.h"
 
 namespace blink {
 
@@ skipping 69 matching lines @@
 {
     switch (property) {
     case CSSPropertyBackgroundPositionX:
     case CSSPropertyBackgroundPositionY:
     case CSSPropertyObjectPosition:
     case CSSPropertyPerspectiveOrigin:
     case CSSPropertyWebkitMaskPositionX:
     case CSSPropertyWebkitMaskPositionY:
         return ValueRangeAll;
 
+    case CSSPropertyBorderBottomLeftRadius:
+    case CSSPropertyBorderBottomRightRadius:
+    case CSSPropertyBorderTopLeftRadius:
+    case CSSPropertyBorderTopRightRadius:
     case CSSPropertyStrokeDasharray:
         return ValueRangeNonNegative;
 
     default:
         ASSERT_NOT_REACHED();
         return ValueRangeAll;
     }
 }
 
 Vector<Length> LengthListPropertyFunctions::getInitialLengthList(CSSPropertyID property)
 {
     return getLengthList(property, *ComputedStyle::initialStyle());
 }
 
+static Vector<Length> toVector(const LengthPoint& point)
+{
+    Vector<Length> result(2);
+    result[0] = point.x();
+    result[1] = point.y();
+    return result;
+}
+
+static Vector<Length> toVector(const LengthSize& size)
+{
+    Vector<Length> result(2);
+    result[0] = size.width();
+    result[1] = size.height();
+    return result;
+}
+
 Vector<Length> LengthListPropertyFunctions::getLengthList(CSSPropertyID property, const ComputedStyle& style)
 {
-    Vector<Length> result;
-
     switch (property) {
-    case CSSPropertyStrokeDasharray:
+    case CSSPropertyStrokeDasharray: {
         if (style.strokeDashArray())
-            result.appendVector(style.strokeDashArray()->vector());
-        return result;
+            return style.strokeDashArray()->vector();
+        return Vector<Length>();
+    }
     case CSSPropertyObjectPosition:
-        result.append(style.objectPosition().x());
-        result.append(style.objectPosition().y());
-        return result;
+        return toVector(style.objectPosition());
     case CSSPropertyPerspectiveOrigin:
-        result.append(style.perspectiveOrigin().x());
-        result.append(style.perspectiveOrigin().y());
-        return result;
+        return toVector(style.perspectiveOrigin());
+    case CSSPropertyBorderBottomLeftRadius:
+        return toVector(style.borderBottomLeftRadius());
+    case CSSPropertyBorderBottomRightRadius:
+        return toVector(style.borderBottomRightRadius());
+    case CSSPropertyBorderTopLeftRadius:
+        return toVector(style.borderTopLeftRadius());
+    case CSSPropertyBorderTopRightRadius:
+        return toVector(style.borderTopRightRadius());
     default:
         break;
     }
 
+    Vector<Length> result;
     const FillLayer* fillLayer = getFillLayer(property, style);
     FillLayerMethods fillLayerMethods(property);
     while (fillLayer && (fillLayer->*fillLayerMethods.isSet)()) {
         result.append((fillLayer->*fillLayerMethods.get)());
         fillLayer = fillLayer->next();
     }
     return result;
 }
 
+static LengthPoint pointFromVector(const Vector<Length>& list)
+{
+    ASSERT(list.size() == 2);
+    return LengthPoint(list[0], list[1]);
+}
+
+static LengthSize sizeFromVector(const Vector<Length>& list)
+{
+    ASSERT(list.size() == 2);
+    return LengthSize(list[0], list[1]);
+}
+
 void LengthListPropertyFunctions::setLengthList(CSSPropertyID property, ComputedStyle& style, Vector<Length>&& lengthList)
 {
     switch (property) {
     case CSSPropertyStrokeDasharray:
         style.setStrokeDashArray(lengthList.isEmpty() ? nullptr : RefVector<Length>::create(std::move(lengthList)));
         return;
     case CSSPropertyObjectPosition:
-        style.setObjectPosition(LengthPoint(lengthList[0], lengthList[1]));
+        style.setObjectPosition(pointFromVector(lengthList));
         return;
     case CSSPropertyPerspectiveOrigin:
-        style.setPerspectiveOrigin(LengthPoint(lengthList[0], lengthList[1]));
+        style.setPerspectiveOrigin(pointFromVector(lengthList));
+        return;
+    case CSSPropertyBorderBottomLeftRadius:
+        style.setBorderBottomLeftRadius(sizeFromVector(lengthList));
+        return;
+    case CSSPropertyBorderBottomRightRadius:
+        style.setBorderBottomRightRadius(sizeFromVector(lengthList));
+        return;
+    case CSSPropertyBorderTopLeftRadius:
+        style.setBorderTopLeftRadius(sizeFromVector(lengthList));
+        return;
+    case CSSPropertyBorderTopRightRadius:
+        style.setBorderTopRightRadius(sizeFromVector(lengthList));
         return;
     default:
         break;
     }
 
     FillLayer* fillLayer = accessFillLayer(property, style);
     FillLayer* prev = nullptr;
     FillLayerMethods fillLayerMethods(property);
     for (size_t i = 0; i < lengthList.size(); i++) {
         if (!fillLayer)
             fillLayer = prev->ensureNext();
         (fillLayer->*fillLayerMethods.set)(lengthList[i]);
         prev = fillLayer;
         fillLayer = fillLayer->next();
     }
     while (fillLayer) {
         (fillLayer->*fillLayerMethods.clear)();
         fillLayer = fillLayer->next();
     }
 }
 
 } // namespace blink