style: Get rid of gecko_size_type.

components/style/gecko/values.rs

@@ -16,8 +16,8 @@ use gecko_bindings::sugar::ns_style_coord::{CoordData, CoordDataMut, CoordDataVa
 use media_queries::Device;
 use nsstring::{nsACString, nsCStr};
 use std::cmp::max;
-use values::{Auto, Either, ExtremumLength, None_, Normal};
-use values::computed::{Angle, Length, LengthOrPercentage, LengthOrPercentageOrAuto};
+use values::{Auto, Either, None_, Normal};
+use values::computed::{Angle, ExtremumLength, Length, LengthOrPercentage, LengthOrPercentageOrAuto};
 use values::computed::{LengthOrPercentageOrNone, Number, NumberOrPercentage};
 use values::computed::{MaxLength, MozLength, Percentage};
 use values::computed::{NonNegativeLength, NonNegativeLengthOrPercentage, NonNegativeNumber};

components/style/properties/data.py

@@ -149,7 +149,6 @@ def __init__(self, style_struct, name, spec=None, animation_value_type=None, key
                  predefined_type=None, servo_pref=None, gecko_pref=None,
                  enabled_in="content", need_index=False,
                  gecko_ffi_name=None,
-                 is_gecko_size_type_hack=False,
                  allowed_in_keyframe_block=True, cast_type='u8',
                  logical=False, alias=None, extra_prefixes=None, boxed=False,
                  flags=None, allowed_in_page_rule=False, allow_quirks=False, ignored_when_colors_disabled=False,
@@ -186,7 +185,6 @@ def __init__(self, style_struct, name, spec=None, animation_value_type=None, key
         self.allow_quirks = allow_quirks
         self.ignored_when_colors_disabled = ignored_when_colors_disabled
         self.is_vector = vector
-        self.is_gecko_size_type_hack = is_gecko_size_type_hack
 
         # https://drafts.csswg.org/css-animations/#keyframes
         # > The <declaration-list> inside of <keyframe-block> accepts any CSS property

components/style/properties/helpers.mako.rs

@@ -894,116 +894,3 @@
         return "nsCSSPropertyID::eCSSProperty_%s" % ident
     %>
 </%def>
-
-// Define property that supports prefixed intrinsic size keyword values for gecko.
-// E.g. -moz-max-content, -moz-min-content, etc.
-//
-// FIXME(emilio): This feels a lot like a huge hack, get rid of this.
-<%def name="gecko_size_type(name, length_type, initial_value, logical, **kwargs)">
-    <%call expr="longhand(name,
-                          predefined_type=length_type,
-                          logical=logical,
-                          is_gecko_size_type_hack=True,
-                          **kwargs)">
-        % if not logical:
-            use values::specified::AllowQuirks;
-        % endif
-        use values::specified::${length_type};
-
-        pub mod computed_value {
-            pub type T = ::values::computed::${length_type};
-        }
-
-        #[derive(Clone, Debug, MallocSizeOf, PartialEq, ToCss)]
-        pub struct SpecifiedValue(pub ${length_type});
-
-        % if length_type == "MozLength":
-        impl SpecifiedValue {
-            /// Returns the `auto` value.
-            pub fn auto() -> Self {
-                use values::specified::length::LengthOrPercentageOrAuto;
-                SpecifiedValue(MozLength::LengthOrPercentageOrAuto(LengthOrPercentageOrAuto::Auto))
-            }
-
-            /// Returns a value representing a `0` length.
-            pub fn zero() -> Self {
-                use values::specified::length::LengthOrPercentageOrAuto;
-                SpecifiedValue(MozLength::LengthOrPercentageOrAuto(LengthOrPercentageOrAuto::zero()))
-            }
-
-            /// Returns a value representing a `0%` length.
-            pub fn zero_percent() -> Self {
-                use values::specified::length::LengthOrPercentageOrAuto;
-                SpecifiedValue(MozLength::LengthOrPercentageOrAuto(LengthOrPercentageOrAuto::zero_percent()))
-            }
-        }
-        % endif
-
-        #[inline]
-        pub fn get_initial_value() -> computed_value::T {
-            use values::computed::${length_type};
-            ${length_type}::${initial_value}
-        }
-
-        impl Parse for SpecifiedValue {
-            fn parse<'i, 't>(
-                context: &ParserContext,
-                input: &mut Parser<'i, 't>,
-            ) -> Result<SpecifiedValue, ParseError<'i>> {
-                % if logical:
-                let ret = ${length_type}::parse(context, input);
-                % else:
-                let ret = ${length_type}::parse_quirky(context, input, AllowQuirks::Yes);
-                % endif
-                // Keyword values don't make sense in the block direction; don't parse them
-                % if "block" in name:
-                    if let Ok(${length_type}::ExtremumLength(..)) = ret {
-                        return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
-                    }
-                % endif
-                ret.map(SpecifiedValue)
-            }
-        }
-
-        fn parse<'i, 't>(
-            context: &ParserContext,
-            input: &mut Parser<'i, 't>,
-        ) -> Result<SpecifiedValue, ParseError<'i>> {
-            SpecifiedValue::parse(context, input)
-        }
-
-        impl ToComputedValue for SpecifiedValue {
-            type ComputedValue = computed_value::T;
-            #[inline]
-            fn to_computed_value(&self, context: &Context) -> computed_value::T {
-                % if not logical or "block" in name:
-                    use values::computed::${length_type};
-                % endif
-                let computed = self.0.to_computed_value(context);
-
-                // filter out keyword values in the block direction
-                % if logical:
-                    % if "block" in name:
-                        if let ${length_type}::ExtremumLength(..) = computed {
-                            return get_initial_value()
-                        }
-                    % endif
-                % else:
-                    if let ${length_type}::ExtremumLength(..) = computed {
-                        <% is_height = "true" if "height" in name else "false" %>
-                        if ${is_height} != context.builder.writing_mode.is_vertical() {
-                            return get_initial_value()
-                        }
-                    }
-                % endif
-                computed
-            }
-
-            #[inline]
-            fn from_computed_value(computed: &computed_value::T) -> Self {
-                SpecifiedValue(ToComputedValue::from_computed_value(computed))
-            }
-        }
-    </%call>
-</%def>
-

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

@@ -160,18 +160,21 @@ ${helpers.predefined_type("order", "Integer", "0",
                           animation_value_type="ComputedValue",
                           spec="https://drafts.csswg.org/css-flexbox/#order-property")}
 
-// FIXME(emilio): All the sizes stuff, and the MozLength values should be
-// unified with Servo, or at least be less hacky.
-//
-// The block direction ones don't even accept extremum lengths during parsing,
-// and should be converted to just LengthOrPercentage.
 % if product == "gecko":
     // FIXME: Gecko doesn't support content value yet.
-    ${helpers.gecko_size_type("flex-basis", "MozLength", "auto()",
-                              logical=False,
-                              spec="https://drafts.csswg.org/css-flexbox/#flex-basis-property",
-                              extra_prefixes="webkit",
-                              animation_value_type="MozLength")}
+    //
+    // FIXME(emilio): I suspect this property shouldn't allow quirks, and this
+    // was just a mistake, it's kind of justificable to support it given the
+    // spec grammar is just `content | <width>`, but other browsers don't...
+    ${helpers.predefined_type(
+        "flex-basis",
+        "MozLength",
+        "computed::MozLength::auto()",
+        extra_prefixes="webkit",
+        animation_value_type="ComputedValue",
+        allow_quirks=True,
+        spec="https://drafts.csswg.org/css-flexbox/#flex-basis-property"
+    )}
 % else:
     // FIXME: This property should be animatable.
     ${helpers.predefined_type("flex-basis",
@@ -183,29 +186,54 @@ ${helpers.predefined_type("order", "Integer", "0",
 % endif
 % for (size, logical) in ALL_SIZES:
     <%
-      spec = "https://drafts.csswg.org/css-box/#propdef-%s"
-      if logical:
-        spec = "https://drafts.csswg.org/css-logical-props/#propdef-%s"
+        spec = "https://drafts.csswg.org/css-box/#propdef-%s"
+        if logical:
+            spec = "https://drafts.csswg.org/css-logical-props/#propdef-%s"
     %>
+    // NOTE: Block-size doesn't support -moz-*-content keywords, since they make
+    // no sense on the block axis, but it simplifies things the have that it has
+    // the same type as the other properties, since otherwise we'd need to
+    // handle logical props where the types are different, which looks like a
+    // pain.
     % if product == "gecko":
+        <%
+            parse_function = "parse" if size != "block-size" else "parse_disallow_keyword"
+        %>
         // width, height, block-size, inline-size
-        ${helpers.gecko_size_type("%s" % size, "MozLength", "auto()",
-                                  logical,
-                                  spec=spec % size,
-                                  animation_value_type="MozLength")}
+        ${helpers.predefined_type(
+            size,
+            "MozLength",
+            "computed::MozLength::auto()",
+            parse_function,
+            logical=logical,
+            allow_quirks=not logical,
+            spec=spec % size,
+            animation_value_type="ComputedValues"
+        )}
         // min-width, min-height, min-block-size, min-inline-size,
-        // max-width, max-height, max-block-size, max-inline-size
-        ${helpers.gecko_size_type("min-%s" % size, "MozLength", "auto()",
-                                  logical,
-                                  spec=spec % size,
-                                  animation_value_type="MozLength")}
-        ${helpers.gecko_size_type("max-%s" % size, "MaxLength", "none()",
-                                  logical,
-                                  spec=spec % size,
-                                  animation_value_type="MaxLength")}
+        ${helpers.predefined_type(
+            "min-%s" % size,
+            "MozLength",
+            "computed::MozLength::auto()",
+            parse_function,
+            logical=logical,
+            allow_quirks=not logical,
+            spec=spec % size,
+            animation_value_type="ComputedValue"
+        )}
+        ${helpers.predefined_type(
+            "max-%s" % size,
+            "MaxLength",
+            "computed::MaxLength::none()",
+            parse_function,
+            logical=logical,
+            allow_quirks=not logical,
+            spec=spec % size,
+            animation_value_type="ComputedValue",
+        )}
     % else:
         // servo versions (no keyword support)
-        ${helpers.predefined_type("%s" % size,
+        ${helpers.predefined_type(size,
                                   "LengthOrPercentageOrAuto",
                                   "computed::LengthOrPercentageOrAuto::Auto",
                                   "parse_non_negative",

components/style/properties/properties.mako.rs

@@ -208,7 +208,7 @@ pub mod animated_properties {
 
     variants = []
     for property in data.longhands:
-        if property.predefined_type and not property.is_vector and not property.is_gecko_size_type_hack:
+        if property.predefined_type and not property.is_vector:
             ty = "::values::specified::{}".format(property.predefined_type)
         else:
             ty = "longhands::{}::SpecifiedValue".format(property.ident)