style: Use Rust types for some misc properties.

-moz-tab-size, border-image-outset and border-image-slice.

This is not a particularly interesting patch, just removes some code. We can
remove way more code when a few related properties are also ported.

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

components/style/values/generics/border.rs

@@ -26,7 +26,8 @@ pub enum BorderImageSideWidth<LengthPercentage, Number> {
 #[derive(
     Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToComputedValue, ToCss,
 )]
-pub struct BorderImageSlice<NumberOrPercentage> {
+#[repr(C)]
+pub struct GenericBorderImageSlice<NumberOrPercentage> {
     /// The offsets.
     #[css(field_bound)]
     pub offsets: Rect<NumberOrPercentage>,
@@ -35,6 +36,8 @@ pub struct BorderImageSlice<NumberOrPercentage> {
     pub fill: bool,
 }
 
+pub use self::GenericBorderImageSlice as BorderImageSlice;
+
 /// A generic value for the `border-*-radius` longhand properties.
 #[derive(
     Animate,

components/style/values/generics/length.rs

@@ -8,6 +8,7 @@ use crate::parser::{Parse, ParserContext};
 #[cfg(feature = "gecko")]
 use crate::values::computed::ExtremumLength;
 use cssparser::Parser;
+use num_traits::Zero;
 use style_traits::ParseError;
 
 /// A `<length-percentage> | auto` value.
@@ -155,3 +156,53 @@ impl<LengthPercentage> MaxSize<LengthPercentage> {
         MaxSize::None
     }
 }
+
+/// A generic `<length>` | `<number>` value for the `-moz-tab-size` property.
+#[derive(
+    Animate,
+    Clone,
+    ComputeSquaredDistance,
+    Copy,
+    Debug,
+    MallocSizeOf,
+    PartialEq,
+    SpecifiedValueInfo,
+    ToAnimatedValue,
+    ToAnimatedZero,
+    ToComputedValue,
+    ToCss,
+)]
+#[repr(C, u8)]
+pub enum GenericLengthOrNumber<L, N> {
+    /// A length.
+    Length(L),
+    /// A number.
+    Number(N),
+}
+
+pub use self::GenericLengthOrNumber as LengthOrNumber;
+
+impl<L: Parse, N: Parse> Parse for LengthOrNumber<L, N> {
+    fn parse<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self, ParseError<'i>> {
+        if let Ok(number) = input.try(|i| N::parse(context, i)) {
+            // Numbers need to be parsed first because `0` must be recognised
+            // as the number `0` and not the length `0px`.
+            return Ok(LengthOrNumber::Number(number));
+        }
+
+        Ok(LengthOrNumber::Length(L::parse(context, input)?))
+    }
+}
+
+impl<L, N> LengthOrNumber<L, N> {
+    /// Returns `0`.
+    pub fn zero() -> Self
+    where
+        N: Zero,
+    {
+        LengthOrNumber::Number(num_traits::Zero::zero())
+    }
+}

components/style/values/generics/mod.rs

@@ -9,6 +9,8 @@ use super::CustomIdent;
 use crate::counter_style::{parse_counter_style_name, Symbols};
 use crate::parser::{Parse, ParserContext};
 use cssparser::Parser;
+use num_traits::Zero;
+use std::ops::Add;
 use style_traits::{KeywordsCollectFn, ParseError};
 use style_traits::{SpecifiedValueInfo, StyleParseErrorKind};
 
@@ -177,6 +179,24 @@ impl SpecifiedValueInfo for CounterStyleOrNone {
 #[repr(transparent)]
 pub struct NonNegative<T>(pub T);
 
+impl <T: Add<Output = T>> Add<NonNegative<T>> for NonNegative<T> {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        NonNegative(self.0 + other.0)
+    }
+}
+
+impl <T: Zero> Zero for NonNegative<T> {
+    fn is_zero(&self) -> bool {
+        self.0.is_zero()
+    }
+
+    fn zero() -> Self {
+        NonNegative(T::zero())
+    }
+}
+
 /// A wrapper of greater-than-or-equal-to-one values.
 #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
 #[derive(

components/style/values/generics/text.rs

@@ -149,25 +149,3 @@ impl<N, L> LineHeight<N, L> {
         LineHeight::Normal
     }
 }
-
-/// A generic value for the `-moz-tab-size` property.
-#[derive(
-    Animate,
-    Clone,
-    ComputeSquaredDistance,
-    Copy,
-    Debug,
-    MallocSizeOf,
-    PartialEq,
-    SpecifiedValueInfo,
-    ToAnimatedValue,
-    ToAnimatedZero,
-    ToComputedValue,
-    ToCss,
-)]
-pub enum MozTabSize<Number, Length> {
-    /// A number.
-    Number(Number),
-    /// A length.
-    Length(Length),
-}