Use generics for border-image-slice property

components/layout/display_list_builder.rs

@@ -1429,8 +1429,7 @@ impl FragmentDisplayListBuilding for Fragment {
                                                                             url.clone(),
                                                                             UsePlaceholder::No);
                     if let Some(webrender_image) = webrender_image {
-                        // The corners array is guaranteed to be len=4 by the css parser.
+                        let corners = &border_style_struct.border_image_slice.offsets;
-                        let corners = &border_style_struct.border_image_slice.corners;
 
                         state.add_display_item(DisplayItem::Border(box BorderDisplayItem {
                             base: base,
@@ -1438,10 +1437,10 @@ impl FragmentDisplayListBuilding for Fragment {
                             details: BorderDetails::Image(ImageBorder {
                                 image: webrender_image,
                                 fill: border_style_struct.border_image_slice.fill,
-                                slice: SideOffsets2D::new(corners[0].resolve(webrender_image.height),
+                                slice: SideOffsets2D::new(corners.top.resolve(webrender_image.height),
-                                                          corners[1].resolve(webrender_image.width),
+                                                          corners.right.resolve(webrender_image.width),
-                                                          corners[2].resolve(webrender_image.height),
+                                                          corners.bottom.resolve(webrender_image.height),
-                                                          corners[3].resolve(webrender_image.width)),
+                                                          corners.left.resolve(webrender_image.width)),
                                 // TODO(gw): Support border-image-outset
                                 outset: SideOffsets2D::zero(),
                                 repeat_horizontal: convert_repeat_mode(border_style_struct.border_image_repeat.0),

components/style/properties/gecko.mako.rs

@@ -1020,9 +1020,9 @@ fn static_assert() {
     pub fn set_border_image_slice(&mut self, v: longhands::border_image_slice::computed_value::T) {
         use gecko_bindings::structs::{NS_STYLE_BORDER_IMAGE_SLICE_NOFILL, NS_STYLE_BORDER_IMAGE_SLICE_FILL};
 
-        for (i, corner) in v.corners.iter().enumerate() {
+        % for side in SIDES:
-            corner.to_gecko_style_coord(&mut self.gecko.mBorderImageSlice.data_at_mut(i));
+        v.offsets.${side.ident}.to_gecko_style_coord(&mut self.gecko.mBorderImageSlice.data_at_mut(${side.index}));
-        }
+        % endfor
 
         let fill = if v.fill {
             NS_STYLE_BORDER_IMAGE_SLICE_FILL

components/style/properties/longhand/border.mako.rs

@@ -291,147 +291,9 @@ ${helpers.predefined_type("border-image-width", "BorderImageWidth",
     animation_value_type="none",
     boxed=True)}
 
-<%helpers:longhand name="border-image-slice" boxed="True" animation_value_type="none"
+${helpers.predefined_type("border-image-slice", "BorderImageSlice",
-                   spec="https://drafts.csswg.org/css-backgrounds/#border-image-slice">
+    initial_value="computed::NumberOrPercentage::Percentage(computed::Percentage(1.)).into()",
-    use std::fmt;
+    initial_specified_value="specified::NumberOrPercentage::Percentage(specified::Percentage(1.)).into()",
-    use style_traits::ToCss;
+    spec="https://drafts.csswg.org/css-backgrounds/#border-image-slice",
-    use values::computed::NumberOrPercentage as ComputedNumberOrPercentage;
+    animation_value_type="none",
-    use values::specified::{NumberOrPercentage, Percentage};
+    boxed=True)}
-
-    no_viewport_percentage!(SpecifiedValue);
-
-    pub mod computed_value {
-        use values::computed::NumberOrPercentage;
-        #[derive(Debug, Clone, PartialEq)]
-        #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
-        pub struct T {
-            pub corners: [NumberOrPercentage; 4],
-            pub fill: bool,
-        }
-    }
-
-    #[derive(Debug, Clone, PartialEq)]
-    #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
-    pub struct SpecifiedValue {
-        pub corners: Vec<NumberOrPercentage>,
-        pub fill: bool,
-    }
-
-    impl ToCss for computed_value::T {
-        fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-            try!(self.corners[0].to_css(dest));
-            try!(dest.write_str(" "));
-            try!(self.corners[1].to_css(dest));
-            try!(dest.write_str(" "));
-            try!(self.corners[2].to_css(dest));
-            try!(dest.write_str(" "));
-            try!(self.corners[3].to_css(dest));
-
-            if self.fill {
-                try!(dest.write_str(" fill"));
-            }
-            Ok(())
-        }
-    }
-    impl ToCss for SpecifiedValue {
-        fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-            try!(self.corners[0].to_css(dest));
-            for value in self.corners.iter().skip(1) {
-                try!(dest.write_str(" "));
-                try!(value.to_css(dest));
-            }
-
-            if self.fill {
-                try!(dest.write_str(" fill"));
-            }
-            Ok(())
-        }
-    }
-
-    #[inline]
-    pub fn get_initial_value() -> computed_value::T {
-        computed_value::T {
-            corners: [ComputedNumberOrPercentage::Percentage(Percentage(1.0)),
-                      ComputedNumberOrPercentage::Percentage(Percentage(1.0)),
-                      ComputedNumberOrPercentage::Percentage(Percentage(1.0)),
-                      ComputedNumberOrPercentage::Percentage(Percentage(1.0))],
-            fill: false,
-        }
-    }
-
-    #[inline]
-    pub fn get_initial_specified_value() -> SpecifiedValue {
-        SpecifiedValue {
-            corners: vec![NumberOrPercentage::Percentage(Percentage(1.0))],
-            fill: false,
-        }
-    }
-
-    impl ToComputedValue for SpecifiedValue {
-        type ComputedValue = computed_value::T;
-
-        #[inline]
-        fn to_computed_value(&self, context: &Context) -> computed_value::T {
-            let length = self.corners.len();
-            let corners = match length {
-                4 => [self.corners[0].to_computed_value(context),
-                      self.corners[1].to_computed_value(context),
-                      self.corners[2].to_computed_value(context),
-                      self.corners[3].to_computed_value(context)],
-                3 => [self.corners[0].to_computed_value(context),
-                      self.corners[1].to_computed_value(context),
-                      self.corners[2].to_computed_value(context),
-                      self.corners[1].to_computed_value(context)],
-                2 => [self.corners[0].to_computed_value(context),
-                      self.corners[1].to_computed_value(context),
-                      self.corners[0].to_computed_value(context),
-                      self.corners[1].to_computed_value(context)],
-                1 => [self.corners[0].to_computed_value(context),
-                      self.corners[0].to_computed_value(context),
-                      self.corners[0].to_computed_value(context),
-                      self.corners[0].to_computed_value(context)],
-                _ => unreachable!(),
-            };
-            computed_value::T {
-                corners: corners,
-                fill: self.fill,
-            }
-        }
-        #[inline]
-        fn from_computed_value(computed: &computed_value::T) -> Self {
-            SpecifiedValue {
-                corners: vec![ToComputedValue::from_computed_value(&computed.corners[0]),
-                              ToComputedValue::from_computed_value(&computed.corners[1]),
-                              ToComputedValue::from_computed_value(&computed.corners[2]),
-                              ToComputedValue::from_computed_value(&computed.corners[3])],
-                fill: computed.fill,
-            }
-        }
-    }
-
-    pub fn parse(context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
-        let mut fill = input.try(|input| input.expect_ident_matching("fill")).is_ok();
-
-        let mut values = vec![];
-        for _ in 0..4 {
-            let value = input.try(|input| NumberOrPercentage::parse_non_negative(context, input));
-            match value {
-                Ok(val) => values.push(val),
-                Err(_) => break,
-            }
-        }
-
-        if !fill {
-            fill = input.try(|input| input.expect_ident_matching("fill")).is_ok();
-        }
-
-        if !values.is_empty() {
-            Ok(SpecifiedValue {
-                corners: values,
-                fill: fill
-            })
-        } else {
-            Err(())
-        }
-    }
-</%helpers:longhand>

components/style/values/computed/border.rs

@@ -4,8 +4,9 @@
 
 //! Computed types for CSS values related to borders.
 
-use values::computed::Number;
+use values::computed::{Number, NumberOrPercentage};
 use values::computed::length::LengthOrPercentage;
+use values::generics::border::BorderImageSlice as GenericBorderImageSlice;
 use values::generics::border::BorderImageWidthSide as GenericBorderImageWidthSide;
 use values::generics::rect::Rect;
 
@@ -15,6 +16,9 @@ pub type BorderImageWidth = Rect<BorderImageWidthSide>;
 /// A computed value for a single side of a `border-image-width` property.
 pub type BorderImageWidthSide = GenericBorderImageWidthSide<LengthOrPercentage, Number>;
 
+/// A computed value for the `border-image-slice` property.
+pub type BorderImageSlice = GenericBorderImageSlice<NumberOrPercentage>;
+
 impl BorderImageWidthSide {
     /// Returns `1`.
     #[inline]

components/style/values/computed/mod.rs

@@ -24,7 +24,7 @@ use super::specified;
 
 pub use app_units::Au;
 pub use cssparser::Color as CSSColor;
-pub use self::border::{BorderImageWidth, BorderImageWidthSide};
+pub use self::border::{BorderImageSlice, BorderImageWidth, BorderImageWidthSide};
 pub use self::image::{Gradient, GradientItem, ImageLayer, LineDirection, Image, ImageRect};
 pub use self::rect::LengthOrNumberRect;
 pub use super::{Auto, Either, None_};

components/style/values/generics/border.rs

@@ -6,6 +6,7 @@
 
 use std::fmt;
 use style_traits::ToCss;
+use values::generics::rect::Rect;
 
 /// A generic value for a single side of a `border-image-width` property.
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
@@ -19,6 +20,16 @@ pub enum BorderImageWidthSide<LengthOrPercentage, Number> {
     Auto,
 }
 
+/// A generic value for the `border-image-slice` property.
+#[derive(Clone, Copy, Debug, HasViewportPercentage, PartialEq, ToComputedValue)]
+#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
+pub struct BorderImageSlice<NumberOrPercentage> {
+    /// The offsets.
+    pub offsets: Rect<NumberOrPercentage>,
+    /// Whether to fill the middle part.
+    pub fill: bool,
+}
+
 impl<L, N> ToCss for BorderImageWidthSide<L, N>
     where L: ToCss, N: ToCss,
 {
@@ -32,3 +43,29 @@ impl<L, N> ToCss for BorderImageWidthSide<L, N>
         }
     }
 }
+
+impl<N> From<N> for BorderImageSlice<N>
+    where N: Clone,
+{
+    #[inline]
+    fn from(value: N) -> Self {
+        Self {
+            offsets: value.into(),
+            fill: false,
+        }
+    }
+}
+
+impl<N> ToCss for BorderImageSlice<N>
+    where N: PartialEq + ToCss,
+{
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+        where W: fmt::Write
+    {
+        self.offsets.to_css(dest)?;
+        if self.fill {
+            dest.write_str(" fill")?;
+        }
+        Ok(())
+    }
+}

components/style/values/specified/border.rs

@@ -6,9 +6,10 @@
 
 use cssparser::Parser;
 use parser::{Parse, ParserContext};
+use values::generics::border::BorderImageSlice as GenericBorderImageSlice;
 use values::generics::border::BorderImageWidthSide as GenericBorderImageWidthSide;
 use values::generics::rect::Rect;
-use values::specified::Number;
+use values::specified::{Number, NumberOrPercentage};
 use values::specified::length::LengthOrPercentage;
 
 /// A specified value for the `border-image-width` property.
@@ -17,6 +18,9 @@ pub type BorderImageWidth = Rect<BorderImageWidthSide>;
 /// A specified value for a single side of a `border-image-width` property.
 pub type BorderImageWidthSide = GenericBorderImageWidthSide<LengthOrPercentage, Number>;
 
+/// A specified value for the `border-image-slice` property.
+pub type BorderImageSlice = GenericBorderImageSlice<NumberOrPercentage>;
+
 impl BorderImageWidthSide {
     /// Returns `1`.
     #[inline]
@@ -39,3 +43,17 @@ impl Parse for BorderImageWidthSide {
         Ok(GenericBorderImageWidthSide::Number(num))
     }
 }
+
+impl Parse for BorderImageSlice {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
+        let mut fill = input.try(|i| i.expect_ident_matching("fill")).is_ok();
+        let offsets = Rect::parse_with(context, input, NumberOrPercentage::parse_non_negative)?;
+        if !fill {
+            fill = input.try(|i| i.expect_ident_matching("fill")).is_ok();
+        }
+        Ok(GenericBorderImageSlice {
+            offsets: offsets,
+            fill: fill,
+        })
+    }
+}

components/style/values/specified/mod.rs

@@ -31,7 +31,7 @@ use values::specified::calc::CalcNode;
 #[cfg(feature = "gecko")]
 pub use self::align::{AlignItems, AlignJustifyContent, AlignJustifySelf, JustifyItems};
 pub use self::rect::LengthOrNumberRect;
-pub use self::border::{BorderImageWidth, BorderImageWidthSide};
+pub use self::border::{BorderImageSlice, BorderImageWidth, BorderImageWidthSide};
 pub use self::color::Color;
 pub use super::generics::grid::GridLine;
 pub use self::image::{ColorStop, EndingShape as GradientEndingShape, Gradient};