Rename LengthOrPercentageOrAutoOrContent to FlexBasis

components/layout/flex.rs

@@ -25,8 +25,9 @@ use style::computed_values::border_collapse;
 use style::logical_geometry::{Direction, LogicalSize};
 use style::properties::ServoComputedValues;
 use style::servo::restyle_damage::{REFLOW, REFLOW_OUT_OF_FLOW};
-use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto};
+use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto, LengthOrPercentageOrNone};
-use style::values::computed::{LengthOrPercentageOrAutoOrContent, LengthOrPercentageOrNone};
+use style::values::computed::flex::FlexBasis;
+use style::values::generics::flex::FlexBasis as GenericFlexBasis;
 
 /// The size of an axis. May be a specified size, a min/max
 /// constraint, or an unlimited size
@@ -67,23 +68,25 @@ impl AxisSize {
 /// and the container size, then return the used value of flex basis. it can be used to help
 /// determining the flex base size and to indicate whether the main size of the item
 /// is definite after flex size resolving.
-fn from_flex_basis(flex_basis: LengthOrPercentageOrAutoOrContent,
+fn from_flex_basis(
+    flex_basis: FlexBasis,
     main_length: LengthOrPercentageOrAuto,
-                   containing_length: Option<Au>) -> MaybeAuto {
+    containing_length: Option<Au>
+) -> MaybeAuto {
     match (flex_basis, containing_length) {
-        (LengthOrPercentageOrAutoOrContent::Length(length), _) =>
+        (GenericFlexBasis::Length(LengthOrPercentage::Length(length)), _) =>
             MaybeAuto::Specified(length),
-        (LengthOrPercentageOrAutoOrContent::Percentage(percent), Some(size)) =>
+        (GenericFlexBasis::Length(LengthOrPercentage::Percentage(percent)), Some(size)) =>
             MaybeAuto::Specified(size.scale_by(percent.0)),
-        (LengthOrPercentageOrAutoOrContent::Percentage(_), None) =>
+        (GenericFlexBasis::Length(LengthOrPercentage::Percentage(_)), None) =>
             MaybeAuto::Auto,
-        (LengthOrPercentageOrAutoOrContent::Calc(calc), _) =>
+        (GenericFlexBasis::Length(LengthOrPercentage::Calc(calc)), _) =>
             MaybeAuto::from_option(calc.to_used_value(containing_length)),
-        (LengthOrPercentageOrAutoOrContent::Content, _) =>
+        (GenericFlexBasis::Content, _) =>
             MaybeAuto::Auto,
-        (LengthOrPercentageOrAutoOrContent::Auto, Some(size)) =>
+        (GenericFlexBasis::Auto, Some(size)) =>
             MaybeAuto::from_style(main_length, size),
-        (LengthOrPercentageOrAutoOrContent::Auto, None) => {
+        (GenericFlexBasis::Auto, None) => {
             if let LengthOrPercentageOrAuto::Length(length) = main_length {
                 MaybeAuto::Specified(length)
             } else {

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

@@ -170,9 +170,8 @@ ${helpers.predefined_type("order", "Integer", "0",
 % else:
     // FIXME: This property should be animatable.
     ${helpers.predefined_type("flex-basis",
-                              "LengthOrPercentageOrAutoOrContent",
+                              "FlexBasis",
-                              "computed::LengthOrPercentageOrAutoOrContent::Auto",
+                              "computed::FlexBasis::auto()",
-                              "parse_non_negative",
                               spec="https://drafts.csswg.org/css-flexbox/#flex-basis-property",
                               extra_prefixes="webkit",
                               animation_value_type="none")}

components/style/values/computed/flex.rs

@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! Computed types for CSS values related to flexbox.
+
+use values::computed::length::LengthOrPercentage;
+use values::generics::flex::FlexBasis as GenericFlexBasis;
+
+/// A computed value for the `flex-basis` property.
+pub type FlexBasis = GenericFlexBasis<LengthOrPercentage>;

components/style/values/computed/length.rs

@@ -421,80 +421,6 @@ impl ToComputedValue for specified::LengthOrPercentageOrAuto {
     }
 }
 
-#[allow(missing_docs)]
-#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
-#[derive(Clone, Copy, PartialEq, ToCss)]
-pub enum LengthOrPercentageOrAutoOrContent {
-    Length(Au),
-    Percentage(Percentage),
-    Calc(CalcLengthOrPercentage),
-    Auto,
-    Content
-}
-
-impl fmt::Debug for LengthOrPercentageOrAutoOrContent {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            LengthOrPercentageOrAutoOrContent::Length(length) => write!(f, "{:?}", length),
-            LengthOrPercentageOrAutoOrContent::Percentage(percentage) => write!(f, "{}%", percentage.0 * 100.),
-            LengthOrPercentageOrAutoOrContent::Calc(calc) => write!(f, "{:?}", calc),
-            LengthOrPercentageOrAutoOrContent::Auto => write!(f, "auto"),
-            LengthOrPercentageOrAutoOrContent::Content => write!(f, "content")
-        }
-    }
-}
-
-impl ToComputedValue for specified::LengthOrPercentageOrAutoOrContent {
-    type ComputedValue = LengthOrPercentageOrAutoOrContent;
-
-    #[inline]
-    fn to_computed_value(&self, context: &Context) -> LengthOrPercentageOrAutoOrContent {
-        match *self {
-            specified::LengthOrPercentageOrAutoOrContent::Length(ref value) => {
-                LengthOrPercentageOrAutoOrContent::Length(value.to_computed_value(context))
-            },
-            specified::LengthOrPercentageOrAutoOrContent::Percentage(value) => {
-                LengthOrPercentageOrAutoOrContent::Percentage(value)
-            },
-            specified::LengthOrPercentageOrAutoOrContent::Calc(ref calc) => {
-                LengthOrPercentageOrAutoOrContent::Calc(calc.to_computed_value(context))
-            },
-            specified::LengthOrPercentageOrAutoOrContent::Auto => {
-                LengthOrPercentageOrAutoOrContent::Auto
-            },
-            specified::LengthOrPercentageOrAutoOrContent::Content => {
-                LengthOrPercentageOrAutoOrContent::Content
-            }
-        }
-    }
-
-
-    #[inline]
-    fn from_computed_value(computed: &LengthOrPercentageOrAutoOrContent) -> Self {
-        match *computed {
-            LengthOrPercentageOrAutoOrContent::Auto => {
-                specified::LengthOrPercentageOrAutoOrContent::Auto
-            }
-            LengthOrPercentageOrAutoOrContent::Content => {
-                specified::LengthOrPercentageOrAutoOrContent::Content
-            }
-            LengthOrPercentageOrAutoOrContent::Length(value) => {
-                specified::LengthOrPercentageOrAutoOrContent::Length(
-                    ToComputedValue::from_computed_value(&value)
-                )
-            }
-            LengthOrPercentageOrAutoOrContent::Percentage(value) => {
-                specified::LengthOrPercentageOrAutoOrContent::Percentage(value)
-            }
-            LengthOrPercentageOrAutoOrContent::Calc(calc) => {
-                specified::LengthOrPercentageOrAutoOrContent::Calc(
-                    Box::new(ToComputedValue::from_computed_value(&calc))
-                )
-            }
-        }
-    }
-}
-
 #[allow(missing_docs)]
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
 #[derive(Clone, Copy, PartialEq, ToCss)]

components/style/values/computed/mod.rs

@@ -28,6 +28,7 @@ pub use self::background::BackgroundSize;
 pub use self::border::{BorderImageSlice, BorderImageWidth, BorderImageSideWidth};
 pub use self::border::{BorderRadius, BorderCornerRadius};
 pub use self::color::{Color, RGBAColor};
+pub use self::flex::FlexBasis;
 pub use self::image::{Gradient, GradientItem, ImageLayer, LineDirection, Image, ImageRect};
 #[cfg(feature = "gecko")]
 pub use self::gecko::ScrollSnapPoint;
@@ -38,9 +39,8 @@ pub use super::specified::{AlignItems, AlignJustifyContent, AlignJustifySelf, Ju
 pub use super::specified::{BorderStyle, Percentage, UrlOrNone};
 pub use super::generics::grid::GridLine;
 pub use super::specified::url::SpecifiedUrl;
-pub use self::length::{CalcLengthOrPercentage, Length, LengthOrNumber, LengthOrPercentage, LengthOrPercentageOrAuto};
+pub use self::length::{CalcLengthOrPercentage, Length, LengthOrNone, LengthOrNumber, LengthOrPercentage};
-pub use self::length::{LengthOrPercentageOrAutoOrContent, LengthOrPercentageOrNone, LengthOrNone};
+pub use self::length::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone, MaxLength, MozLength};
-pub use self::length::{MaxLength, MozLength};
 pub use self::position::Position;
 pub use self::text::{InitialLetter, LetterSpacing, LineHeight, WordSpacing};
 pub use self::transform::{TimingFunction, TransformOrigin};
@@ -49,6 +49,7 @@ pub mod background;
 pub mod basic_shape;
 pub mod border;
 pub mod color;
+pub mod flex;
 pub mod image;
 #[cfg(feature = "gecko")]
 pub mod gecko;

components/style/values/generics/flex.rs

@@ -0,0 +1,37 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! Generic types for CSS values related to flexbox.
+
+use values::specified::Percentage;
+
+/// A generic value for the `flex-basis` property.
+#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
+#[derive(Clone, Copy, Debug, HasViewportPercentage, PartialEq, ToComputedValue, ToCss)]
+pub enum FlexBasis<LengthOrPercentage> {
+    /// `auto`
+    Auto,
+    /// `content`
+    Content,
+    /// `<length-percentage>`
+    Length(LengthOrPercentage),
+}
+
+impl<L> FlexBasis<L> {
+    /// Returns `auto`.
+    #[inline]
+    pub fn auto() -> Self {
+        FlexBasis::Auto
+    }
+}
+
+impl<L> FlexBasis<L>
+where Percentage: Into<L>,
+{
+    /// Returns `0%`.
+    #[inline]
+    pub fn zero_percent() -> Self {
+        FlexBasis::Length(Percentage(0.).into())
+    }
+}

components/style/values/generics/mod.rs

@@ -16,6 +16,7 @@ use values::specified::url::SpecifiedUrl;
 pub mod background;
 pub mod basic_shape;
 pub mod border;
+pub mod flex;
 #[cfg(feature = "gecko")]
 pub mod gecko;
 pub mod grid;

components/style/values/specified/flex.rs

@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! Specified types for CSS values related to flexbox.
+
+use cssparser::Parser;
+use parser::{Parse, ParserContext};
+use style_traits::ParseError;
+use values::generics::flex::FlexBasis as GenericFlexBasis;
+use values::specified::length::LengthOrPercentage;
+
+/// A specified value for the `flex-basis` property.
+pub type FlexBasis = GenericFlexBasis<LengthOrPercentage>;
+
+impl Parse for FlexBasis {
+    fn parse<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>)
+    -> Result<Self, ParseError<'i>> {
+        if let Ok(length) = input.try(|i| LengthOrPercentage::parse_non_negative(context, i)) {
+            return Ok(GenericFlexBasis::Length(length));
+        }
+        try_match_ident_ignore_ascii_case! { input.expect_ident()?,
+            "auto" => Ok(GenericFlexBasis::Auto),
+            "content" => Ok(GenericFlexBasis::Content),
+        }
+    }
+}

components/style/values/specified/length.rs

@@ -1101,72 +1101,6 @@ pub type LengthOrNormal = Either<Length, Normal>;
 /// Either a `<length>` or the `auto` keyword.
 pub type LengthOrAuto = Either<Length, Auto>;
 
-/// Either a `<length>` or a `<percentage>` or the `auto` keyword or the
-/// `content` keyword.
-#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
-#[derive(Clone, Debug, HasViewportPercentage, PartialEq, ToCss)]
-pub enum LengthOrPercentageOrAutoOrContent {
-    /// A `<length>`.
-    Length(NoCalcLength),
-    /// A percentage.
-    Percentage(Percentage),
-    /// A `calc` node.
-    Calc(Box<CalcLengthOrPercentage>),
-    /// The `auto` keyword.
-    Auto,
-    /// The `content` keyword.
-    Content
-}
-
-impl LengthOrPercentageOrAutoOrContent {
-    /// Parse a non-negative LengthOrPercentageOrAutoOrContent.
-    pub fn parse_non_negative<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-                                      -> Result<Self, ParseError<'i>> {
-        let num_context = AllowedLengthType::NonNegative;
-        let token = try!(input.next());
-        match token {
-            Token::Dimension { value, ref unit, .. } if num_context.is_ok(context.parsing_mode, value) => {
-                NoCalcLength::parse_dimension(context, value, unit)
-                             .map(LengthOrPercentageOrAutoOrContent::Length)
-            }
-            Token::Percentage { unit_value, .. } if num_context.is_ok(context.parsing_mode, unit_value) => {
-                Ok(LengthOrPercentageOrAutoOrContent::Percentage(Percentage(unit_value)))
-            }
-            Token::Number { value, .. } if value == 0. => {
-                Ok(Self::zero())
-            }
-            Token::Ident(ref value) if value.eq_ignore_ascii_case("auto") => {
-                Ok(LengthOrPercentageOrAutoOrContent::Auto)
-            }
-            Token::Ident(ref value) if value.eq_ignore_ascii_case("content") => {
-                Ok(LengthOrPercentageOrAutoOrContent::Content)
-            }
-            Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
-                let calc = try!(input.parse_nested_block(|i| {
-                    CalcNode::parse_length_or_percentage(context, i, num_context)
-                }));
-                Ok(LengthOrPercentageOrAutoOrContent::Calc(Box::new(calc)))
-            }
-            _ => Err(())
-        }.map_err(|()| BasicParseError::UnexpectedToken(token).into())
-    }
-
-    /// Returns the `auto` value.
-    pub fn auto() -> Self {
-        LengthOrPercentageOrAutoOrContent::Auto
-    }
-
-    /// Returns a value representing a `0` length.
-    pub fn zero() -> Self {
-        LengthOrPercentageOrAutoOrContent::Length(NoCalcLength::zero())
-    }
-
-    /// Returns a value representing `0%`.
-    pub fn zero_percent() -> Self {
-        LengthOrPercentageOrAutoOrContent::Percentage(Percentage::zero())
-    }
-}
-
 /// Either a `<length>` or a `<number>`.
 pub type LengthOrNumber = Either<Length, Number>;
 

components/style/values/specified/mod.rs

@@ -33,16 +33,17 @@ pub use self::background::BackgroundSize;
 pub use self::border::{BorderCornerRadius, BorderImageSlice, BorderImageWidth};
 pub use self::border::{BorderImageSideWidth, BorderRadius, BorderSideWidth};
 pub use self::color::{Color, RGBAColor};
-pub use self::rect::LengthOrNumberRect;
+pub use self::flex::FlexBasis;
 #[cfg(feature = "gecko")]
 pub use self::gecko::ScrollSnapPoint;
 pub use self::image::{ColorStop, EndingShape as GradientEndingShape, Gradient};
 pub use self::image::{GradientItem, GradientKind, Image, ImageRect, ImageLayer};
-pub use self::length::AbsoluteLength;
+pub use self::length::{AbsoluteLength, CalcLengthOrPercentage, CharacterWidth};
-pub use self::length::{FontRelativeLength, ViewportPercentageLength, CharacterWidth, Length, CalcLengthOrPercentage};
+pub use self::length::{FontRelativeLength, Length, LengthOrNone, LengthOrNumber};
-pub use self::length::{Percentage, LengthOrNone, LengthOrNumber, LengthOrPercentage, LengthOrPercentageOrAuto};
+pub use self::length::{LengthOrPercentage, LengthOrPercentageOrAuto};
-pub use self::length::{LengthOrPercentageOrNone, LengthOrPercentageOrAutoOrContent, NoCalcLength};
+pub use self::length::{LengthOrPercentageOrNone, MaxLength, MozLength};
-pub use self::length::{MaxLength, MozLength};
+pub use self::length::{NoCalcLength, Percentage, ViewportPercentageLength};
+pub use self::rect::LengthOrNumberRect;
 pub use self::position::{Position, PositionComponent};
 pub use self::text::{InitialLetter, LetterSpacing, LineHeight, WordSpacing};
 pub use self::transform::{TimingFunction, TransformOrigin};
@@ -55,6 +56,7 @@ pub mod basic_shape;
 pub mod border;
 pub mod calc;
 pub mod color;
+pub mod flex;
 #[cfg(feature = "gecko")]
 pub mod gecko;
 pub mod grid;

tests/unit/style/properties/serialization.rs

@@ -6,11 +6,10 @@ use properties::{parse, parse_input};
 use style::computed_values::display::T::inline_block;
 use style::properties::{PropertyDeclaration, Importance, PropertyId};
 use style::properties::parse_property_declaration_list;
-use style::values::{RGBA, Auto};
+use style::values::{CustomIdent, RGBA, Auto};
-use style::values::CustomIdent;
+use style::values::generics::flex::FlexBasis;
 use style::values::specified::{BorderStyle, BorderSideWidth, Color};
-use style::values::specified::{Length, LengthOrPercentage};
+use style::values::specified::{Length, LengthOrPercentage, LengthOrPercentageOrAuto};
-use style::values::specified::{LengthOrPercentageOrAuto, LengthOrPercentageOrAutoOrContent};
 use style::values::specified::{NoCalcLength, PositionComponent};
 use style::values::specified::position::Y;
 use style::values::specified::url::SpecifiedUrl;
@@ -564,7 +563,7 @@ mod shorthand_serialization {
         let grow = Number::new(2f32);
         let shrink = Number::new(3f32);
         let basis =
-            LengthOrPercentageOrAutoOrContent::Percentage(Percentage(0.5f32));
+            FlexBasis::Length(Percentage(0.5f32).into());
 
         properties.push(PropertyDeclaration::FlexGrow(grow));
         properties.push(PropertyDeclaration::FlexShrink(shrink));