Auto merge of #19966 - emilio:bye-gecko-size, r=nox

style: Get rid of gecko_size_type.

It's a hack, should die.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/19966)
<!-- Reviewable:end -->

components/style/values/computed/length.rs

@@ -5,13 +5,15 @@
 //! `<length>` computed values, and related ones.
 
 use app_units::Au;
+use logical_geometry::WritingMode;
 use ordered_float::NotNaN;
+use properties::LonghandId;
 use std::fmt::{self, Write};
 use std::ops::{Add, Neg};
 use style_traits::{CssWriter, ToCss};
 use style_traits::values::specified::AllowedNumericType;
 use super::{Number, ToComputedValue, Context, Percentage};
-use values::{Auto, CSSFloat, Either, ExtremumLength, None_, Normal, specified};
+use values::{Auto, CSSFloat, Either, None_, Normal, specified};
 use values::animated::{Animate, Procedure, ToAnimatedZero};
 use values::computed::NonNegativeNumber;
 use values::distance::{ComputeSquaredDistance, SquaredDistance};
@@ -874,7 +876,58 @@ pub type NonNegativeLengthOrNormal = Either<NonNegativeLength, Normal>;
 /// Either a computed NonNegativeLength or a NonNegativeNumber value.
 pub type NonNegativeLengthOrNumber = Either<NonNegativeLength, NonNegativeNumber>;
 
-/// A value suitable for a `min-width`, `min-height`, `width` or `height` property.
+/// A type for possible values for min- and max- flavors of width, height,
+/// block-size, and inline-size.
+#[allow(missing_docs)]
+#[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
+#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, Parse, PartialEq, ToCss)]
+pub enum ExtremumLength {
+    MozMaxContent,
+    MozMinContent,
+    MozFitContent,
+    MozAvailable,
+}
+
+impl ExtremumLength {
+    /// Returns whether this size keyword can be used for the given writing-mode
+    /// and property.
+    ///
+    /// TODO: After these values are supported for both axes (and maybe
+    /// unprefixed, see bug 1322780) all this complexity can go away, and
+    /// everything can be derived (no need for uncacheable stuff).
+    fn valid_for(&self, wm: WritingMode, longhand: LonghandId) -> bool {
+        // We only make sense on the inline axis.
+        match longhand {
+            // FIXME(emilio): The flex-basis thing is not quite clear...
+            LonghandId::FlexBasis |
+            LonghandId::MinWidth |
+            LonghandId::MaxWidth |
+            LonghandId::Width => !wm.is_vertical(),
+
+            LonghandId::MinHeight |
+            LonghandId::MaxHeight |
+            LonghandId::Height => wm.is_vertical(),
+
+            LonghandId::MinInlineSize |
+            LonghandId::MaxInlineSize |
+            LonghandId::InlineSize => true,
+            // The block-* properties are rejected at parse-time, so they're
+            // unexpected here.
+            _ => {
+                debug_assert!(
+                    false,
+                    "Unexpected property using ExtremumLength: {:?}",
+                    longhand,
+                );
+                false
+            }
+        }
+    }
+}
+
+/// A value suitable for a `min-width`, `min-height`, `width` or `height`
+/// property.
+///
 /// See values/specified/length.rs for more details.
 #[allow(missing_docs)]
 #[cfg_attr(feature = "servo", derive(MallocSizeOf))]
@@ -888,6 +941,7 @@ pub enum MozLength {
 
 impl MozLength {
     /// Returns the `auto` value.
+    #[inline]
     pub fn auto() -> Self {
         MozLength::LengthOrPercentageOrAuto(LengthOrPercentageOrAuto::Auto)
     }
@@ -898,16 +952,22 @@ impl ToComputedValue for specified::MozLength {
 
     #[inline]
     fn to_computed_value(&self, context: &Context) -> MozLength {
+        debug_assert!(
+            context.for_non_inherited_property.is_some(),
+            "Someone added a MozLength to an inherited property? Evil!"
+        );
         match *self {
             specified::MozLength::LengthOrPercentageOrAuto(ref lopoa) => {
                 MozLength::LengthOrPercentageOrAuto(lopoa.to_computed_value(context))
             }
-            specified::MozLength::ExtremumLength(ref ext) => {
-                debug_assert!(context.for_non_inherited_property.is_some(),
-                              "should check whether we're a non-inherited property");
+            specified::MozLength::ExtremumLength(ext) => {
                 context.rule_cache_conditions.borrow_mut()
                     .set_writing_mode_dependency(context.builder.writing_mode);
-                MozLength::ExtremumLength(ext.clone())
+                if !ext.valid_for(context.builder.writing_mode, context.for_non_inherited_property.unwrap()) {
+                    MozLength::auto()
+                } else {
+                    MozLength::ExtremumLength(ext)
+                }
             }
         }
     }
@@ -915,11 +975,14 @@ impl ToComputedValue for specified::MozLength {
     #[inline]
     fn from_computed_value(computed: &MozLength) -> Self {
         match *computed {
-            MozLength::LengthOrPercentageOrAuto(ref lopoa) =>
+            MozLength::LengthOrPercentageOrAuto(ref lopoa) => {
                 specified::MozLength::LengthOrPercentageOrAuto(
-                    specified::LengthOrPercentageOrAuto::from_computed_value(&lopoa)),
-            MozLength::ExtremumLength(ref ext) =>
-                specified::MozLength::ExtremumLength(ext.clone()),
+                    specified::LengthOrPercentageOrAuto::from_computed_value(lopoa)
+                )
+            },
+            MozLength::ExtremumLength(ext) => {
+                specified::MozLength::ExtremumLength(ext)
+            }
         }
     }
 }
@@ -937,21 +1000,33 @@ pub enum MaxLength {
 
 impl MaxLength {
     /// Returns the `none` value.
+    #[inline]
     pub fn none() -> Self {
         MaxLength::LengthOrPercentageOrNone(LengthOrPercentageOrNone::None)
     }
 }
+
 impl ToComputedValue for specified::MaxLength {
     type ComputedValue = MaxLength;
 
     #[inline]
     fn to_computed_value(&self, context: &Context) -> MaxLength {
+        debug_assert!(
+            context.for_non_inherited_property.is_some(),
+            "Someone added a MaxLength to an inherited property? Evil!"
+        );
         match *self {
             specified::MaxLength::LengthOrPercentageOrNone(ref lopon) => {
                 MaxLength::LengthOrPercentageOrNone(lopon.to_computed_value(context))
             }
-            specified::MaxLength::ExtremumLength(ref ext) => {
-                MaxLength::ExtremumLength(ext.clone())
+            specified::MaxLength::ExtremumLength(ext) => {
+                context.rule_cache_conditions.borrow_mut()
+                    .set_writing_mode_dependency(context.builder.writing_mode);
+                if !ext.valid_for(context.builder.writing_mode, context.for_non_inherited_property.unwrap()) {
+                    MaxLength::none()
+                } else {
+                    MaxLength::ExtremumLength(ext)
+                }
             }
         }
     }

components/style/values/computed/mod.rs

@@ -58,7 +58,7 @@ pub use super::{Auto, Either, None_};
 pub use super::specified::{BorderStyle, TextDecorationLine};
 pub use self::length::{CalcLengthOrPercentage, Length, LengthOrNone, LengthOrNumber, LengthOrPercentage};
 pub use self::length::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone, MaxLength, MozLength};
-pub use self::length::{CSSPixelLength, NonNegativeLength, NonNegativeLengthOrPercentage};
+pub use self::length::{CSSPixelLength, ExtremumLength, NonNegativeLength, NonNegativeLengthOrPercentage};
 pub use self::list::{ListStyleImage, Quotes};
 #[cfg(feature = "gecko")]
 pub use self::list::ListStyleType;

components/style/values/mod.rs

@@ -195,14 +195,3 @@ impl ToCss for KeyframesName {
     }
 }
 
-/// A type for possible values for min- and max- flavors of width,
-/// height, block-size, and inline-size.
-#[allow(missing_docs)]
-#[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
-#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, Parse, PartialEq, ToCss)]
-pub enum ExtremumLength {
-    MozMaxContent,
-    MozMinContent,
-    MozFitContent,
-    MozAvailable,
-}

components/style/values/specified/length.rs

@@ -18,8 +18,8 @@ use style_traits::{ParseError, StyleParseErrorKind};
 use style_traits::values::specified::AllowedNumericType;
 use stylesheets::CssRuleType;
 use super::{AllowQuirks, Number, ToComputedValue, Percentage};
-use values::{Auto, CSSFloat, Either, ExtremumLength, None_, Normal};
-use values::computed::{self, CSSPixelLength, Context};
+use values::{Auto, CSSFloat, Either, None_, Normal};
+use values::computed::{self, CSSPixelLength, Context, ExtremumLength};
 use values::generics::NonNegative;
 use values::specified::NonNegativeNumber;
 use values::specified::calc::CalcNode;
@@ -933,6 +933,7 @@ impl LengthOrPercentageOrAuto {
     }
 
     /// Returns a value representing `0%`.
+    #[inline]
     pub fn zero_percent() -> Self {
         LengthOrPercentageOrAuto::Percentage(computed::Percentage::zero())
     }
@@ -1125,15 +1126,45 @@ impl Parse for MozLength {
 }
 
 impl MozLength {
+    /// Parses, without quirks, and disallowing ExtremumLength values.
+    ///
+    /// Used for logical props in the block direction.
+    pub fn parse_disallow_keyword<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self, ParseError<'i>> {
+        let length = LengthOrPercentageOrAuto::parse_non_negative(context, input)?;
+        Ok(MozLength::LengthOrPercentageOrAuto(length))
+    }
+
     /// Parses, with quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
-        input.try(ExtremumLength::parse).map(MozLength::ExtremumLength)
-            .or_else(|_| input.try(|i| LengthOrPercentageOrAuto::parse_non_negative_quirky(context, i, allow_quirks))
-                               .map(MozLength::LengthOrPercentageOrAuto))
+        if let Ok(l) = input.try(ExtremumLength::parse) {
+            return Ok(MozLength::ExtremumLength(l));
+        }
+
+        let length = LengthOrPercentageOrAuto::parse_non_negative_quirky(
+            context,
+            input,
+            allow_quirks,
+        )?;
+        Ok(MozLength::LengthOrPercentageOrAuto(length))
+    }
+
+    /// Returns `auto`.
+    #[inline]
+    pub fn auto() -> Self {
+        MozLength::LengthOrPercentageOrAuto(LengthOrPercentageOrAuto::auto())
+    }
+
+    /// Returns `0%`.
+    #[inline]
+    pub fn zero_percent() -> Self {
+        MozLength::LengthOrPercentageOrAuto(LengthOrPercentageOrAuto::zero_percent())
     }
 }
 
@@ -1152,14 +1183,32 @@ impl Parse for MaxLength {
 }
 
 impl MaxLength {
+    /// Parses, without quirks, and disallowing ExtremumLength values.
+    ///
+    /// Used for logical props in the block direction.
+    pub fn parse_disallow_keyword<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self, ParseError<'i>> {
+        let length = LengthOrPercentageOrNone::parse_non_negative(context, input)?;
+        Ok(MaxLength::LengthOrPercentageOrNone(length))
+    }
+
     /// Parses, with quirks.
     pub fn parse_quirky<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_quirks: AllowQuirks,
     ) -> Result<Self, ParseError<'i>> {
-        input.try(ExtremumLength::parse).map(MaxLength::ExtremumLength)
-            .or_else(|_| input.try(|i| LengthOrPercentageOrNone::parse_non_negative_quirky(context, i, allow_quirks))
-                               .map(MaxLength::LengthOrPercentageOrNone))
+        if let Ok(l) = input.try(ExtremumLength::parse) {
+            return Ok(MaxLength::ExtremumLength(l));
+        }
+
+        let length = LengthOrPercentageOrNone::parse_non_negative_quirky(
+            context,
+            input,
+            allow_quirks,
+        )?;
+        Ok(MaxLength::LengthOrPercentageOrNone(length))
     }
 }