style: Add a Zero trait that doesn't require Add, and use it in place of num_traits and IsZeroLength.

Use it to be consistent in InsetRect serialization and storage between Servo and
Gecko.

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

components/style/values/specified/angle.rs

@@ -101,6 +101,11 @@ impl Angle {
         }
     }
 
+    /// Return `0deg`.
+    pub fn zero() -> Self {
+        Self::from_degrees(0.0, false)
+    }
+
     /// Returns the value of the angle in degrees, mostly for `calc()`.
     #[inline]
     pub fn degrees(&self) -> CSSFloat {
@@ -113,12 +118,6 @@ impl Angle {
         self.was_calc
     }
 
-    /// Returns `0deg`.
-    #[inline]
-    pub fn zero() -> Self {
-        Self::from_degrees(0.0, false)
-    }
-
     /// Returns an `Angle` parsed from a `calc()` expression.
     pub fn from_calc(degrees: CSSFloat) -> Self {
         Angle {

components/style/values/specified/basic_shape.rs

@@ -18,6 +18,7 @@ use crate::values::specified::position::{HorizontalPosition, Position, VerticalP
 use crate::values::specified::url::SpecifiedUrl;
 use crate::values::specified::SVGPathData;
 use crate::values::specified::{LengthPercentage, NonNegativeLengthPercentage};
+use crate::Zero;
 use cssparser::Parser;
 use std::fmt::{self, Write};
 use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
@@ -202,9 +203,9 @@ impl InsetRect {
     ) -> Result<Self, ParseError<'i>> {
         let rect = Rect::parse_with(context, input, LengthPercentage::parse)?;
         let round = if input.try(|i| i.expect_ident_matching("round")).is_ok() {
-            Some(BorderRadius::parse(context, input)?)
+            BorderRadius::parse(context, input)?
         } else {
-            None
+            BorderRadius::zero()
         };
         Ok(generic::InsetRect { rect, round })
     }

components/style/values/specified/border.rs

@@ -15,6 +15,7 @@ use crate::values::generics::rect::Rect;
 use crate::values::generics::size::Size2D;
 use crate::values::specified::length::{NonNegativeLength, NonNegativeLengthPercentage};
 use crate::values::specified::{AllowQuirks, NonNegativeNumber, NonNegativeNumberOrPercentage};
+use crate::Zero;
 use cssparser::Parser;
 use std::fmt::{self, Write};
 use style_traits::{CssWriter, ParseError, ToCss};

components/style/values/specified/effects.rs

@@ -20,6 +20,7 @@ use crate::values::specified::url::SpecifiedUrl;
 use crate::values::specified::{Angle, NumberOrPercentage};
 #[cfg(not(feature = "gecko"))]
 use crate::values::Impossible;
+use crate::Zero;
 use cssparser::{self, BasicParseErrorKind, Parser, Token};
 use style_traits::{ParseError, StyleParseErrorKind, ValueParseErrorKind};
 

components/style/values/specified/length.rs

@@ -14,11 +14,11 @@ use crate::values::generics::length as generics;
 use crate::values::generics::length::{
     GenericLengthOrNumber, MaxSize as GenericMaxSize, Size as GenericSize,
 };
-use crate::values::generics::transform::IsZeroLength;
 use crate::values::generics::NonNegative;
 use crate::values::specified::calc::CalcNode;
 use crate::values::specified::NonNegativeNumber;
 use crate::values::{Auto, CSSFloat, Either, Normal};
+use crate::Zero;
 use app_units::Au;
 use cssparser::{Parser, Token};
 use euclid::Size2D;
@@ -477,21 +477,6 @@ impl NoCalcLength {
         })
     }
 
-    #[inline]
-    /// Returns a `zero` length.
-    pub fn zero() -> NoCalcLength {
-        NoCalcLength::Absolute(AbsoluteLength::Px(0.))
-    }
-
-    #[inline]
-    /// Checks whether the length value is zero.
-    pub fn is_zero(&self) -> bool {
-        match *self {
-            NoCalcLength::Absolute(length) => length.is_zero(),
-            _ => false,
-        }
-    }
-
     /// Get a px value without context.
     #[inline]
     pub fn to_computed_pixel_length_without_context(&self) -> Result<CSSFloat, ()> {
@@ -510,9 +495,12 @@ impl NoCalcLength {
 
 impl SpecifiedValueInfo for NoCalcLength {}
 
-impl IsZeroLength for NoCalcLength {
-    #[inline]
-    fn is_zero_length(&self) -> bool {
+impl Zero for NoCalcLength {
+    fn zero() -> Self {
+        NoCalcLength::Absolute(AbsoluteLength::Px(0.))
+    }
+
+    fn is_zero(&self) -> bool {
         match *self {
             NoCalcLength::Absolute(v) => v.is_zero(),
             NoCalcLength::FontRelative(v) => v.is_zero(),
@@ -584,12 +572,6 @@ impl Mul<CSSFloat> for ViewportPercentageLength {
 }
 
 impl Length {
-    #[inline]
-    /// Returns a `zero` length.
-    pub fn zero() -> Length {
-        Length::NoCalc(NoCalcLength::zero())
-    }
-
     #[inline]
     fn parse_internal<'i, 't>(
         context: &ParserContext,
@@ -672,6 +654,21 @@ impl Parse for Length {
     }
 }
 
+impl Zero for Length {
+    fn zero() -> Self {
+        Length::NoCalc(NoCalcLength::zero())
+    }
+
+    fn is_zero(&self) -> bool {
+        // FIXME(emilio): Seems a bit weird to treat calc() unconditionally as
+        // non-zero here?
+        match *self {
+            Length::NoCalc(ref l) => l.is_zero(),
+            Length::Calc(..) => false,
+        }
+    }
+}
+
 impl Length {
     /// Parses a length, with quirks.
     pub fn parse_quirky<'i, 't>(
@@ -711,12 +708,6 @@ impl From<Length> for NonNegativeLength {
 }
 
 impl NonNegativeLength {
-    /// Returns a `zero` length.
-    #[inline]
-    pub fn zero() -> Self {
-        Length::zero().into()
-    }
-
     /// Get an absolute length from a px value.
     #[inline]
     pub fn from_px(px_value: CSSFloat) -> Self {
@@ -801,12 +792,6 @@ impl Parse for LengthPercentage {
 }
 
 impl LengthPercentage {
-    #[inline]
-    /// Returns a `zero` length.
-    pub fn zero() -> LengthPercentage {
-        LengthPercentage::Length(NoCalcLength::zero())
-    }
-
     #[inline]
     /// Returns a `0%` value.
     pub fn zero_percent() -> LengthPercentage {
@@ -898,11 +883,14 @@ impl LengthPercentage {
     }
 }
 
-impl IsZeroLength for LengthPercentage {
-    #[inline]
-    fn is_zero_length(&self) -> bool {
+impl Zero for LengthPercentage {
+    fn zero() -> Self {
+        LengthPercentage::Length(NoCalcLength::zero())
+    }
+
+    fn is_zero(&self) -> bool {
         match *self {
-            LengthPercentage::Length(l) => l.is_zero_length(),
+            LengthPercentage::Length(l) => l.is_zero(),
             LengthPercentage::Percentage(p) => p.0 == 0.0,
             LengthPercentage::Calc(_) => false,
         }
@@ -913,11 +901,6 @@ impl IsZeroLength for LengthPercentage {
 pub type LengthPercentageOrAuto = generics::LengthPercentageOrAuto<LengthPercentage>;
 
 impl LengthPercentageOrAuto {
-    /// Returns a value representing a `0` length.
-    pub fn zero() -> Self {
-        generics::LengthPercentageOrAuto::LengthPercentage(LengthPercentage::zero())
-    }
-
     /// Returns a value representing `0%`.
     #[inline]
     pub fn zero_percent() -> Self {
@@ -943,11 +926,6 @@ pub type NonNegativeLengthPercentageOrAuto =
     generics::LengthPercentageOrAuto<NonNegativeLengthPercentage>;
 
 impl NonNegativeLengthPercentageOrAuto {
-    /// Returns a value representing a `0` length.
-    pub fn zero() -> Self {
-        generics::LengthPercentageOrAuto::LengthPercentage(NonNegativeLengthPercentage::zero())
-    }
-
     /// Returns a value representing `0%`.
     #[inline]
     pub fn zero_percent() -> Self {
@@ -997,12 +975,6 @@ impl Parse for NonNegativeLengthPercentage {
 }
 
 impl NonNegativeLengthPercentage {
-    #[inline]
-    /// Returns a `zero` length.
-    pub fn zero() -> Self {
-        NonNegative(LengthPercentage::zero())
-    }
-
     #[inline]
     /// Returns a `0%` value.
     pub fn zero_percent() -> Self {

components/style/values/specified/position.rs

@@ -17,6 +17,7 @@ use crate::values::generics::position::ZIndex as GenericZIndex;
 use crate::values::specified::transform::OriginComponent;
 use crate::values::specified::{AllowQuirks, Integer, LengthPercentage};
 use crate::values::{Either, None_};
+use crate::Zero;
 use cssparser::Parser;
 use selectors::parser::SelectorParseErrorKind;
 use servo_arc::Arc;

components/style/values/specified/transform.rs

@@ -11,6 +11,7 @@ use crate::values::generics::transform as generic;
 use crate::values::generics::transform::{Matrix, Matrix3D};
 use crate::values::specified::position::{Side, X, Y};
 use crate::values::specified::{self, Angle, Integer, Length, LengthPercentage, Number};
+use crate::Zero;
 use cssparser::Parser;
 use style_traits::{ParseError, StyleParseErrorKind};