CSS Motion Path: Support parsing of ray(<angle>) paths

third_party/WebKit/Source/core/css/BasicShapeFunctions.cpp

 /*
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 14 matching lines @@
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include "core/css/BasicShapeFunctions.h"
 
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
+#include "core/css/CSSRayValue.h"
 #include "core/css/CSSValuePair.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/style/BasicShapes.h"
 #include "core/style/ComputedStyle.h"
+#include "core/style/StyleRay.h"
 
 namespace blink {
 
+static StyleRay::RaySize KeywordToRaySize(CSSValueID id) {
+  switch (id) {
+    case CSSValueClosestSide:
+      return StyleRay::RaySize::kClosestSide;
+    case CSSValueClosestCorner:
+      return StyleRay::RaySize::kClosestCorner;
+    case CSSValueFarthestSide:
+      return StyleRay::RaySize::kFarthestSide;
+    case CSSValueFarthestCorner:
+      return StyleRay::RaySize::kFarthestCorner;
+    case CSSValueSides:
+      return StyleRay::RaySize::kSides;
+    default:
+      NOTREACHED();
+      return StyleRay::RaySize::kClosestSide;
+  }
+}
+
+static CSSValueID RaySizeToKeyword(StyleRay::RaySize size) {
+  switch (size) {
+    case StyleRay::RaySize::kClosestSide:
+      return CSSValueClosestSide;
+    case StyleRay::RaySize::kClosestCorner:
+      return CSSValueClosestCorner;
+    case StyleRay::RaySize::kFarthestSide:
+      return CSSValueFarthestSide;
+    case StyleRay::RaySize::kFarthestCorner:
+      return CSSValueFarthestCorner;
+    case StyleRay::RaySize::kSides:
+      return CSSValueSides;
+  }
+  NOTREACHED();
+  return CSSValueInvalid;
+}
+
 static CSSValue* ValueForCenterCoordinate(
     const ComputedStyle& style,
     const BasicShapeCenterCoordinate& center,
     EBoxOrient orientation) {
   if (center.GetDirection() == BasicShapeCenterCoordinate::kTopLeft)
     return CSSValue::Create(center.length(), style.EffectiveZoom());
 
   CSSValueID keyword =
       orientation == HORIZONTAL ? CSSValueRight : CSSValueBottom;
 
@@ skipping 22 matching lines @@
       return CSSIdentifierValue::Create(CSSValueFarthestSide);
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 CSSValue* ValueForBasicShape(const ComputedStyle& style,
                              const BasicShape* basic_shape) {
   switch (basic_shape->GetType()) {
+    case BasicShape::kStyleRayType: {
+      const StyleRay& ray = ToStyleRay(*basic_shape);
+      return CSSRayValue::Create(
+          *CSSPrimitiveValue::Create(ray.Angle(),
+                                     CSSPrimitiveValue::UnitType::kDegrees),
+          *CSSIdentifierValue::Create(RaySizeToKeyword(ray.Size())),
+          (ray.Contain() ? CSSIdentifierValue::Create(CSSValueContain)
+                         : nullptr));
+    }
+
+    case BasicShape::kStylePathType:
+      return ToStylePath(basic_shape)->ComputedCSSValue();
+
     case BasicShape::kBasicShapeCircleType: {
       const BasicShapeCircle* circle = ToBasicShapeCircle(basic_shape);
       CSSBasicShapeCircleValue* circle_value =
           CSSBasicShapeCircleValue::Create();
 
       circle_value->SetCenterX(
           ValueForCenterCoordinate(style, circle->CenterX(), HORIZONTAL));
       circle_value->SetCenterY(
           ValueForCenterCoordinate(style, circle->CenterY(), VERTICAL));
       circle_value->SetRadius(
@@ skipping 194 matching lines @@
     rect->SetTopLeftRadius(
         ConvertToLengthSize(state, rect_value.TopLeftRadius()));
     rect->SetTopRightRadius(
         ConvertToLengthSize(state, rect_value.TopRightRadius()));
     rect->SetBottomRightRadius(
         ConvertToLengthSize(state, rect_value.BottomRightRadius()));
     rect->SetBottomLeftRadius(
         ConvertToLengthSize(state, rect_value.BottomLeftRadius()));
 
     basic_shape = std::move(rect);
+  } else if (basic_shape_value.IsRayValue()) {
+    const CSSRayValue& ray_value = ToCSSRayValue(basic_shape_value);
+    float angle = ray_value.Angle().ComputeDegrees();
+    StyleRay::RaySize size = KeywordToRaySize(ray_value.Size().GetValueID());
+    bool contain = !!ray_value.Contain();
+    basic_shape = StyleRay::Create(angle, size, contain);
   } else {
     NOTREACHED();
   }
 
   return basic_shape.Release();
 }
 
 FloatPoint FloatPointForCenterCoordinate(
     const BasicShapeCenterCoordinate& center_x,
     const BasicShapeCenterCoordinate& center_y,
     FloatSize box_size) {
   float x = FloatValueForLength(center_x.ComputedLength(), box_size.Width());
   float y = FloatValueForLength(center_y.ComputedLength(), box_size.Height());
   return FloatPoint(x, y);
 }
 
 }  // namespace blink