style: Use the owned slice type for basic shape polygon coordinates.

This enables destructors for tagged unions in cbindgen, implemented in:

 * https://github.com/eqrion/cbindgen/pull/333

Which allow us to properly generate a destructor for the cbindgen-generated
StyleBasicShape (which now contains an OwnedSlice).

For now, we still use the glue code to go from Box<BasicShape> to
UniquePtr<BasicShape>. But that will change in the future when we generate even
more stuff and remove all the glue.

I could add support for copy-constructor generation to cbindgen for tagged
enums, but I'm not sure if it'll end up being needed, and copy-constructing
unions in C++ is always very tricky.

Differential Revision: https://phabricator.services.mozilla.com/D29769

components/style/values/animated/mod.rs

@@ -16,7 +16,6 @@ use crate::values::computed::Image;
 use crate::values::specified::SVGPathData;
 use crate::values::CSSFloat;
 use app_units::Au;
-use euclid::Point2D;
 use smallvec::SmallVec;
 use std::cmp;
 
@@ -241,16 +240,10 @@ impl Animate for Au {
     }
 }
 
-impl<T> Animate for Point2D<T>
-where
-    T: Animate,
-{
+impl<T: Animate> Animate for Box<T> {
     #[inline]
     fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> {
-        Ok(Point2D::new(
-            self.x.animate(&other.x, procedure)?,
-            self.y.animate(&other.y, procedure)?,
-        ))
+        Ok(Box::new((**self).animate(&other, procedure)?))
     }
 }
 
@@ -288,6 +281,24 @@ where
     }
 }
 
+impl<T> ToAnimatedValue for Box<T>
+where
+    T: ToAnimatedValue,
+{
+    type AnimatedValue = Box<<T as ToAnimatedValue>::AnimatedValue>;
+
+    #[inline]
+    fn to_animated_value(self) -> Self::AnimatedValue {
+        Box::new((*self).to_animated_value())
+    }
+
+    #[inline]
+    fn from_animated_value(animated: Self::AnimatedValue) -> Self {
+        Box::new(T::from_animated_value(*animated))
+    }
+}
+
+
 impl<T> ToAnimatedValue for Box<[T]>
 where
     T: ToAnimatedValue,
@@ -328,7 +339,7 @@ where
 
     #[inline]
     fn from_animated_value(animated: Self::AnimatedValue) -> Self {
-        Box::from_animated_value(animated.into_box()).into()
+        Self::from(Box::from_animated_value(animated.into_box()))
     }
 }
 

components/style/values/computed/basic_shape.rs

@@ -23,7 +23,7 @@ pub type ClippingShape = generic::ClippingShape<BasicShape, ComputedUrl>;
 pub type FloatAreaShape = generic::FloatAreaShape<BasicShape, Image>;
 
 /// A computed basic shape.
-pub type BasicShape = generic::BasicShape<
+pub type BasicShape = generic::GenericBasicShape<
     LengthPercentage,
     LengthPercentage,
     LengthPercentage,
@@ -41,7 +41,7 @@ pub type Ellipse =
     generic::Ellipse<LengthPercentage, LengthPercentage, NonNegativeLengthPercentage>;
 
 /// The computed value of `ShapeRadius`
-pub type ShapeRadius = generic::ShapeRadius<NonNegativeLengthPercentage>;
+pub type ShapeRadius = generic::GenericShapeRadius<NonNegativeLengthPercentage>;
 
 impl ToCss for Circle {
     fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result

components/style/values/generics/basic_shape.rs

@@ -7,8 +7,8 @@
 
 use crate::values::animated::{Animate, Procedure, ToAnimatedZero};
 use crate::values::distance::{ComputeSquaredDistance, SquaredDistance};
-use crate::values::generics::border::BorderRadius;
-use crate::values::generics::position::Position;
+use crate::values::generics::border::GenericBorderRadius;
+use crate::values::generics::position::GenericPosition;
 use crate::values::generics::rect::Rect;
 use crate::values::specified::SVGPathData;
 use crate::Zero;
@@ -89,7 +89,7 @@ pub enum ShapeBox {
 pub enum ShapeSource<BasicShape, ReferenceBox, ImageOrUrl> {
     #[animation(error)]
     ImageOrUrl(ImageOrUrl),
-    Shape(BasicShape, Option<ReferenceBox>),
+    Shape(Box<BasicShape>, Option<ReferenceBox>),
     #[animation(error)]
     Box(ReferenceBox),
     #[css(function)]
@@ -113,7 +113,8 @@ pub enum ShapeSource<BasicShape, ReferenceBox, ImageOrUrl> {
     ToResolvedValue,
     ToShmem,
 )]
-pub enum BasicShape<H, V, LengthPercentage, NonNegativeLengthPercentage> {
+#[repr(C, u8)]
+pub enum GenericBasicShape<H, V, LengthPercentage, NonNegativeLengthPercentage> {
     Inset(
         #[css(field_bound)]
         #[shmem(field_bound)]
@@ -129,9 +130,11 @@ pub enum BasicShape<H, V, LengthPercentage, NonNegativeLengthPercentage> {
         #[shmem(field_bound)]
         Ellipse<H, V, NonNegativeLengthPercentage>,
     ),
-    Polygon(Polygon<LengthPercentage>),
+    Polygon(GenericPolygon<LengthPercentage>),
 }
 
+pub use self::GenericBasicShape as BasicShape;
+
 /// <https://drafts.csswg.org/css-shapes/#funcdef-inset>
 #[allow(missing_docs)]
 #[css(function = "inset")]
@@ -148,10 +151,11 @@ pub enum BasicShape<H, V, LengthPercentage, NonNegativeLengthPercentage> {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(C)]
 pub struct InsetRect<LengthPercentage, NonNegativeLengthPercentage> {
     pub rect: Rect<LengthPercentage>,
     #[shmem(field_bound)]
-    pub round: BorderRadius<NonNegativeLengthPercentage>,
+    pub round: GenericBorderRadius<NonNegativeLengthPercentage>,
 }
 
 /// <https://drafts.csswg.org/css-shapes/#funcdef-circle>
@@ -171,9 +175,10 @@ pub struct InsetRect<LengthPercentage, NonNegativeLengthPercentage> {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(C)]
 pub struct Circle<H, V, NonNegativeLengthPercentage> {
-    pub position: Position<H, V>,
-    pub radius: ShapeRadius<NonNegativeLengthPercentage>,
+    pub position: GenericPosition<H, V>,
+    pub radius: GenericShapeRadius<NonNegativeLengthPercentage>,
 }
 
 /// <https://drafts.csswg.org/css-shapes/#funcdef-ellipse>
@@ -193,10 +198,11 @@ pub struct Circle<H, V, NonNegativeLengthPercentage> {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(C)]
 pub struct Ellipse<H, V, NonNegativeLengthPercentage> {
-    pub position: Position<H, V>,
-    pub semiaxis_x: ShapeRadius<NonNegativeLengthPercentage>,
-    pub semiaxis_y: ShapeRadius<NonNegativeLengthPercentage>,
+    pub position: GenericPosition<H, V>,
+    pub semiaxis_x: GenericShapeRadius<NonNegativeLengthPercentage>,
+    pub semiaxis_y: GenericShapeRadius<NonNegativeLengthPercentage>,
 }
 
 /// <https://drafts.csswg.org/css-shapes/#typedef-shape-radius>
@@ -216,7 +222,8 @@ pub struct Ellipse<H, V, NonNegativeLengthPercentage> {
     ToResolvedValue,
     ToShmem,
 )]
-pub enum ShapeRadius<NonNegativeLengthPercentage> {
+#[repr(C, u8)]
+pub enum GenericShapeRadius<NonNegativeLengthPercentage> {
     Length(NonNegativeLengthPercentage),
     #[animation(error)]
     ClosestSide,
@@ -224,10 +231,12 @@ pub enum ShapeRadius<NonNegativeLengthPercentage> {
     FarthestSide,
 }
 
+pub use self::GenericShapeRadius as ShapeRadius;
+
 /// A generic type for representing the `polygon()` function
 ///
 /// <https://drafts.csswg.org/css-shapes/#funcdef-polygon>
-#[css(comma, function)]
+#[css(comma, function = "polygon")]
 #[derive(
     Clone,
     Debug,
@@ -240,15 +249,18 @@ pub enum ShapeRadius<NonNegativeLengthPercentage> {
     ToResolvedValue,
     ToShmem,
 )]
-pub struct Polygon<LengthPercentage> {
+#[repr(C)]
+pub struct GenericPolygon<LengthPercentage> {
     /// The filling rule for a polygon.
     #[css(skip_if = "fill_is_default")]
     pub fill: FillRule,
     /// A collection of (x, y) coordinates to draw the polygon.
     #[css(iterable)]
-    pub coordinates: Vec<PolygonCoord<LengthPercentage>>,
+    pub coordinates: crate::OwnedSlice<PolygonCoord<LengthPercentage>>,
 }
 
+pub use self::GenericPolygon as Polygon;
+
 /// Coordinates for Polygon.
 #[derive(
     Clone,
@@ -262,6 +274,7 @@ pub struct Polygon<LengthPercentage> {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(C)]
 pub struct PolygonCoord<LengthPercentage>(pub LengthPercentage, pub LengthPercentage);
 
 // https://drafts.csswg.org/css-shapes/#typedef-fill-rule
@@ -393,7 +406,8 @@ where
                     this.1.animate(&other.1, procedure)?,
                 ))
             })
-            .collect::<Result<Vec<_>, _>>()?;
+            .collect::<Result<Vec<_>, _>>()?
+            .into();
         Ok(Polygon {
             fill: self.fill,
             coordinates,

components/style/values/specified/basic_shape.rs

@@ -55,7 +55,7 @@ pub type Ellipse =
 pub type ShapeRadius = generic::ShapeRadius<NonNegativeLengthPercentage>;
 
 /// The specified value of `Polygon`
-pub type Polygon = generic::Polygon<LengthPercentage>;
+pub type Polygon = generic::GenericPolygon<LengthPercentage>;
 
 #[cfg(feature = "gecko")]
 fn is_clip_path_path_enabled(context: &ParserContext) -> bool {
@@ -138,11 +138,11 @@ where
         }
 
         if let Some(shp) = shape {
-            return Ok(ShapeSource::Shape(shp, ref_box));
+            return Ok(ShapeSource::Shape(Box::new(shp), ref_box));
         }
 
         ref_box
-            .map(|v| ShapeSource::Box(v))
+            .map(ShapeSource::Box)
             .ok_or(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
     }
 }
@@ -152,7 +152,7 @@ impl Parse for GeometryBox {
         _context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(shape_box) = input.try(|i| ShapeBox::parse(i)) {
+        if let Ok(shape_box) = input.try(ShapeBox::parse) {
             return Ok(GeometryBox::ShapeBox(shape_box));
         }
 
@@ -352,17 +352,14 @@ impl Polygon {
             })
             .unwrap_or_default();
 
-        let buf = input.parse_comma_separated(|i| {
+        let coordinates = input.parse_comma_separated(|i| {
             Ok(PolygonCoord(
                 LengthPercentage::parse(context, i)?,
                 LengthPercentage::parse(context, i)?,
             ))
-        })?;
+        })?.into();
 
-        Ok(Polygon {
-            fill: fill,
-            coordinates: buf,
-        })
+        Ok(Polygon { fill, coordinates })
     }
 }