From 0dfbd38532bd1895d3818de5268d8d2c6d989a5b Mon Sep 17 00:00:00 2001
From: Sean Voisen <svoisen@mozilla.com>
Date: Tue, 17 Dec 2019 11:27:41 +0000
Subject: [PATCH 01/66] style: Add support for logical versions of
 overscroll-behavior.

Differential Revision: https://phabricator.services.mozilla.com/D57363
---
 components/style/properties/longhands/box.mako.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/components/style/properties/longhands/box.mako.rs b/components/style/properties/longhands/box.mako.rs
index fba2fac66dc..862a373bdfe 100644
--- a/components/style/properties/longhands/box.mako.rs
+++ b/components/style/properties/longhands/box.mako.rs
@@ -472,13 +472,15 @@ ${helpers.predefined_type(
     animation_value_type="discrete",
 )}
 
-% for axis in ["x", "y"]:
+% for (axis, logical) in ALL_AXES:
     ${helpers.predefined_type(
         "overscroll-behavior-" + axis,
         "OverscrollBehavior",
         "computed::OverscrollBehavior::Auto",
         engines="gecko",
         needs_context=False,
+        logical_group="overscroll-behavior",
+        logical=logical,
         gecko_pref="layout.css.overscroll-behavior.enabled",
         spec="https://wicg.github.io/overscroll-behavior/#overscroll-behavior-properties",
         animation_value_type="discrete",

From 2b499e48509ad102b0cbd6fc4997598e1b128445 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Thu, 19 Dec 2019 01:19:04 +0000
Subject: [PATCH 02/66] style: Do not use synthetic display-inside values.

This matches the new servo layout engine too, and thus removes some #[cfg]
gunk.  Just use `flow` since it doesn't simplify the layout code as much.

Differential Revision: https://phabricator.services.mozilla.com/D45973
---
 components/style/style_adjuster.rs       |  4 +-
 components/style/values/specified/box.rs | 52 +++++++-----------------
 2 files changed, 16 insertions(+), 40 deletions(-)

diff --git a/components/style/style_adjuster.rs b/components/style/style_adjuster.rs
index 6a3dc75f4d8..36463aad6fb 100644
--- a/components/style/style_adjuster.rs
+++ b/components/style/style_adjuster.rs
@@ -12,8 +12,6 @@ use crate::properties::longhands::float::computed_value::T as Float;
 use crate::properties::longhands::overflow_x::computed_value::T as Overflow;
 use crate::properties::longhands::position::computed_value::T as Position;
 use crate::properties::{self, ComputedValues, StyleBuilder};
-#[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-use crate::values::specified::box_::DisplayInside;
 use app_units::Au;
 
 /// A struct that implements all the adjustment methods.
@@ -207,7 +205,7 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
             self.style.pseudo.map_or(false, |p| p.is_marker()) &&
                 self.style.get_parent_list().clone_list_style_position() ==
                     ListStylePosition::Outside &&
-                layout_parent_style.get_box().clone_display().inside() != DisplayInside::Inline
+                !layout_parent_style.get_box().clone_display().is_inline_flow()
         );
 
         if !blockify {
diff --git a/components/style/values/specified/box.rs b/components/style/values/specified/box.rs
index ad8602ac431..1549f66e8e9 100644
--- a/components/style/values/specified/box.rs
+++ b/components/style/values/specified/box.rs
@@ -61,12 +61,9 @@ pub enum DisplayInside {
     None = 0,
     #[cfg(any(feature = "servo-layout-2020", feature = "gecko"))]
     Contents,
-    #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-    Block,
+    Flow,
     FlowRoot,
     #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-    Inline,
-    #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
     Flex,
     #[cfg(feature = "gecko")]
     Grid,
@@ -114,7 +111,6 @@ pub enum DisplayInside {
     MozGroupbox,
     #[cfg(feature = "gecko")]
     MozPopup,
-    Flow, // only used for parsing, not computed value
 }
 
 #[allow(missing_docs)]
@@ -147,14 +143,8 @@ impl Display {
     pub const None: Self = Self::new(DisplayOutside::None, DisplayInside::None);
     #[cfg(any(feature = "servo-layout-2020", feature = "gecko"))]
     pub const Contents: Self = Self::new(DisplayOutside::None, DisplayInside::Contents);
-    #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-    pub const Inline: Self = Self::new(DisplayOutside::Inline, DisplayInside::Inline);
-    #[cfg(any(feature = "servo-layout-2020"))]
     pub const Inline: Self = Self::new(DisplayOutside::Inline, DisplayInside::Flow);
     pub const InlineBlock: Self = Self::new(DisplayOutside::Inline, DisplayInside::FlowRoot);
-    #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-    pub const Block: Self = Self::new(DisplayOutside::Block, DisplayInside::Block);
-    #[cfg(any(feature = "servo-layout-2020"))]
     pub const Block: Self = Self::new(DisplayOutside::Block, DisplayInside::Flow);
     #[cfg(feature = "gecko")]
     pub const FlowRoot: Self = Self::new(DisplayOutside::Block, DisplayInside::FlowRoot);
@@ -171,7 +161,7 @@ impl Display {
     #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
     pub const InlineTable: Self = Self::new(DisplayOutside::Inline, DisplayInside::Table);
     #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-    pub const TableCaption: Self = Self::new(DisplayOutside::TableCaption, DisplayInside::Block);
+    pub const TableCaption: Self = Self::new(DisplayOutside::TableCaption, DisplayInside::Flow);
     #[cfg(feature = "gecko")]
     pub const Ruby: Self = Self::new(DisplayOutside::Inline, DisplayInside::Ruby);
     #[cfg(feature = "gecko")]
@@ -256,18 +246,8 @@ impl Display {
     }
 
     /// Make a display enum value from <display-outside> and <display-inside> values.
-    /// We store `flow` as a synthetic `block` or `inline` inside-value to simplify
-    /// our layout code.
     #[inline]
     fn from3(outside: DisplayOutside, inside: DisplayInside, list_item: bool) -> Self {
-        let inside = match inside {
-            #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-            DisplayInside::Flow => match outside {
-                DisplayOutside::Inline => DisplayInside::Inline,
-                _ => DisplayInside::Block,
-            },
-            _ => inside,
-        };
         let v = Self::new(outside, inside);
         if !list_item {
             return v;
@@ -290,6 +270,13 @@ impl Display {
         .unwrap()
     }
 
+    /// Whether this is `display: inline` (or `inline list-item`).
+    #[inline]
+    pub fn is_inline_flow(&self) -> bool {
+        self.outside() == DisplayOutside::Inline &&
+            self.inside() == DisplayInside::Flow
+    }
+
     /// Returns whether this `display` value is some kind of list-item.
     #[inline]
     pub const fn is_list_item(&self) -> bool {
@@ -381,9 +368,8 @@ impl Display {
         match self.outside() {
             DisplayOutside::Inline => {
                 let inside = match self.inside() {
-                    #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-                    DisplayInside::Inline | DisplayInside::FlowRoot => DisplayInside::Block,
-                    #[cfg(feature = "servo-layout-2020")]
+                    // `inline-block` blockifies to `block` rather than
+                    // `flow-root`, for legacy reasons.
                     DisplayInside::FlowRoot => DisplayInside::Flow,
                     inside => inside,
                 };
@@ -407,7 +393,9 @@ impl Display {
         match self.outside() {
             DisplayOutside::Block => {
                 let inside = match self.inside() {
-                    DisplayInside::Block => DisplayInside::FlowRoot,
+                    // `display: block` inlinifies to `display: inline-block`,
+                    // rather than `inline`, for legacy reasons.
+                    DisplayInside::Flow => DisplayInside::FlowRoot,
                     inside => inside,
                 };
                 Display::from3(DisplayOutside::Inline, inside, self.is_list_item())
@@ -443,18 +431,8 @@ impl ToCss for Display {
     where
         W: fmt::Write,
     {
-        #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-        debug_assert_ne!(
-            self.inside(),
-            DisplayInside::Flow,
-            "`flow` fears in `display` computed value"
-        );
         let outside = self.outside();
-        let inside = match self.inside() {
-            #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
-            DisplayInside::Block | DisplayInside::Inline => DisplayInside::Flow,
-            inside => inside,
-        };
+        let inside = self.inside();
         match *self {
             Display::Block | Display::Inline => outside.to_css(dest),
             Display::InlineBlock => dest.write_str("inline-block"),

From d3e65000be4f6e19b5b85ab471b9e2a620dbb559 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Thu, 19 Dec 2019 20:43:06 +0000
Subject: [PATCH 03/66] style: Workaround LLVM ABI bug.

All the gory details in https://bugzilla.mozilla.org/show_bug.cgi?id=1600735 and
related LLVM / GCC bugs. Avoid the issue by forcing the relevant enum to be
32-bit wide, so as to not trigger the LLVM bug.

Differential Revision: https://phabricator.services.mozilla.com/D57868
---
 components/style/properties/properties.mako.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs
index 30a03f79290..e4a07da1c77 100644
--- a/components/style/properties/properties.mako.rs
+++ b/components/style/properties/properties.mako.rs
@@ -1803,8 +1803,11 @@ impl ToCss for PropertyId {
 }
 
 /// The counted unknown property list which is used for css use counters.
+///
+/// FIXME: This should be just #[repr(u8)], but can't be because of ABI issues,
+/// see https://bugs.llvm.org/show_bug.cgi?id=44228.
 #[derive(Clone, Copy, Debug, Eq, FromPrimitive, Hash, PartialEq)]
-#[repr(u8)]
+#[repr(u32)]
 pub enum CountedUnknownProperty {
     % for prop in data.counted_unknown_properties:
     /// ${prop.name}

From 69bf0e40a6b1f4420e32464f04773f477c748b57 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Thu, 26 Dec 2019 22:17:35 +0000
Subject: [PATCH 04/66] style: Remove unused FFI function to refcount
 nsIReferrerInfo.

We don't use RefPtr<nsIReferrerInfo> in rust.

Differential Revision: https://phabricator.services.mozilla.com/D58274
---
 components/style/gecko_bindings/sugar/refptr.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/components/style/gecko_bindings/sugar/refptr.rs b/components/style/gecko_bindings/sugar/refptr.rs
index e27b4a28c40..a141aef4e8b 100644
--- a/components/style/gecko_bindings/sugar/refptr.rs
+++ b/components/style/gecko_bindings/sugar/refptr.rs
@@ -303,11 +303,6 @@ impl_threadsafe_refcount!(
     bindings::Gecko_AddRefURLExtraDataArbitraryThread,
     bindings::Gecko_ReleaseURLExtraDataArbitraryThread
 );
-impl_threadsafe_refcount!(
-    structs::nsIReferrerInfo,
-    bindings::Gecko_AddRefnsIReferrerInfoArbitraryThread,
-    bindings::Gecko_ReleasensIReferrerInfoArbitraryThread
-);
 impl_threadsafe_refcount!(
     structs::nsIURI,
     bindings::Gecko_AddRefnsIURIArbitraryThread,

From 4f4d4803263f48030cfda400410e1b2b85cb8d2d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Tue, 31 Dec 2019 18:14:35 +0000
Subject: [PATCH 05/66] style: Do not incorrectly share style across elements
 with different part names.

Do the same we do for classes for now. We could be more precise and achieve a
bit more sharing with some more effort (left a comment there), but it seems
unlikely to matter in practice (and if we did that, we'd probably want to do the
same for classes).

Differential Revision: https://phabricator.services.mozilla.com/D58453
---
 components/style/sharing/checks.rs | 15 ++++++++-
 components/style/sharing/mod.rs    | 53 ++++++++++++++++++++++++++----
 2 files changed, 60 insertions(+), 8 deletions(-)

diff --git a/components/style/sharing/checks.rs b/components/style/sharing/checks.rs
index 19c1c52acdc..9c860f0258f 100644
--- a/components/style/sharing/checks.rs
+++ b/components/style/sharing/checks.rs
@@ -81,7 +81,7 @@ where
     target.pres_hints() == candidate.pres_hints()
 }
 
-/// Whether a given element has the same class attribute than a given candidate.
+/// Whether a given element has the same class attribute as a given candidate.
 ///
 /// We don't try to share style across elements with different class attributes.
 pub fn have_same_class<E>(
@@ -94,6 +94,19 @@ where
     target.class_list() == candidate.class_list()
 }
 
+/// Whether a given element has the same class attribute as a given candidate.
+///
+/// We don't try to share style across elements with different part attributes.
+pub fn have_same_parts<E>(
+    target: &mut StyleSharingTarget<E>,
+    candidate: &mut StyleSharingCandidate<E>,
+) -> bool
+where
+    E: TElement,
+{
+    target.part_list() == candidate.part_list()
+}
+
 /// Whether a given element and a candidate match the same set of "revalidation"
 /// selectors.
 ///
diff --git a/components/style/sharing/mod.rs b/components/style/sharing/mod.rs
index 9b8c1275e4b..2d36aeea7ff 100644
--- a/components/style/sharing/mod.rs
+++ b/components/style/sharing/mod.rs
@@ -124,10 +124,16 @@ impl OpaqueComputedValues {
 pub struct ValidationData {
     /// The class list of this element.
     ///
-    /// TODO(emilio): See if it's worth to sort them, or doing something else in
-    /// a similar fashion as what Boris is doing for the ID attribute.
+    /// TODO(emilio): Maybe check whether rules for these classes apply to the
+    /// element?
     class_list: Option<SmallVec<[Atom; 5]>>,
 
+    /// The part list of this element.
+    ///
+    /// TODO(emilio): Maybe check whether rules with these part names apply to
+    /// the element?
+    part_list: Option<SmallVec<[Atom; 5]>>,
+
     /// The list of presentational attributes of the element.
     pres_hints: Option<SmallVec<[ApplicableDeclarationBlock; 5]>>,
 
@@ -161,22 +167,41 @@ impl ValidationData {
         })
     }
 
+    /// Get or compute the part-list associated with this element.
+    pub fn part_list<E>(&mut self, element: E) -> &[Atom]
+    where
+        E: TElement,
+    {
+        if !element.has_part_attr() {
+            return &[]
+        }
+        self.part_list.get_or_insert_with(|| {
+            let mut list = SmallVec::<[Atom; 5]>::new();
+            element.each_part(|p| list.push(p.clone()));
+            // See below for the reasoning.
+            if !list.spilled() {
+                list.sort_unstable_by_key(|a| a.get_hash());
+            }
+            list
+        })
+    }
+
     /// Get or compute the class-list associated with this element.
     pub fn class_list<E>(&mut self, element: E) -> &[Atom]
     where
         E: TElement,
     {
         self.class_list.get_or_insert_with(|| {
-            let mut class_list = SmallVec::<[Atom; 5]>::new();
-            element.each_class(|c| class_list.push(c.clone()));
+            let mut list = SmallVec::<[Atom; 5]>::new();
+            element.each_class(|c| list.push(c.clone()));
             // Assuming there are a reasonable number of classes (we use the
             // inline capacity as "reasonable number"), sort them to so that
             // we don't mistakenly reject sharing candidates when one element
             // has "foo bar" and the other has "bar foo".
-            if !class_list.spilled() {
-                class_list.sort_by(|a, b| a.get_hash().cmp(&b.get_hash()));
+            if !list.spilled() {
+                list.sort_unstable_by_key(|a| a.get_hash());
             }
-            class_list
+            list
         })
     }
 
@@ -273,6 +298,11 @@ impl<E: TElement> StyleSharingCandidate<E> {
         self.validation_data.class_list(self.element)
     }
 
+    /// Get the part list of this candidate.
+    fn part_list(&mut self) -> &[Atom] {
+        self.validation_data.part_list(self.element)
+    }
+
     /// Get the pres hints of this candidate.
     fn pres_hints(&mut self) -> &[ApplicableDeclarationBlock] {
         self.validation_data.pres_hints(self.element)
@@ -335,6 +365,10 @@ impl<E: TElement> StyleSharingTarget<E> {
         self.validation_data.class_list(self.element)
     }
 
+    fn part_list(&mut self) -> &[Atom] {
+        self.validation_data.part_list(self.element)
+    }
+
     /// Get the pres hints of this candidate.
     fn pres_hints(&mut self) -> &[ApplicableDeclarationBlock] {
         self.validation_data.pres_hints(self.element)
@@ -772,6 +806,11 @@ impl<E: TElement> StyleSharingCache<E> {
             return None;
         }
 
+        if !checks::have_same_parts(target, candidate) {
+            trace!("Miss: Shadow parts");
+            return None;
+        }
+
         if !checks::revalidate(
             target,
             candidate,

From 07d0eea5fb2ef09b01981ff4f437eab073a713ae Mon Sep 17 00:00:00 2001
From: Ting-Yu Lin <tlin@mozilla.com>
Date: Tue, 31 Dec 2019 16:15:12 +0000
Subject: [PATCH 06/66] style:- Remove column-span pref in column.mako.rs.

Differential Revision: https://phabricator.services.mozilla.com/D58399
---
 components/style/properties/longhands/column.mako.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/components/style/properties/longhands/column.mako.rs b/components/style/properties/longhands/column.mako.rs
index 8b49679abf7..b987990844d 100644
--- a/components/style/properties/longhands/column.mako.rs
+++ b/components/style/properties/longhands/column.mako.rs
@@ -69,17 +69,14 @@ ${helpers.predefined_type(
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-rule-color",
 )}
 
-// FIXME: Remove enabled_in="ua" once column-span is enabled on nightly (bug 1423383).
 ${helpers.single_keyword(
     "column-span",
     "none all",
     engines="gecko",
     animation_value_type="discrete",
     gecko_enum_prefix="StyleColumnSpan",
-    gecko_pref="layout.css.column-span.enabled",
-    enabled_in="ua",
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-span",
-    extra_prefixes="moz:layout.css.column-span.enabled",
+    extra_prefixes="moz",
 )}
 
 ${helpers.predefined_type(

From 219c0f6328c1bf043a02cef3cce4d5035554c2dd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Sun, 5 Jan 2020 13:10:39 +0000
Subject: [PATCH 07/66] style: Use cbindgen for content property.

This cleans up and also allows us to keep the distinction between content: none
and content: normal, which allows us to fix the computed style we return from
getComputedStyle().

Do this last bit from the resolved value instead of StyleAdjuster, because
otherwise we need to tweak every initial struct for ::before / ::after.

Differential Revision: https://phabricator.services.mozilla.com/D58276
---
 components/style/counter_style/mod.rs         |   2 +
 components/style/gecko/values.rs              |  40 +--
 .../style/gecko_string_cache/namespace.rs     |   1 +
 components/style/lib.rs                       |   6 +-
 components/style/properties/gecko.mako.rs     | 244 +-----------------
 components/style/values/computed/counters.rs  |   4 +-
 components/style/values/computed/mod.rs       |   1 +
 components/style/values/generics/counters.rs  |  28 +-
 components/style/values/generics/mod.rs       |  32 +--
 components/style/values/resolved/counters.rs  |  46 ++++
 components/style/values/resolved/mod.rs       |   2 +
 components/style/values/specified/counters.rs |  34 ++-
 components/style/values/specified/mod.rs      |  25 +-
 13 files changed, 122 insertions(+), 343 deletions(-)
 create mode 100644 components/style/values/resolved/counters.rs

diff --git a/components/style/counter_style/mod.rs b/components/style/counter_style/mod.rs
index 25cdc3f8737..d131f350393 100644
--- a/components/style/counter_style/mod.rs
+++ b/components/style/counter_style/mod.rs
@@ -409,6 +409,7 @@ impl ToCss for System {
 
 /// <https://drafts.csswg.org/css-counter-styles/#typedef-symbol>
 #[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss, ToShmem)]
+#[repr(u8)]
 pub enum Symbol {
     /// <string>
     String(crate::OwnedStr),
@@ -554,6 +555,7 @@ impl Parse for Fallback {
 
 /// <https://drafts.csswg.org/css-counter-styles/#descdef-counter-style-symbols>
 #[derive(Clone, Debug, Eq, MallocSizeOf, PartialEq, ToComputedValue, ToCss, ToShmem)]
+#[repr(C)]
 pub struct Symbols(#[css(iterable)] pub crate::OwnedSlice<Symbol>);
 
 impl Parse for Symbols {
diff --git a/components/style/gecko/values.rs b/components/style/gecko/values.rs
index b31485345b6..a755556e850 100644
--- a/components/style/gecko/values.rs
+++ b/components/style/gecko/values.rs
@@ -7,13 +7,13 @@
 //! Different kind of helpers to interact with Gecko values.
 
 use crate::counter_style::{Symbol, Symbols};
+use crate::gecko_bindings::bindings;
 use crate::gecko_bindings::structs::CounterStylePtr;
 use crate::values::generics::CounterStyle;
 use crate::values::Either;
 use crate::Atom;
 use app_units::Au;
 use cssparser::RGBA;
-use nsstring::{nsACString, nsCStr};
 use std::cmp::max;
 
 /// Convert a given RGBA value to `nscolor`.
@@ -51,43 +51,13 @@ pub fn round_border_to_device_pixels(width: Au, au_per_device_px: Au) -> Au {
 
 impl CounterStyle {
     /// Convert this counter style to a Gecko CounterStylePtr.
-    pub fn to_gecko_value(self, gecko_value: &mut CounterStylePtr) {
-        use crate::gecko_bindings::bindings::Gecko_SetCounterStyleToName as set_name;
-        use crate::gecko_bindings::bindings::Gecko_SetCounterStyleToSymbols as set_symbols;
-        match self {
-            CounterStyle::Name(name) => unsafe {
-                debug_assert_ne!(name.0, atom!("none"));
-                set_name(gecko_value, name.0.into_addrefed());
-            },
-            CounterStyle::Symbols(symbols_type, symbols) => {
-                let symbols: Vec<_> = symbols
-                    .0
-                    .iter()
-                    .map(|symbol| match *symbol {
-                        Symbol::String(ref s) => nsCStr::from(&**s),
-                        Symbol::Ident(_) => unreachable!("Should not have identifier in symbols()"),
-                    })
-                    .collect();
-                let symbols: Vec<_> = symbols
-                    .iter()
-                    .map(|symbol| symbol as &nsACString as *const _)
-                    .collect();
-                unsafe {
-                    set_symbols(
-                        gecko_value,
-                        symbols_type.to_gecko_keyword(),
-                        symbols.as_ptr(),
-                        symbols.len() as u32,
-                    )
-                };
-            },
-        }
+    #[inline]
+    pub fn to_gecko_value(&self, gecko_value: &mut CounterStylePtr) {
+        unsafe { bindings::Gecko_CounterStyle_ToPtr(self, gecko_value) }
     }
 
     /// Convert Gecko CounterStylePtr to CounterStyle or String.
     pub fn from_gecko_value(gecko_value: &CounterStylePtr) -> Either<Self, String> {
-        use crate::gecko_bindings::bindings;
-        use crate::values::generics::SymbolsType;
         use crate::values::CustomIdent;
 
         let name = unsafe { bindings::Gecko_CounterStyle_GetName(gecko_value) };
@@ -103,7 +73,7 @@ impl CounterStyle {
                 debug_assert_eq!(symbols.len(), 1);
                 Either::Second(symbols[0].to_string())
             } else {
-                let symbol_type = SymbolsType::from_gecko_keyword(anonymous.mSystem as u32);
+                let symbol_type = anonymous.mSymbolsType;
                 let symbols = symbols
                     .iter()
                     .map(|gecko_symbol| Symbol::String(gecko_symbol.to_string().into()))
diff --git a/components/style/gecko_string_cache/namespace.rs b/components/style/gecko_string_cache/namespace.rs
index 33883e66941..2dba484e002 100644
--- a/components/style/gecko_string_cache/namespace.rs
+++ b/components/style/gecko_string_cache/namespace.rs
@@ -25,6 +25,7 @@ macro_rules! ns {
 
 /// A Gecko namespace is just a wrapped atom.
 #[derive(Clone, Debug, Default, Eq, Hash, MallocSizeOf, PartialEq, ToShmem)]
+#[repr(transparent)]
 pub struct Namespace(pub Atom);
 
 impl PrecomputedHash for Namespace {
diff --git a/components/style/lib.rs b/components/style/lib.rs
index 354950f9c15..33862461aa9 100644
--- a/components/style/lib.rs
+++ b/components/style/lib.rs
@@ -173,10 +173,12 @@ pub mod values;
 pub use crate::gecko_string_cache as string_cache;
 #[cfg(feature = "gecko")]
 pub use crate::gecko_string_cache::Atom;
+/// The namespace prefix type for Gecko, which is just an atom.
 #[cfg(feature = "gecko")]
-pub use crate::gecko_string_cache::Atom as Prefix;
+pub type Prefix = crate::gecko_string_cache::Atom;
+/// The local name of an element for Gecko, which is just an atom.
 #[cfg(feature = "gecko")]
-pub use crate::gecko_string_cache::Atom as LocalName;
+pub type LocalName = crate::gecko_string_cache::Atom;
 #[cfg(feature = "gecko")]
 pub use crate::gecko_string_cache::Namespace;
 
diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index 14262e7a074..874bf1a83cb 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -36,7 +36,6 @@ use crate::gecko_bindings::bindings::Gecko_SetNullImageValue;
 use crate::gecko_bindings::structs;
 use crate::gecko_bindings::structs::nsCSSPropertyID;
 use crate::gecko_bindings::structs::mozilla::PseudoStyleType;
-use crate::gecko_bindings::sugar::refptr::RefPtr;
 use crate::gecko::values::round_border_to_device_pixels;
 use crate::logical_geometry::WritingMode;
 use crate::media_queries::Device;
@@ -45,7 +44,6 @@ use crate::properties::longhands;
 use crate::rule_tree::StrongRuleNode;
 use crate::selector_parser::PseudoElement;
 use servo_arc::{Arc, RawOffsetArc, UniqueArc};
-use std::marker::PhantomData;
 use std::mem::{forget, MaybeUninit};
 use std::{cmp, ops, ptr};
 use crate::values::{self, CustomIdent, Either, KeyframesName, None_};
@@ -2200,19 +2198,18 @@ fn static_assert() {
     }
 
     pub fn set_list_style_type(&mut self, v: longhands::list_style_type::computed_value::T) {
-        use crate::gecko_bindings::bindings::Gecko_SetCounterStyleToName;
-        use crate::gecko_bindings::bindings::Gecko_SetCounterStyleToString;
         use nsstring::{nsACString, nsCStr};
         use self::longhands::list_style_type::computed_value::T;
         match v {
             T::None => unsafe {
-                Gecko_SetCounterStyleToName(&mut self.gecko.mCounterStyle,
-                                            atom!("none").into_addrefed());
+                bindings::Gecko_SetCounterStyleToNone(&mut self.gecko.mCounterStyle)
             }
             T::CounterStyle(s) => s.to_gecko_value(&mut self.gecko.mCounterStyle),
             T::String(s) => unsafe {
-                Gecko_SetCounterStyleToString(&mut self.gecko.mCounterStyle,
-                                              &nsCStr::from(&s) as &nsACString)
+                bindings::Gecko_SetCounterStyleToString(
+                    &mut self.gecko.mCounterStyle,
+                    &nsCStr::from(&s) as &nsACString,
+                )
             }
         }
     }
@@ -2580,236 +2577,9 @@ clip-path
     ${impl_simple('column_rule_style', 'mColumnRuleStyle')}
 </%self:impl_trait>
 
-<%self:impl_trait style_struct_name="Counters" skip_longhands="content">
+<%self:impl_trait style_struct_name="Counters">
     pub fn ineffective_content_property(&self) -> bool {
-        self.gecko.mContents.is_empty()
-    }
-
-    pub fn set_content(&mut self, v: longhands::content::computed_value::T) {
-        use crate::values::CustomIdent;
-        use crate::values::generics::counters::{Content, ContentItem};
-        use crate::values::generics::CounterStyle;
-        use crate::gecko_bindings::structs::nsStyleContentData;
-        use crate::gecko_bindings::structs::nsStyleContentAttr;
-        use crate::gecko_bindings::structs::StyleContentType;
-        use crate::gecko_bindings::bindings::Gecko_ClearAndResizeStyleContents;
-
-        // Converts a string as utf16, and returns an owned, zero-terminated raw buffer.
-        fn as_utf16_and_forget(s: &str) -> *mut u16 {
-            use std::mem;
-            let mut vec = s.encode_utf16().collect::<Vec<_>>();
-            vec.push(0u16);
-            let ptr = vec.as_mut_ptr();
-            mem::forget(vec);
-            ptr
-        }
-
-        fn set_counter_function(
-            data: &mut nsStyleContentData,
-            content_type: StyleContentType,
-            name: CustomIdent,
-            sep: &str,
-            style: CounterStyle,
-        ) {
-            debug_assert!(content_type == StyleContentType::Counter ||
-                          content_type == StyleContentType::Counters);
-            let counter_func = unsafe {
-                bindings::Gecko_SetCounterFunction(data, content_type).as_mut().unwrap()
-            };
-            counter_func.mIdent.set_move(unsafe {
-                RefPtr::from_addrefed(name.0.into_addrefed())
-            });
-            if content_type == StyleContentType::Counters {
-                counter_func.mSeparator.assign_str(sep);
-            }
-            style.to_gecko_value(&mut counter_func.mCounterStyle);
-        }
-
-        match v {
-            Content::None |
-            Content::Normal => {
-                // Ensure destructors run, otherwise we could leak.
-                if !self.gecko.mContents.is_empty() {
-                    unsafe {
-                        Gecko_ClearAndResizeStyleContents(&mut *self.gecko, 0);
-                    }
-                }
-            },
-            Content::MozAltContent => {
-                unsafe {
-                    Gecko_ClearAndResizeStyleContents(&mut *self.gecko, 1);
-                    *self.gecko.mContents[0].mContent.mString.as_mut() = ptr::null_mut();
-                }
-                self.gecko.mContents[0].mType = StyleContentType::AltContent;
-            },
-            Content::Items(items) => {
-                unsafe {
-                    Gecko_ClearAndResizeStyleContents(&mut *self.gecko,
-                                                      items.len() as u32);
-                }
-                for (i, item) in items.into_vec().into_iter().enumerate() {
-                    // NB: Gecko compares the mString value if type is not image
-                    // or URI independently of whatever gets there. In the quote
-                    // cases, they set it to null, so do the same here.
-                    unsafe {
-                        *self.gecko.mContents[i].mContent.mString.as_mut() = ptr::null_mut();
-                    }
-                    match item {
-                        ContentItem::String(ref value) => {
-                            self.gecko.mContents[i].mType = StyleContentType::String;
-                            unsafe {
-                                // NB: we share allocators, so doing this is fine.
-                                *self.gecko.mContents[i].mContent.mString.as_mut() =
-                                    as_utf16_and_forget(&value);
-                            }
-                        }
-                        ContentItem::Attr(ref attr) => {
-                            self.gecko.mContents[i].mType = StyleContentType::Attr;
-                            unsafe {
-                                // NB: we share allocators, so doing this is fine.
-                                let maybe_ns = attr.namespace.clone();
-                                let attr_struct = Box::new(nsStyleContentAttr {
-                                    mName: structs::RefPtr {
-                                        mRawPtr: attr.attribute.clone().into_addrefed(),
-                                        _phantom_0: PhantomData,
-                                    },
-                                    mNamespaceURL: structs::RefPtr {
-                                        mRawPtr: maybe_ns.map_or(ptr::null_mut(), |x| (x.1).0.into_addrefed()),
-                                        _phantom_0: PhantomData,
-                                    },
-                                });
-                                *self.gecko.mContents[i].mContent.mAttr.as_mut() =
-                                    Box::into_raw(attr_struct);
-                            }
-                        }
-                        ContentItem::OpenQuote
-                            => self.gecko.mContents[i].mType = StyleContentType::OpenQuote,
-                        ContentItem::CloseQuote
-                            => self.gecko.mContents[i].mType = StyleContentType::CloseQuote,
-                        ContentItem::NoOpenQuote
-                            => self.gecko.mContents[i].mType = StyleContentType::NoOpenQuote,
-                        ContentItem::NoCloseQuote
-                            => self.gecko.mContents[i].mType = StyleContentType::NoCloseQuote,
-                        ContentItem::Counter(name, style) => {
-                            set_counter_function(
-                                &mut self.gecko.mContents[i],
-                                StyleContentType::Counter,
-                                name,
-                                "",
-                                style,
-                            );
-                        }
-                        ContentItem::Counters(name, sep, style) => {
-                            set_counter_function(
-                                &mut self.gecko.mContents[i],
-                                StyleContentType::Counters,
-                                name,
-                                &sep,
-                                style,
-                            );
-                        }
-                        ContentItem::Url(ref url) => {
-                            unsafe {
-                                bindings::Gecko_SetContentDataImageValue(
-                                    &mut self.gecko.mContents[i],
-                                    url,
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn copy_content_from(&mut self, other: &Self) {
-        use crate::gecko_bindings::bindings::Gecko_CopyStyleContentsFrom;
-        unsafe {
-            Gecko_CopyStyleContentsFrom(&mut *self.gecko, &*other.gecko)
-        }
-    }
-
-    pub fn reset_content(&mut self, other: &Self) {
-        self.copy_content_from(other)
-    }
-
-    pub fn clone_content(&self) -> longhands::content::computed_value::T {
-        use {Atom, Namespace};
-        use crate::gecko::conversions::string_from_chars_pointer;
-        use crate::gecko_bindings::structs::StyleContentType;
-        use crate::values::generics::counters::{Content, ContentItem};
-        use crate::values::{CustomIdent, Either};
-        use crate::values::generics::CounterStyle;
-        use crate::values::specified::Attr;
-
-        if self.gecko.mContents.is_empty() {
-            return Content::None;
-        }
-
-        if self.gecko.mContents.len() == 1 &&
-           self.gecko.mContents[0].mType == StyleContentType::AltContent {
-            return Content::MozAltContent;
-        }
-
-        Content::Items(
-            self.gecko.mContents.iter().map(|gecko_content| {
-                match gecko_content.mType {
-                    StyleContentType::OpenQuote => ContentItem::OpenQuote,
-                    StyleContentType::CloseQuote => ContentItem::CloseQuote,
-                    StyleContentType::NoOpenQuote => ContentItem::NoOpenQuote,
-                    StyleContentType::NoCloseQuote => ContentItem::NoCloseQuote,
-                    StyleContentType::String => {
-                        let gecko_chars = unsafe { gecko_content.mContent.mString.as_ref() };
-                        let string = unsafe { string_from_chars_pointer(*gecko_chars) };
-                        ContentItem::String(string.into_boxed_str())
-                    },
-                    StyleContentType::Attr => {
-                        let (namespace, attribute) = unsafe {
-                            let s = &**gecko_content.mContent.mAttr.as_ref();
-                            let ns = if s.mNamespaceURL.mRawPtr.is_null() {
-                                None
-                            } else {
-                                // FIXME(bholley): We don't have any way to get the prefix here. :-(
-                                let prefix = atom!("");
-                                Some((prefix, Namespace(Atom::from_raw(s.mNamespaceURL.mRawPtr))))
-                            };
-                            (ns, Atom::from_raw(s.mName.mRawPtr))
-                        };
-                        ContentItem::Attr(Attr { namespace, attribute })
-                    },
-                    StyleContentType::Counter | StyleContentType::Counters => {
-                        let gecko_function =
-                            unsafe { &**gecko_content.mContent.mCounters.as_ref() };
-                        let ident = CustomIdent(unsafe {
-                            Atom::from_raw(gecko_function.mIdent.mRawPtr)
-                        });
-                        let style =
-                            CounterStyle::from_gecko_value(&gecko_function.mCounterStyle);
-                        let style = match style {
-                            Either::First(counter_style) => counter_style,
-                            Either::Second(_) =>
-                                unreachable!("counter function shouldn't have single string type"),
-                        };
-                        if gecko_content.mType == StyleContentType::Counter {
-                            ContentItem::Counter(ident, style)
-                        } else {
-                            let separator = gecko_function.mSeparator.to_string();
-                            ContentItem::Counters(ident, separator.into_boxed_str(), style)
-                        }
-                    },
-                    StyleContentType::Image => {
-                        unsafe {
-                            let gecko_image_request =
-                                &**gecko_content.mContent.mImage.as_ref();
-                            ContentItem::Url(
-                                ComputedImageUrl::from_image_request(gecko_image_request)
-                            )
-                        }
-                    },
-                    _ => panic!("Found unexpected value in style struct for content property"),
-                }
-            }).collect::<Vec<_>>().into_boxed_slice()
-        )
+        !self.gecko.mContent.is_items()
     }
 </%self:impl_trait>
 
diff --git a/components/style/values/computed/counters.rs b/components/style/values/computed/counters.rs
index 3a083632eb9..40cfe46efa6 100644
--- a/components/style/values/computed/counters.rs
+++ b/components/style/values/computed/counters.rs
@@ -16,7 +16,7 @@ pub type CounterIncrement = GenericCounterIncrement<i32>;
 pub type CounterSetOrReset = GenericCounterSetOrReset<i32>;
 
 /// A computed value for the `content` property.
-pub type Content = generics::Content<ComputedImageUrl>;
+pub type Content = generics::GenericContent<ComputedImageUrl>;
 
 /// A computed content item.
-pub type ContentItem = generics::ContentItem<ComputedImageUrl>;
+pub type ContentItem = generics::GenericContentItem<ComputedImageUrl>;
diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs
index f5b3440f426..958deaaf44e 100644
--- a/components/style/values/computed/mod.rs
+++ b/components/style/values/computed/mod.rs
@@ -471,6 +471,7 @@ trivial_to_computed_value!(Atom);
 trivial_to_computed_value!(Prefix);
 trivial_to_computed_value!(String);
 trivial_to_computed_value!(Box<str>);
+trivial_to_computed_value!(crate::OwnedStr);
 
 /// A `<number>` value.
 pub type Number = CSSFloat;
diff --git a/components/style/values/generics/counters.rs b/components/style/values/generics/counters.rs
index 69893c75561..9ed8cdba68b 100644
--- a/components/style/values/generics/counters.rs
+++ b/components/style/values/generics/counters.rs
@@ -153,22 +153,26 @@ fn is_decimal(counter_type: &CounterStyleType) -> bool {
     SpecifiedValueInfo,
     ToComputedValue,
     ToCss,
-    ToResolvedValue,
     ToShmem,
 )]
-pub enum Content<ImageUrl> {
+#[repr(u8)]
+pub enum GenericContent<ImageUrl> {
     /// `normal` reserved keyword.
     Normal,
     /// `none` reserved keyword.
     None,
-    /// `-moz-alt-content`.
-    #[cfg(feature = "gecko")]
-    MozAltContent,
     /// Content items.
-    Items(#[css(iterable)] Box<[ContentItem<ImageUrl>]>),
+    Items(#[css(iterable)] crate::OwnedSlice<GenericContentItem<ImageUrl>>),
 }
 
+pub use self::GenericContent as Content;
+
 impl<ImageUrl> Content<ImageUrl> {
+    #[inline]
+    pub(crate) fn is_items(&self) -> bool {
+        matches!(*self, Self::Items(..))
+    }
+
     /// Set `content` property to `normal`.
     #[inline]
     pub fn normal() -> Self {
@@ -189,9 +193,10 @@ impl<ImageUrl> Content<ImageUrl> {
     ToResolvedValue,
     ToShmem,
 )]
-pub enum ContentItem<ImageUrl> {
+#[repr(u8)]
+pub enum GenericContentItem<ImageUrl> {
     /// Literal string content.
-    String(Box<str>),
+    String(crate::OwnedStr),
     /// `counter(name, style)`.
     #[css(comma, function)]
     Counter(CustomIdent, #[css(skip_if = "is_decimal")] CounterStyleType),
@@ -199,7 +204,7 @@ pub enum ContentItem<ImageUrl> {
     #[css(comma, function)]
     Counters(
         CustomIdent,
-        Box<str>,
+        crate::OwnedStr,
         #[css(skip_if = "is_decimal")] CounterStyleType,
     ),
     /// `open-quote`.
@@ -210,9 +215,14 @@ pub enum ContentItem<ImageUrl> {
     NoOpenQuote,
     /// `no-close-quote`.
     NoCloseQuote,
+    /// `-moz-alt-content`.
+    #[cfg(feature = "gecko")]
+    MozAltContent,
     /// `attr([namespace? `|`]? ident)`
     #[cfg(feature = "gecko")]
     Attr(Attr),
     /// `url(url)`
     Url(ImageUrl),
 }
+
+pub use self::GenericContentItem as ContentItem;
diff --git a/components/style/values/generics/mod.rs b/components/style/values/generics/mod.rs
index 4db80abc8a8..a97d9e1018a 100644
--- a/components/style/values/generics/mod.rs
+++ b/components/style/values/generics/mod.rs
@@ -39,7 +39,7 @@ pub mod transform;
 pub mod ui;
 pub mod url;
 
-// https://drafts.csswg.org/css-counter-styles/#typedef-symbols-type
+/// https://drafts.csswg.org/css-counter-styles/#typedef-symbols-type
 #[allow(missing_docs)]
 #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
 #[derive(
@@ -55,6 +55,7 @@ pub mod url;
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(u8)]
 pub enum SymbolsType {
     Cyclic,
     Numeric,
@@ -63,39 +64,12 @@ pub enum SymbolsType {
     Fixed,
 }
 
-#[cfg(feature = "gecko")]
-impl SymbolsType {
-    /// Convert symbols type to their corresponding Gecko values.
-    pub fn to_gecko_keyword(self) -> u8 {
-        use crate::gecko_bindings::structs;
-        match self {
-            SymbolsType::Cyclic => structs::NS_STYLE_COUNTER_SYSTEM_CYCLIC as u8,
-            SymbolsType::Numeric => structs::NS_STYLE_COUNTER_SYSTEM_NUMERIC as u8,
-            SymbolsType::Alphabetic => structs::NS_STYLE_COUNTER_SYSTEM_ALPHABETIC as u8,
-            SymbolsType::Symbolic => structs::NS_STYLE_COUNTER_SYSTEM_SYMBOLIC as u8,
-            SymbolsType::Fixed => structs::NS_STYLE_COUNTER_SYSTEM_FIXED as u8,
-        }
-    }
-
-    /// Convert Gecko value to symbol type.
-    pub fn from_gecko_keyword(gecko_value: u32) -> SymbolsType {
-        use crate::gecko_bindings::structs;
-        match gecko_value {
-            structs::NS_STYLE_COUNTER_SYSTEM_CYCLIC => SymbolsType::Cyclic,
-            structs::NS_STYLE_COUNTER_SYSTEM_NUMERIC => SymbolsType::Numeric,
-            structs::NS_STYLE_COUNTER_SYSTEM_ALPHABETIC => SymbolsType::Alphabetic,
-            structs::NS_STYLE_COUNTER_SYSTEM_SYMBOLIC => SymbolsType::Symbolic,
-            structs::NS_STYLE_COUNTER_SYSTEM_FIXED => SymbolsType::Fixed,
-            x => panic!("Unexpected value for symbol type {}", x),
-        }
-    }
-}
-
 /// <https://drafts.csswg.org/css-counter-styles/#typedef-counter-style>
 ///
 /// Note that 'none' is not a valid name.
 #[cfg_attr(feature = "gecko", derive(MallocSizeOf))]
 #[derive(Clone, Debug, Eq, PartialEq, ToComputedValue, ToCss, ToResolvedValue, ToShmem)]
+#[repr(u8)]
 pub enum CounterStyle {
     /// `<counter-style-name>`
     Name(CustomIdent),
diff --git a/components/style/values/resolved/counters.rs b/components/style/values/resolved/counters.rs
new file mode 100644
index 00000000000..daf70359061
--- /dev/null
+++ b/components/style/values/resolved/counters.rs
@@ -0,0 +1,46 @@
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+//! Resolved values for counter properties
+
+use super::{Context, ToResolvedValue};
+use crate::values::computed;
+
+/// https://drafts.csswg.org/css-content/#content-property
+///
+/// We implement this at resolved value time because otherwise it causes us to
+/// allocate a bunch of useless initial structs for ::before / ::after, which is
+/// a bit unfortunate.
+///
+/// Though these should be temporary, mostly, so if this causes complexity in
+/// other places, it should be fine to move to `StyleAdjuster`.
+///
+/// See https://github.com/w3c/csswg-drafts/issues/4632 for where some related
+/// issues are being discussed.
+impl ToResolvedValue for computed::Content {
+    type ResolvedValue = Self;
+
+    #[inline]
+    fn to_resolved_value(self, context: &Context) -> Self {
+        let is_before_or_after =
+            context.style.pseudo().map_or(false, |p| p.is_before_or_after());
+
+        match self {
+            Self::Normal if is_before_or_after => Self::None,
+            // For now, make `content: none` compute to `normal` on other
+            // elements, as we don't respect it.
+            //
+            // FIXME(emilio, bug 1605473): for marker this should be preserved
+            // and respected, probably.
+            Self::None if !is_before_or_after => Self::Normal,
+            other => other,
+        }
+    }
+
+    #[inline]
+    fn from_resolved_value(resolved: Self) -> Self {
+        resolved
+    }
+}
+
diff --git a/components/style/values/resolved/mod.rs b/components/style/values/resolved/mod.rs
index e64178a1c95..f50f58b5db4 100644
--- a/components/style/values/resolved/mod.rs
+++ b/components/style/values/resolved/mod.rs
@@ -10,6 +10,7 @@ use cssparser;
 use smallvec::SmallVec;
 
 mod color;
+mod counters;
 
 use crate::values::computed;
 
@@ -68,6 +69,7 @@ trivial_to_resolved_value!(u32);
 trivial_to_resolved_value!(usize);
 trivial_to_resolved_value!(String);
 trivial_to_resolved_value!(Box<str>);
+trivial_to_resolved_value!(crate::OwnedStr);
 trivial_to_resolved_value!(cssparser::RGBA);
 trivial_to_resolved_value!(crate::Atom);
 trivial_to_resolved_value!(app_units::Au);
diff --git a/components/style/values/specified/counters.rs b/components/style/values/specified/counters.rs
index 09020e73448..15898b58f47 100644
--- a/components/style/values/specified/counters.rs
+++ b/components/style/values/specified/counters.rs
@@ -9,8 +9,6 @@ use crate::computed_values::list_style_type::T as ListStyleType;
 use crate::parser::{Parse, ParserContext};
 use crate::values::generics::counters as generics;
 use crate::values::generics::counters::CounterPair;
-use crate::values::generics::counters::GenericCounterIncrement;
-use crate::values::generics::counters::GenericCounterSetOrReset;
 #[cfg(feature = "gecko")]
 use crate::values::generics::CounterStyle;
 use crate::values::specified::url::SpecifiedImageUrl;
@@ -23,7 +21,7 @@ use selectors::parser::SelectorParseErrorKind;
 use style_traits::{ParseError, StyleParseErrorKind};
 
 /// A specified value for the `counter-increment` property.
-pub type CounterIncrement = GenericCounterIncrement<Integer>;
+pub type CounterIncrement = generics::GenericCounterIncrement<Integer>;
 
 impl Parse for CounterIncrement {
     fn parse<'i, 't>(
@@ -35,7 +33,7 @@ impl Parse for CounterIncrement {
 }
 
 /// A specified value for the `counter-set` and `counter-reset` properties.
-pub type CounterSetOrReset = GenericCounterSetOrReset<Integer>;
+pub type CounterSetOrReset = generics::GenericCounterSetOrReset<Integer>;
 
 impl Parse for CounterSetOrReset {
     fn parse<'i, 't>(
@@ -84,10 +82,10 @@ fn parse_counters<'i, 't>(
 }
 
 /// The specified value for the `content` property.
-pub type Content = generics::Content<SpecifiedImageUrl>;
+pub type Content = generics::GenericContent<SpecifiedImageUrl>;
 
 /// The specified value for a content item in the `content` property.
-pub type ContentItem = generics::ContentItem<SpecifiedImageUrl>;
+pub type ContentItem = generics::GenericContentItem<SpecifiedImageUrl>;
 
 impl Content {
     #[cfg(feature = "servo")]
@@ -131,17 +129,9 @@ impl Parse for Content {
         {
             return Ok(generics::Content::None);
         }
-        #[cfg(feature = "gecko")]
-        {
-            if input
-                .try(|input| input.expect_ident_matching("-moz-alt-content"))
-                .is_ok()
-            {
-                return Ok(generics::Content::MozAltContent);
-            }
-        }
 
         let mut content = vec![];
+        let mut has_alt_content = false;
         loop {
             #[cfg(feature = "gecko")]
             {
@@ -153,7 +143,7 @@ impl Parse for Content {
             match input.next() {
                 Ok(&Token::QuotedString(ref value)) => {
                     content.push(generics::ContentItem::String(
-                        value.as_ref().to_owned().into_boxed_str(),
+                        value.as_ref().to_owned().into(),
                     ));
                 },
                 Ok(&Token::Function(ref name)) => {
@@ -168,7 +158,7 @@ impl Parse for Content {
                             let location = input.current_source_location();
                             let name = CustomIdent::from_ident(location, input.expect_ident()?, &[])?;
                             input.expect_comma()?;
-                            let separator = input.expect_string()?.as_ref().to_owned().into_boxed_str();
+                            let separator = input.expect_string()?.as_ref().to_owned().into();
                             let style = Content::parse_counter_style(context, input);
                             Ok(generics::ContentItem::Counters(name, separator, style))
                         }),
@@ -191,6 +181,11 @@ impl Parse for Content {
                         "close-quote" => generics::ContentItem::CloseQuote,
                         "no-open-quote" => generics::ContentItem::NoOpenQuote,
                         "no-close-quote" => generics::ContentItem::NoCloseQuote,
+                        #[cfg(feature = "gecko")]
+                        "-moz-alt-content" => {
+                            has_alt_content = true;
+                            generics::ContentItem::MozAltContent
+                        },
                         _ =>{
                             let ident = ident.clone();
                             return Err(input.new_custom_error(
@@ -206,9 +201,10 @@ impl Parse for Content {
                 },
             }
         }
-        if content.is_empty() {
+        // We don't allow to parse `-moz-alt-content in multiple positions.
+        if content.is_empty() || (has_alt_content && content.len() != 1) {
             return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
         }
-        Ok(generics::Content::Items(content.into_boxed_slice()))
+        Ok(generics::Content::Items(content.into()))
     }
 }
diff --git a/components/style/values/specified/mod.rs b/components/style/values/specified/mod.rs
index 7f3ecfb96b3..7e16ba09601 100644
--- a/components/style/values/specified/mod.rs
+++ b/components/style/values/specified/mod.rs
@@ -767,9 +767,12 @@ impl AllowQuirks {
     ToShmem,
 )]
 #[css(function)]
+#[repr(C)]
 pub struct Attr {
-    /// Optional namespace prefix and URL.
-    pub namespace: Option<(Prefix, Namespace)>,
+    /// Optional namespace prefix.
+    pub namespace_prefix: Prefix,
+    /// Optional namespace URL.
+    pub namespace_url: Namespace,
     /// Attribute name
     pub attribute: Atom,
 }
@@ -814,7 +817,7 @@ impl Attr {
                         ref t => return Err(location.new_unexpected_token_error(t.clone())),
                     };
 
-                    let prefix_and_ns = if let Some(ns) = first {
+                    let (namespace_prefix, namespace_url) = if let Some(ns) = first {
                         let prefix = Prefix::from(ns.as_ref());
                         let ns = match get_namespace_for_prefix(&prefix, context) {
                             Some(ns) => ns,
@@ -823,17 +826,18 @@ impl Attr {
                                     .new_custom_error(StyleParseErrorKind::UnspecifiedError));
                             },
                         };
-                        Some((prefix, ns))
+                        (prefix, ns)
                     } else {
-                        None
+                        (Prefix::default(), Namespace::default())
                     };
                     return Ok(Attr {
-                        namespace: prefix_and_ns,
+                        namespace_prefix,
+                        namespace_url,
                         attribute: Atom::from(second_token.as_ref()),
                     });
                 },
                 // In the case of attr(foobar    ) we don't want to error out
-                // because of the trailing whitespace
+                // because of the trailing whitespace.
                 Token::WhiteSpace(..) => {},
                 ref t => return Err(input.new_unexpected_token_error(t.clone())),
             }
@@ -841,7 +845,8 @@ impl Attr {
 
         if let Some(first) = first {
             Ok(Attr {
-                namespace: None,
+                namespace_prefix: Prefix::default(),
+                namespace_url: Namespace::default(),
                 attribute: Atom::from(first.as_ref()),
             })
         } else {
@@ -856,8 +861,8 @@ impl ToCss for Attr {
         W: Write,
     {
         dest.write_str("attr(")?;
-        if let Some((ref prefix, ref _url)) = self.namespace {
-            serialize_atom_identifier(prefix, dest)?;
+        if !self.namespace_prefix.is_empty() {
+            serialize_atom_identifier(&self.namespace_prefix, dest)?;
             dest.write_str("|")?;
         }
         serialize_atom_identifier(&self.attribute, dest)?;

From 718a9b1f05292be3afc552eab20fcf65803348ed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Tue, 7 Jan 2020 21:00:42 +0000
Subject: [PATCH 08/66] style: Make display: -moz-box more similar to other
 display types for block layout.

It is unexpected (see bug) that a -moz-box is affected by baseline alignment.
Make -moz-box be block-outside, and -moz-inline-box be inline-outside, instead
of the bespoke thing we have now.

This is more similar to everything else, and fixes the bug.

Differential Revision: https://phabricator.services.mozilla.com/D58726
---
 components/style/values/specified/box.rs | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/components/style/values/specified/box.rs b/components/style/values/specified/box.rs
index 1549f66e8e9..2f114b5bb0a 100644
--- a/components/style/values/specified/box.rs
+++ b/components/style/values/specified/box.rs
@@ -98,8 +98,6 @@ pub enum DisplayInside {
     #[cfg(feature = "gecko")]
     MozBox,
     #[cfg(feature = "gecko")]
-    MozInlineBox,
-    #[cfg(feature = "gecko")]
     MozGrid,
     #[cfg(feature = "gecko")]
     MozGridGroup,
@@ -221,9 +219,9 @@ impl Display {
 
     /// XUL boxes.
     #[cfg(feature = "gecko")]
-    pub const MozBox: Self = Self::new(DisplayOutside::XUL, DisplayInside::MozBox);
+    pub const MozBox: Self = Self::new(DisplayOutside::Block, DisplayInside::MozBox);
     #[cfg(feature = "gecko")]
-    pub const MozInlineBox: Self = Self::new(DisplayOutside::XUL, DisplayInside::MozInlineBox);
+    pub const MozInlineBox: Self = Self::new(DisplayOutside::Inline, DisplayInside::MozBox);
     #[cfg(feature = "gecko")]
     pub const MozGrid: Self = Self::new(DisplayOutside::XUL, DisplayInside::MozGrid);
     #[cfg(feature = "gecko")]
@@ -375,11 +373,6 @@ impl Display {
                 };
                 Display::from3(DisplayOutside::Block, inside, self.is_list_item())
             },
-            #[cfg(feature = "gecko")]
-            DisplayOutside::XUL => match self.inside() {
-                DisplayInside::MozInlineBox | DisplayInside::MozBox => Display::MozBox,
-                _ => Display::Block,
-            },
             DisplayOutside::Block | DisplayOutside::None => *self,
             #[cfg(any(feature = "servo-layout-2013", feature = "gecko"))]
             _ => Display::Block,
@@ -400,11 +393,6 @@ impl Display {
                 };
                 Display::from3(DisplayOutside::Inline, inside, self.is_list_item())
             },
-            #[cfg(feature = "gecko")]
-            DisplayOutside::XUL => match self.inside() {
-                DisplayInside::MozBox => Display::MozInlineBox,
-                _ => *self,
-            },
             _ => *self,
         }
     }

From d459e3453ae309302537a4c9937336a14f632e5e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Wed, 8 Jan 2020 00:55:18 +0000
Subject: [PATCH 09/66] style: Make an assertion a release assert in nightly.

If this can happen legitimately, this will help fuzzers to catch it.

Differential Revision: https://phabricator.services.mozilla.com/D59066
---
 components/style/rule_tree/mod.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs
index 19e3accb851..fa859d79f06 100644
--- a/components/style/rule_tree/mod.rs
+++ b/components/style/rule_tree/mod.rs
@@ -1719,7 +1719,10 @@ impl Drop for StrongRuleNode {
             return;
         }
 
-        debug_assert!(node.children.read().is_empty());
+        if cfg!(debug_assertions) || crate::gecko_bindings::structs::GECKO_IS_NIGHTLY {
+            assert!(node.children.read().is_empty());
+        }
+
         if node.parent.is_none() {
             debug!("Dropping root node!");
             // The free list should be null by this point

From 25fda147f38ecb65ebb8e58b5cfce6b92a7bdf8a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Thu, 9 Jan 2020 11:36:02 +0000
Subject: [PATCH 10/66] style: Minor comment fix.

Differential Revision: https://phabricator.services.mozilla.com/D59310
---
 components/style/sharing/checks.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/style/sharing/checks.rs b/components/style/sharing/checks.rs
index 9c860f0258f..5e8350e78d3 100644
--- a/components/style/sharing/checks.rs
+++ b/components/style/sharing/checks.rs
@@ -94,7 +94,7 @@ where
     target.class_list() == candidate.class_list()
 }
 
-/// Whether a given element has the same class attribute as a given candidate.
+/// Whether a given element has the same part attribute as a given candidate.
 ///
 /// We don't try to share style across elements with different part attributes.
 pub fn have_same_parts<E>(

From ec37e7a5b815d4ac5e393fdf5d035495a8d9d49c Mon Sep 17 00:00:00 2001
From: Xidorn Quan <me@upsuper.org>
Date: Fri, 10 Jan 2020 23:47:28 +0000
Subject: [PATCH 11/66] style: Ensure nested ruby level container don't escape
 from line break suppression.

Differential Revision: https://phabricator.services.mozilla.com/D58351
---
 components/style/style_adjuster.rs | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/components/style/style_adjuster.rs b/components/style/style_adjuster.rs
index 36463aad6fb..a66c9462c92 100644
--- a/components/style/style_adjuster.rs
+++ b/components/style/style_adjuster.rs
@@ -547,7 +547,14 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
     }
 
     #[cfg(feature = "gecko")]
-    fn should_suppress_linebreak(&self, layout_parent_style: &ComputedValues) -> bool {
+    fn should_suppress_linebreak<E>(
+        &self,
+        layout_parent_style: &ComputedValues,
+        element: Option<E>,
+    ) -> bool
+    where
+        E: TElement,
+    {
         // Line break suppression should only be propagated to in-flow children.
         if self.style.is_floating() || self.style.is_absolutely_positioned() {
             return false;
@@ -567,11 +574,18 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
             // Ruby base and text are always non-breakable.
             Display::RubyBase | Display::RubyText => true,
             // Ruby base container and text container are breakable.
+            // Non-HTML elements may not form ruby base / text container because
+            // they may not respect ruby-internal display values, so we can't
+            // make them escaped from line break suppression.
             // Note that, when certain HTML tags, e.g. form controls, have ruby
             // level container display type, they could also escape from the
             // line break suppression flag while they shouldn't. However, it is
-            // generally fine since they themselves are non-breakable.
-            Display::RubyBaseContainer | Display::RubyTextContainer => false,
+            // generally fine as far as they can't break the line inside them.
+            Display::RubyBaseContainer | Display::RubyTextContainer
+                if element.map_or(true, |e| e.is_html_element()) =>
+            {
+                false
+            },
             // Anything else is non-breakable if and only if its layout parent
             // has a ruby display type, because any of the ruby boxes can be
             // anonymous.
@@ -593,7 +607,7 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
 
         let self_display = self.style.get_box().clone_display();
         // Check whether line break should be suppressed for this element.
-        if self.should_suppress_linebreak(layout_parent_style) {
+        if self.should_suppress_linebreak(layout_parent_style, element) {
             self.style
                 .add_flags(ComputedValueFlags::SHOULD_SUPPRESS_LINEBREAK);
             // Inlinify the display type if allowed.

From 61f3ff1de3b973efc2074e4b7251e11692bee12f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 13 Jan 2020 13:21:58 +0000
Subject: [PATCH 12/66] style: Split LengthPercentage again.

This is needed to support min() / max() / clamp(), etc, as those need to be a
tree of values and thus need heap storage.

This unfortunately grows LengthPercentage to be two pointers, which is bad as
it blows up the size of nsStylePosition enough to trigger the size assertions.

This patch comments out the assertion for now, the follow-up patches will
uncomment them.

Differential Revision: https://phabricator.services.mozilla.com/D58700
---
 components/style/gecko/media_queries.rs       |   3 +-
 components/style/values/animated/length.rs    |  11 +-
 components/style/values/animated/mod.rs       |  10 +
 components/style/values/computed/length.rs    | 453 +++++++++++-------
 components/style/values/specified/gecko.rs    |   2 +-
 components/style/values/specified/position.rs |   2 +-
 6 files changed, 304 insertions(+), 177 deletions(-)

diff --git a/components/style/gecko/media_queries.rs b/components/style/gecko/media_queries.rs
index 3f82b832bce..390c1d4fe58 100644
--- a/components/style/gecko/media_queries.rs
+++ b/components/style/gecko/media_queries.rs
@@ -138,8 +138,7 @@ impl Device {
 
     /// Set the font size of the root element (for rem)
     pub fn set_root_font_size(&self, size: Au) {
-        self.root_font_size
-            .store(size.0 as isize, Ordering::Relaxed)
+        self.root_font_size.store(size.0 as isize, Ordering::Relaxed)
     }
 
     /// Sets the body text color for the "inherit color from body" quirk.
diff --git a/components/style/values/animated/length.rs b/components/style/values/animated/length.rs
index 04a0844dbe0..ece26a9c491 100644
--- a/components/style/values/animated/length.rs
+++ b/components/style/values/animated/length.rs
@@ -5,7 +5,7 @@
 //! Animation implementation for various length-related types.
 
 use super::{Animate, Procedure};
-use crate::values::computed::length::LengthPercentage;
+use crate::values::computed::length::{LengthPercentage, CalcLengthPercentage};
 use crate::values::computed::Percentage;
 
 /// <https://drafts.csswg.org/css-transitions/#animtype-lpcalc>
@@ -26,10 +26,9 @@ impl Animate for LengthPercentage {
             .animate(&other.unclamped_length(), procedure)?;
         let percentage =
             animate_percentage_half(self.specified_percentage(), other.specified_percentage())?;
-        Ok(Self::with_clamping_mode(
-            length,
-            percentage,
-            self.clamping_mode,
-        ))
+
+        // Gets clamped as needed after the animation, so no need to specify any
+        // particular AllowedNumericType.
+        Ok(CalcLengthPercentage::new(length, percentage).to_length_percentge())
     }
 }
diff --git a/components/style/values/animated/mod.rs b/components/style/values/animated/mod.rs
index ea43d01112e..7cac407adcb 100644
--- a/components/style/values/animated/mod.rs
+++ b/components/style/values/animated/mod.rs
@@ -424,6 +424,16 @@ impl ToAnimatedZero for i32 {
     }
 }
 
+impl<T> ToAnimatedZero for Box<T>
+where
+    T: ToAnimatedZero,
+{
+    #[inline]
+    fn to_animated_zero(&self) -> Result<Self, ()> {
+        Ok(Box::new((**self).to_animated_zero()?))
+    }
+}
+
 impl<T> ToAnimatedZero for Option<T>
 where
     T: ToAnimatedZero,
diff --git a/components/style/values/computed/length.rs b/components/style/values/computed/length.rs
index 485ef954d8e..285d9d2e6d4 100644
--- a/components/style/values/computed/length.rs
+++ b/components/style/values/computed/length.rs
@@ -18,7 +18,6 @@ use crate::values::specified::length::{AbsoluteLength, FontBaseSize, FontRelativ
 use crate::values::{specified, CSSFloat};
 use crate::Zero;
 use app_units::Au;
-use ordered_float::NotNan;
 use std::fmt::{self, Write};
 use std::ops::{Add, AddAssign, Div, Mul, Neg, Sub};
 use style_traits::values::specified::AllowedNumericType;
@@ -54,13 +53,13 @@ impl ToComputedValue for specified::NoCalcLength {
 }
 
 impl ToComputedValue for specified::Length {
-    type ComputedValue = CSSPixelLength;
+    type ComputedValue = Length;
 
     #[inline]
     fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
         match *self {
             specified::Length::NoCalc(l) => l.to_computed_value(context),
-            specified::Length::Calc(ref calc) => calc.to_computed_value(context).length(),
+            specified::Length::Calc(ref calc) => calc.to_computed_value(context).length_component(),
         }
     }
 
@@ -73,15 +72,32 @@ impl ToComputedValue for specified::Length {
 /// A `<length-percentage>` value. This can be either a `<length>`, a
 /// `<percentage>`, or a combination of both via `calc()`.
 ///
+/// cbindgen:private-default-tagged-enum-constructor=false
+/// cbindgen:derive-mut-casts=true
+///
 /// https://drafts.csswg.org/css-values-4/#typedef-length-percentage
 #[allow(missing_docs)]
-#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue)]
+#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, ToAnimatedZero, ToResolvedValue)]
+#[repr(u8)]
+pub enum LengthPercentage {
+    Length(Length),
+    Percentage(Percentage),
+    Calc(Box<CalcLengthPercentage>),
+}
+
+/// The representation of a calc() function.
+#[derive(
+    Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue,
+)]
 #[repr(C)]
-pub struct LengthPercentage {
+pub struct CalcLengthPercentage {
     length: Length,
+
     percentage: Percentage,
+
     #[animation(constant)]
-    pub clamping_mode: AllowedNumericType,
+    clamping_mode: AllowedNumericType,
+
     /// Whether we specified a percentage or not.
     #[animation(constant)]
     pub has_percentage: bool,
@@ -99,7 +115,7 @@ pub struct LengthPercentage {
 // We may want to just eagerly-detect whether we can clamp in
 // `LengthPercentage::new` and switch to `AllowedNumericType::NonNegative` then,
 // maybe.
-impl PartialEq for LengthPercentage {
+impl PartialEq for CalcLengthPercentage {
     fn eq(&self, other: &Self) -> bool {
         self.length == other.length &&
             self.percentage == other.percentage &&
@@ -115,123 +131,8 @@ impl ComputeSquaredDistance for LengthPercentage {
         Ok(self
             .unclamped_length()
             .compute_squared_distance(&other.unclamped_length())? +
-            self.percentage
-                .compute_squared_distance(&other.percentage)?)
-    }
-}
-
-impl LengthPercentage {
-    /// Returns a new `LengthPercentage`.
-    #[inline]
-    pub fn new(length: Length, percentage: Option<Percentage>) -> Self {
-        Self::with_clamping_mode(length, percentage, AllowedNumericType::All)
-    }
-
-    /// Returns a new `LengthPercentage` with zero length and some percentage.
-    pub fn new_percent(percentage: Percentage) -> Self {
-        Self::new(Length::zero(), Some(percentage))
-    }
-
-    /// Returns a new `LengthPercentage` with a specific clamping mode.
-    #[inline]
-    pub fn with_clamping_mode(
-        length: Length,
-        percentage: Option<Percentage>,
-        clamping_mode: AllowedNumericType,
-    ) -> Self {
-        Self {
-            clamping_mode,
-            length,
-            percentage: percentage.unwrap_or_default(),
-            has_percentage: percentage.is_some(),
-        }
-    }
-
-    /// Returns this `calc()` as a `<length>`.
-    ///
-    /// Panics in debug mode if a percentage is present in the expression.
-    #[inline]
-    pub fn length(&self) -> CSSPixelLength {
-        debug_assert!(!self.has_percentage);
-        self.length_component()
-    }
-
-    /// Returns the length component of this `calc()`
-    #[inline]
-    pub fn length_component(&self) -> CSSPixelLength {
-        CSSPixelLength::new(self.clamping_mode.clamp(self.length.px()))
-    }
-
-    /// Returns the `<length>` component of this `calc()`, unclamped.
-    #[inline]
-    pub fn unclamped_length(&self) -> CSSPixelLength {
-        self.length
-    }
-
-    /// Returns the percentage component of this `calc()`
-    #[inline]
-    pub fn percentage_component(&self) -> Percentage {
-        Percentage(self.clamping_mode.clamp(self.percentage.0))
-    }
-
-    /// Return the percentage value as CSSFloat.
-    #[inline]
-    pub fn percentage(&self) -> CSSFloat {
-        self.percentage.0
-    }
-
-    /// Return the specified percentage if any.
-    #[inline]
-    pub fn specified_percentage(&self) -> Option<Percentage> {
-        if self.has_percentage {
-            Some(self.percentage)
-        } else {
-            None
-        }
-    }
-
-    /// Returns the length component if this could be represented as a
-    /// non-calc length.
-    pub fn as_length(&self) -> Option<Length> {
-        if !self.has_percentage {
-            Some(self.length_component())
-        } else {
-            None
-        }
-    }
-
-    /// Returns the percentage component if this could be represented as a
-    /// non-calc percentage.
-    pub fn as_percentage(&self) -> Option<Percentage> {
-        if !self.has_percentage || self.length.px() != 0. {
-            return None;
-        }
-
-        Some(Percentage(self.clamping_mode.clamp(self.percentage.0)))
-    }
-
-    /// Resolves the percentage.
-    #[inline]
-    pub fn percentage_relative_to(&self, basis: Length) -> Length {
-        let length = self.unclamped_length().0 + basis.0 * self.percentage.0;
-        Length::new(self.clamping_mode.clamp(length))
-    }
-
-    /// Convert the computed value into used value.
-    #[inline]
-    pub fn maybe_to_used_value(&self, container_len: Option<Length>) -> Option<Au> {
-        self.maybe_percentage_relative_to(container_len)
-            .map(Au::from)
-    }
-
-    /// If there are special rules for computing percentages in a value (e.g.
-    /// the height property), they apply whenever a calc() expression contains
-    /// percentages.
-    pub fn maybe_percentage_relative_to(&self, container_len: Option<Length>) -> Option<Length> {
-        if self.has_percentage {
-            return Some(self.percentage_relative_to(container_len?));
-        }
-        Some(self.length())
+            self.percentage()
+                .compute_squared_distance(&other.percentage())?)
     }
 }
 
@@ -251,7 +152,7 @@ impl specified::CalcLengthPercentage {
         context: &Context,
         zoom_fn: F,
         base_size: FontBaseSize,
-    ) -> LengthPercentage
+    ) -> CalcLengthPercentage
     where
         F: Fn(Length) -> Length,
     {
@@ -285,7 +186,7 @@ impl specified::CalcLengthPercentage {
             }
         }
 
-        LengthPercentage::with_clamping_mode(
+        CalcLengthPercentage::with_clamping_mode(
             Length::new(length.min(f32::MAX).max(f32::MIN)),
             self.percentage,
             self.clamping_mode,
@@ -297,7 +198,7 @@ impl specified::CalcLengthPercentage {
         &self,
         context: &Context,
         base_size: FontBaseSize,
-    ) -> LengthPercentage {
+    ) -> CalcLengthPercentage {
         self.to_computed_value_with_zoom(
             context,
             |abs| context.maybe_zoom_text(abs.into()),
@@ -329,18 +230,14 @@ impl specified::CalcLengthPercentage {
             },
         }
     }
-}
 
-impl ToComputedValue for specified::CalcLengthPercentage {
-    type ComputedValue = LengthPercentage;
-
-    fn to_computed_value(&self, context: &Context) -> LengthPercentage {
+    fn to_computed_value(&self, context: &Context) -> CalcLengthPercentage {
         // normal properties don't zoom, and compute em units against the current style's font-size
         self.to_computed_value_with_zoom(context, |abs| abs, FontBaseSize::CurrentStyle)
     }
 
     #[inline]
-    fn from_computed_value(computed: &LengthPercentage) -> Self {
+    fn from_computed_value(computed: &CalcLengthPercentage) -> Self {
         specified::CalcLengthPercentage {
             clamping_mode: computed.clamping_mode,
             absolute: Some(AbsoluteLength::from_computed_value(&computed.length)),
@@ -353,50 +250,262 @@ impl ToComputedValue for specified::CalcLengthPercentage {
 impl LengthPercentage {
     /// 1px length value for SVG defaults
     #[inline]
-    pub fn one() -> LengthPercentage {
-        LengthPercentage::new(Length::new(1.), None)
+    pub fn one() -> Self {
+        Self::Length(Length::new(1.))
+    }
+
+    /// Constructs a length value.
+    #[inline]
+    pub fn new_length(l: Length) -> Self {
+        Self::Length(l)
+    }
+
+    /// Constructs a percentage value.
+    #[inline]
+    pub fn new_percent(p: Percentage) -> Self {
+        Self::Percentage(p)
+    }
+
+    /// Constructs a `calc()` value.
+    #[inline]
+    pub fn new_calc(l: Length, percentage: Percentage) -> Self {
+        CalcLengthPercentage::new(l, Some(percentage)).to_length_percentge()
     }
 
     /// Returns true if the computed value is absolute 0 or 0%.
     #[inline]
     pub fn is_definitely_zero(&self) -> bool {
-        self.unclamped_length().px() == 0.0 && self.percentage.0 == 0.0
+        match *self {
+            Self::Length(l) => l.px() == 0.0,
+            Self::Percentage(p) => p.0 == 0.0,
+            Self::Calc(ref c) => c.is_definitely_zero(),
+        }
     }
 
-    // CSSFloat doesn't implement Hash, so does CSSPixelLength. Therefore, we
-    // still use Au as the hash key.
-    #[allow(missing_docs)]
-    pub fn to_hash_key(&self) -> (Au, NotNan<f32>) {
-        (
-            Au::from(self.unclamped_length()),
-            NotNan::new(self.percentage.0).unwrap(),
-        )
+    /// Returns the `<length>` component of this `calc()`, unclamped.
+    #[inline]
+    pub fn unclamped_length(&self) -> Length {
+        match *self {
+            Self::Length(l) => l,
+            Self::Percentage(..) => Zero::zero(),
+            Self::Calc(ref c) => c.unclamped_length(),
+        }
+    }
+
+    /// Returns this `calc()` as a `<length>`.
+    ///
+    /// Panics in debug mode if a percentage is present in the expression.
+    #[inline]
+    fn length(&self) -> Length {
+        debug_assert!(!self.has_percentage());
+        self.length_component()
+    }
+
+    /// Returns the `<length>` component of this `calc()`, clamped.
+    #[inline]
+    pub fn length_component(&self) -> Length {
+        match *self {
+            Self::Length(l) => l,
+            Self::Percentage(..) => Zero::zero(),
+            Self::Calc(ref c) => c.length_component(),
+        }
+    }
+
+    /// Returns the `<percentage>` component of this `calc()`, unclamped, as a
+    /// float.
+    ///
+    /// FIXME: This are very different semantics from length(), we should
+    /// probably rename this.
+    #[inline]
+    pub fn percentage(&self) -> CSSFloat {
+        match *self {
+            Self::Length(..) => 0.,
+            Self::Percentage(p) => p.0,
+            Self::Calc(ref c) => c.percentage.0,
+        }
+    }
+
+    /// Returns the `<length>` component of this `calc()`, clamped.
+    #[inline]
+    pub fn as_percentage(&self) -> Option<Percentage> {
+        match *self {
+            Self::Length(..) => None,
+            Self::Percentage(p) => Some(p),
+            Self::Calc(ref c) => c.as_percentage(),
+        }
+    }
+
+    /// Resolves the percentage.
+    #[inline]
+    pub fn resolve(&self, basis: Length) -> Length {
+        match *self {
+            Self::Length(l) => l,
+            Self::Percentage(p) => Length::new(basis.0 * p.0),
+            Self::Calc(ref c) => c.resolve(basis),
+        }
+    }
+
+    /// Resolves the percentage. Just an alias of resolve().
+    #[inline]
+    pub fn percentage_relative_to(&self, basis: Length) -> Length {
+        self.resolve(basis)
+    }
+
+    /// Return whether there's any percentage in this value.
+    #[inline]
+    pub fn has_percentage(&self) -> bool {
+        match *self {
+            Self::Length(..) => false,
+            Self::Percentage(..) => true,
+            Self::Calc(ref c) => c.has_percentage,
+        }
+    }
+
+    /// Return the specified percentage if any.
+    #[inline]
+    pub fn specified_percentage(&self) -> Option<Percentage> {
+        match *self {
+            Self::Length(..) => None,
+            Self::Percentage(p) => Some(p),
+            Self::Calc(ref c) => c.specified_percentage(),
+        }
     }
 
     /// Returns the used value.
+    #[inline]
     pub fn to_used_value(&self, containing_length: Au) -> Au {
         Au::from(self.to_pixel_length(containing_length))
     }
 
     /// Returns the used value as CSSPixelLength.
+    #[inline]
     pub fn to_pixel_length(&self, containing_length: Au) -> Length {
-        self.percentage_relative_to(containing_length.into())
+        self.resolve(containing_length.into())
+    }
+
+    /// Convert the computed value into used value.
+    #[inline]
+    fn maybe_to_used_value(&self, container_len: Option<Length>) -> Option<Au> {
+        self.maybe_percentage_relative_to(container_len).map(Au::from)
+    }
+
+    /// If there are special rules for computing percentages in a value (e.g.
+    /// the height property), they apply whenever a calc() expression contains
+    /// percentages.
+    pub fn maybe_percentage_relative_to(&self, container_len: Option<Length>) -> Option<Length> {
+        if self.has_percentage() {
+            return Some(self.resolve(container_len?));
+        }
+        Some(self.length())
     }
 
     /// Returns the clamped non-negative values.
     #[inline]
     pub fn clamp_to_non_negative(self) -> Self {
-        if let Some(p) = self.specified_percentage() {
+        match self {
+            Self::Length(l) => Self::Length(l.clamp_to_non_negative()),
+            Self::Percentage(p) => Self::Percentage(p.clamp_to_non_negative()),
+            Self::Calc(c) => c.clamp_to_non_negative().to_length_percentge(),
+        }
+    }
+}
+
+impl CalcLengthPercentage {
+    /// Returns a new `LengthPercentage`.
+    #[inline]
+    pub fn new(length: Length, percentage: Option<Percentage>) -> Self {
+        Self::with_clamping_mode(length, percentage, AllowedNumericType::All)
+    }
+
+    /// Converts this to a `LengthPercentage`, simplifying if possible.
+    #[inline]
+    pub fn to_length_percentge(self) -> LengthPercentage {
+        if !self.has_percentage {
+            return LengthPercentage::Length(self.length_component())
+        }
+        if self.length.is_zero() {
+            return LengthPercentage::Percentage(Percentage(self.clamping_mode.clamp(self.percentage.0)));
+        }
+        LengthPercentage::Calc(Box::new(self))
+    }
+
+    fn specified_percentage(&self) -> Option<Percentage> {
+        if self.has_percentage {
+            Some(self.percentage)
+        } else {
+            None
+        }
+    }
+
+    /// Returns a new `LengthPercentage` with a specific clamping mode.
+    #[inline]
+    fn with_clamping_mode(
+        length: Length,
+        percentage: Option<Percentage>,
+        clamping_mode: AllowedNumericType,
+    ) -> Self {
+        Self {
+            clamping_mode,
+            length,
+            percentage: percentage.unwrap_or_default(),
+            has_percentage: percentage.is_some(),
+        }
+    }
+
+    /// Returns the length component of this `calc()`
+    #[inline]
+    fn length_component(&self) -> CSSPixelLength {
+        Length::new(self.clamping_mode.clamp(self.length.px()))
+    }
+
+    /// Returns the percentage component if this could be represented as a
+    /// non-calc percentage.
+    fn as_percentage(&self) -> Option<Percentage> {
+        if !self.has_percentage || self.length.px() != 0. {
+            return None;
+        }
+
+        Some(Percentage(self.clamping_mode.clamp(self.percentage.0)))
+    }
+
+    /// Resolves the percentage.
+    #[inline]
+    pub fn resolve(&self, basis: Length) -> Length {
+        let length = self.length.0 + basis.0 * self.percentage.0;
+        Length::new(self.clamping_mode.clamp(length))
+    }
+
+    /// Resolves the percentage.
+    #[inline]
+    pub fn percentage_relative_to(&self, basis: Length) -> Length {
+        self.resolve(basis)
+    }
+
+    /// Returns the length, without clamping.
+    #[inline]
+    pub fn unclamped_length(&self) -> Length {
+        self.length
+    }
+
+    /// Returns true if the computed value is absolute 0 or 0%.
+    #[inline]
+    fn is_definitely_zero(&self) -> bool {
+        self.length.px() == 0.0 && self.percentage.0 == 0.0
+    }
+
+    /// Returns the clamped non-negative values.
+    #[inline]
+    fn clamp_to_non_negative(self) -> Self {
+        if self.has_percentage {
             // If we can eagerly clamp the percentage then just do that.
             if self.length.is_zero() {
                 return Self::with_clamping_mode(
                     Length::zero(),
-                    Some(p.clamp_to_non_negative()),
+                    Some(self.percentage.clamp_to_non_negative()),
                     AllowedNumericType::NonNegative,
                 );
             }
-
-            return Self::with_clamping_mode(self.length, Some(p), AllowedNumericType::NonNegative);
+            return Self::with_clamping_mode(self.length, Some(self.percentage), AllowedNumericType::NonNegative);
         }
 
         Self::with_clamping_mode(
@@ -413,31 +522,41 @@ impl ToComputedValue for specified::LengthPercentage {
     fn to_computed_value(&self, context: &Context) -> LengthPercentage {
         match *self {
             specified::LengthPercentage::Length(ref value) => {
-                LengthPercentage::new(value.to_computed_value(context), None)
+                LengthPercentage::Length(value.to_computed_value(context))
+            },
+            specified::LengthPercentage::Percentage(value) => {
+                LengthPercentage::Percentage(value)
+            },
+            specified::LengthPercentage::Calc(ref calc) => {
+                (**calc).to_computed_value(context).to_length_percentge()
             },
-            specified::LengthPercentage::Percentage(value) => LengthPercentage::new_percent(value),
-            specified::LengthPercentage::Calc(ref calc) => (**calc).to_computed_value(context),
         }
     }
 
     fn from_computed_value(computed: &LengthPercentage) -> Self {
-        if let Some(p) = computed.as_percentage() {
-            return specified::LengthPercentage::Percentage(p);
+        match *computed {
+            LengthPercentage::Length(ref l) => {
+                specified::LengthPercentage::Length(ToComputedValue::from_computed_value(l))
+            }
+            LengthPercentage::Percentage(p) => {
+                specified::LengthPercentage::Percentage(p)
+            }
+            LengthPercentage::Calc(ref c) => {
+                if let Some(p) = c.as_percentage() {
+                    return specified::LengthPercentage::Percentage(p)
+                }
+                if !c.has_percentage {
+                    return specified::LengthPercentage::Length(ToComputedValue::from_computed_value(&c.length_component()))
+                }
+                specified::LengthPercentage::Calc(Box::new(specified::CalcLengthPercentage::from_computed_value(c)))
+            }
         }
-
-        if !computed.has_percentage {
-            return specified::LengthPercentage::Length(ToComputedValue::from_computed_value(
-                &computed.length(),
-            ));
-        }
-
-        specified::LengthPercentage::Calc(Box::new(ToComputedValue::from_computed_value(computed)))
     }
 }
 
 impl Zero for LengthPercentage {
     fn zero() -> Self {
-        LengthPercentage::new(Length::zero(), None)
+        LengthPercentage::Length(Length::zero())
     }
 
     #[inline]
@@ -541,7 +660,7 @@ impl ToAnimatedValue for NonNegativeLengthPercentage {
 impl From<NonNegativeLength> for NonNegativeLengthPercentage {
     #[inline]
     fn from(length: NonNegativeLength) -> Self {
-        NonNegative(LengthPercentage::new(length.0, None))
+        NonNegative(LengthPercentage::new_length(length.0))
     }
 }
 
@@ -557,7 +676,7 @@ impl From<LengthPercentage> for NonNegativeLengthPercentage {
 impl From<Au> for LengthPercentage {
     #[inline]
     fn from(length: Au) -> Self {
-        LengthPercentage::new(length.into(), None)
+        LengthPercentage::new_length(length.into())
     }
 }
 
@@ -572,7 +691,7 @@ impl NonNegativeLengthPercentage {
     #[inline]
     pub fn to_used_value(&self, containing_length: Au) -> Au {
         let resolved = self.0.to_used_value(containing_length);
-        ::std::cmp::max(resolved, Au(0))
+        std::cmp::max(resolved, Au(0))
     }
 
     /// Convert the computed value into used value.
@@ -581,7 +700,7 @@ impl NonNegativeLengthPercentage {
         let resolved = self
             .0
             .maybe_to_used_value(containing_length.map(|v| v.into()))?;
-        Some(::std::cmp::max(resolved, Au(0)))
+        Some(std::cmp::max(resolved, Au(0)))
     }
 }
 
diff --git a/components/style/values/specified/gecko.rs b/components/style/values/specified/gecko.rs
index 4c85d1df668..3e3085c8849 100644
--- a/components/style/values/specified/gecko.rs
+++ b/components/style/values/specified/gecko.rs
@@ -23,7 +23,7 @@ fn parse_pixel_or_percent<'i, 't>(
             value, ref unit, ..
         } => {
             match_ignore_ascii_case! { unit,
-                "px" => Ok(LengthPercentage::new(Length::new(value), None)),
+                "px" => Ok(LengthPercentage::new_length(Length::new(value))),
                 _ => Err(()),
             }
         },
diff --git a/components/style/values/specified/position.rs b/components/style/values/specified/position.rs
index 8d35671991d..420133810ed 100644
--- a/components/style/values/specified/position.rs
+++ b/components/style/values/specified/position.rs
@@ -297,7 +297,7 @@ impl<S: Side> ToComputedValue for PositionComponent<S> {
                 let p = Percentage(1. - length.percentage());
                 let l = -length.unclamped_length();
                 // We represent `<end-side> <length>` as `calc(100% - <length>)`.
-                ComputedLengthPercentage::with_clamping_mode(l, Some(p), length.clamping_mode)
+                ComputedLengthPercentage::new_calc(l, p)
             },
             PositionComponent::Side(_, Some(ref length)) |
             PositionComponent::Length(ref length) => length.to_computed_value(context),

From 4d5bd94a2b5deb2a1817c6351bc42fa5b20bd910 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 13 Jan 2020 13:23:44 +0000
Subject: [PATCH 13/66] style: Move LengthPercentage to its own file.

I'm (sadly) about to make it a bit more complicated to pack it better. So we
may as well do this so it is easier to reason about navigate.

I also reordered things a bit, and removed some From<> implementations and
such.

Differential Revision: https://phabricator.services.mozilla.com/D58701
---
 components/style/values/animated/length.rs    |   4 +-
 components/style/values/computed/length.rs    | 568 +-----------------
 .../values/computed/length_percentage.rs      | 559 +++++++++++++++++
 components/style/values/computed/mod.rs       |   1 +
 components/style/values/specified/position.rs |   2 +-
 5 files changed, 566 insertions(+), 568 deletions(-)
 create mode 100644 components/style/values/computed/length_percentage.rs

diff --git a/components/style/values/animated/length.rs b/components/style/values/animated/length.rs
index ece26a9c491..837b3ee86c3 100644
--- a/components/style/values/animated/length.rs
+++ b/components/style/values/animated/length.rs
@@ -5,7 +5,7 @@
 //! Animation implementation for various length-related types.
 
 use super::{Animate, Procedure};
-use crate::values::computed::length::{LengthPercentage, CalcLengthPercentage};
+use crate::values::computed::length::LengthPercentage;
 use crate::values::computed::Percentage;
 
 /// <https://drafts.csswg.org/css-transitions/#animtype-lpcalc>
@@ -29,6 +29,6 @@ impl Animate for LengthPercentage {
 
         // Gets clamped as needed after the animation, so no need to specify any
         // particular AllowedNumericType.
-        Ok(CalcLengthPercentage::new(length, percentage).to_length_percentge())
+        Ok(LengthPercentage::new_calc(length, percentage))
     }
 }
diff --git a/components/style/values/computed/length.rs b/components/style/values/computed/length.rs
index 285d9d2e6d4..d90e4e543b7 100644
--- a/components/style/values/computed/length.rs
+++ b/components/style/values/computed/length.rs
@@ -4,28 +4,26 @@
 
 //! `<length>` computed values, and related ones.
 
-use super::{Context, Number, Percentage, ToComputedValue};
+use super::{Context, Number, ToComputedValue};
 use crate::values::animated::ToAnimatedValue;
 use crate::values::computed::NonNegativeNumber;
-use crate::values::distance::{ComputeSquaredDistance, SquaredDistance};
 use crate::values::generics::length as generics;
 use crate::values::generics::length::{
     GenericLengthOrNumber, GenericLengthPercentageOrNormal, GenericMaxSize, GenericSize,
 };
 use crate::values::generics::NonNegative;
-use crate::values::specified::length::ViewportPercentageLength;
-use crate::values::specified::length::{AbsoluteLength, FontBaseSize, FontRelativeLength};
+use crate::values::specified::length::{AbsoluteLength, FontBaseSize};
 use crate::values::{specified, CSSFloat};
 use crate::Zero;
 use app_units::Au;
 use std::fmt::{self, Write};
 use std::ops::{Add, AddAssign, Div, Mul, Neg, Sub};
-use style_traits::values::specified::AllowedNumericType;
 use style_traits::{CSSPixel, CssWriter, ToCss};
 
 pub use super::image::Image;
 pub use crate::values::specified::url::UrlOrNone;
 pub use crate::values::specified::{Angle, BorderStyle, Time};
+pub use super::length_percentage::{LengthPercentage, NonNegativeLengthPercentage};
 
 impl ToComputedValue for specified::NoCalcLength {
     type ComputedValue = Length;
@@ -69,502 +67,6 @@ impl ToComputedValue for specified::Length {
     }
 }
 
-/// A `<length-percentage>` value. This can be either a `<length>`, a
-/// `<percentage>`, or a combination of both via `calc()`.
-///
-/// cbindgen:private-default-tagged-enum-constructor=false
-/// cbindgen:derive-mut-casts=true
-///
-/// https://drafts.csswg.org/css-values-4/#typedef-length-percentage
-#[allow(missing_docs)]
-#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, ToAnimatedZero, ToResolvedValue)]
-#[repr(u8)]
-pub enum LengthPercentage {
-    Length(Length),
-    Percentage(Percentage),
-    Calc(Box<CalcLengthPercentage>),
-}
-
-/// The representation of a calc() function.
-#[derive(
-    Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue,
-)]
-#[repr(C)]
-pub struct CalcLengthPercentage {
-    length: Length,
-
-    percentage: Percentage,
-
-    #[animation(constant)]
-    clamping_mode: AllowedNumericType,
-
-    /// Whether we specified a percentage or not.
-    #[animation(constant)]
-    pub has_percentage: bool,
-}
-
-// NOTE(emilio): We don't compare `clamping_mode` since we want to preserve the
-// invariant that `from_computed_value(length).to_computed_value(..) == length`.
-//
-// Right now for e.g. a non-negative length, we set clamping_mode to `All`
-// unconditionally for non-calc values, and to `NonNegative` for calc.
-//
-// If we determine that it's sound, from_computed_value() can generate an
-// absolute length, which then would get `All` as the clamping mode.
-//
-// We may want to just eagerly-detect whether we can clamp in
-// `LengthPercentage::new` and switch to `AllowedNumericType::NonNegative` then,
-// maybe.
-impl PartialEq for CalcLengthPercentage {
-    fn eq(&self, other: &Self) -> bool {
-        self.length == other.length &&
-            self.percentage == other.percentage &&
-            self.has_percentage == other.has_percentage
-    }
-}
-
-impl ComputeSquaredDistance for LengthPercentage {
-    #[inline]
-    fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> {
-        // FIXME(nox): This looks incorrect to me, to add a distance between lengths
-        // with a distance between percentages.
-        Ok(self
-            .unclamped_length()
-            .compute_squared_distance(&other.unclamped_length())? +
-            self.percentage()
-                .compute_squared_distance(&other.percentage())?)
-    }
-}
-
-impl ToCss for LengthPercentage {
-    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
-    where
-        W: Write,
-    {
-        specified::LengthPercentage::from_computed_value(self).to_css(dest)
-    }
-}
-
-impl specified::CalcLengthPercentage {
-    /// Compute the value, zooming any absolute units by the zoom function.
-    fn to_computed_value_with_zoom<F>(
-        &self,
-        context: &Context,
-        zoom_fn: F,
-        base_size: FontBaseSize,
-    ) -> CalcLengthPercentage
-    where
-        F: Fn(Length) -> Length,
-    {
-        use std::f32;
-        let mut length = 0.;
-
-        if let Some(absolute) = self.absolute {
-            length += zoom_fn(absolute.to_computed_value(context)).px();
-        }
-
-        for val in &[
-            self.vw.map(ViewportPercentageLength::Vw),
-            self.vh.map(ViewportPercentageLength::Vh),
-            self.vmin.map(ViewportPercentageLength::Vmin),
-            self.vmax.map(ViewportPercentageLength::Vmax),
-        ] {
-            if let Some(val) = *val {
-                let viewport_size = context.viewport_size_for_viewport_unit_resolution();
-                length += val.to_computed_value(viewport_size).px();
-            }
-        }
-
-        for val in &[
-            self.ch.map(FontRelativeLength::Ch),
-            self.em.map(FontRelativeLength::Em),
-            self.ex.map(FontRelativeLength::Ex),
-            self.rem.map(FontRelativeLength::Rem),
-        ] {
-            if let Some(val) = *val {
-                length += val.to_computed_value(context, base_size).px();
-            }
-        }
-
-        CalcLengthPercentage::with_clamping_mode(
-            Length::new(length.min(f32::MAX).max(f32::MIN)),
-            self.percentage,
-            self.clamping_mode,
-        )
-    }
-
-    /// Compute font-size or line-height taking into account text-zoom if necessary.
-    pub fn to_computed_value_zoomed(
-        &self,
-        context: &Context,
-        base_size: FontBaseSize,
-    ) -> CalcLengthPercentage {
-        self.to_computed_value_with_zoom(
-            context,
-            |abs| context.maybe_zoom_text(abs.into()),
-            base_size,
-        )
-    }
-
-    /// Compute the value into pixel length as CSSFloat without context,
-    /// so it returns Err(()) if there is any non-absolute unit.
-    pub fn to_computed_pixel_length_without_context(&self) -> Result<CSSFloat, ()> {
-        if self.vw.is_some() ||
-            self.vh.is_some() ||
-            self.vmin.is_some() ||
-            self.vmax.is_some() ||
-            self.em.is_some() ||
-            self.ex.is_some() ||
-            self.ch.is_some() ||
-            self.rem.is_some() ||
-            self.percentage.is_some()
-        {
-            return Err(());
-        }
-
-        match self.absolute {
-            Some(abs) => Ok(abs.to_px()),
-            None => {
-                debug_assert!(false, "Someone forgot to handle an unit here: {:?}", self);
-                Err(())
-            },
-        }
-    }
-
-    fn to_computed_value(&self, context: &Context) -> CalcLengthPercentage {
-        // normal properties don't zoom, and compute em units against the current style's font-size
-        self.to_computed_value_with_zoom(context, |abs| abs, FontBaseSize::CurrentStyle)
-    }
-
-    #[inline]
-    fn from_computed_value(computed: &CalcLengthPercentage) -> Self {
-        specified::CalcLengthPercentage {
-            clamping_mode: computed.clamping_mode,
-            absolute: Some(AbsoluteLength::from_computed_value(&computed.length)),
-            percentage: computed.specified_percentage(),
-            ..Default::default()
-        }
-    }
-}
-
-impl LengthPercentage {
-    /// 1px length value for SVG defaults
-    #[inline]
-    pub fn one() -> Self {
-        Self::Length(Length::new(1.))
-    }
-
-    /// Constructs a length value.
-    #[inline]
-    pub fn new_length(l: Length) -> Self {
-        Self::Length(l)
-    }
-
-    /// Constructs a percentage value.
-    #[inline]
-    pub fn new_percent(p: Percentage) -> Self {
-        Self::Percentage(p)
-    }
-
-    /// Constructs a `calc()` value.
-    #[inline]
-    pub fn new_calc(l: Length, percentage: Percentage) -> Self {
-        CalcLengthPercentage::new(l, Some(percentage)).to_length_percentge()
-    }
-
-    /// Returns true if the computed value is absolute 0 or 0%.
-    #[inline]
-    pub fn is_definitely_zero(&self) -> bool {
-        match *self {
-            Self::Length(l) => l.px() == 0.0,
-            Self::Percentage(p) => p.0 == 0.0,
-            Self::Calc(ref c) => c.is_definitely_zero(),
-        }
-    }
-
-    /// Returns the `<length>` component of this `calc()`, unclamped.
-    #[inline]
-    pub fn unclamped_length(&self) -> Length {
-        match *self {
-            Self::Length(l) => l,
-            Self::Percentage(..) => Zero::zero(),
-            Self::Calc(ref c) => c.unclamped_length(),
-        }
-    }
-
-    /// Returns this `calc()` as a `<length>`.
-    ///
-    /// Panics in debug mode if a percentage is present in the expression.
-    #[inline]
-    fn length(&self) -> Length {
-        debug_assert!(!self.has_percentage());
-        self.length_component()
-    }
-
-    /// Returns the `<length>` component of this `calc()`, clamped.
-    #[inline]
-    pub fn length_component(&self) -> Length {
-        match *self {
-            Self::Length(l) => l,
-            Self::Percentage(..) => Zero::zero(),
-            Self::Calc(ref c) => c.length_component(),
-        }
-    }
-
-    /// Returns the `<percentage>` component of this `calc()`, unclamped, as a
-    /// float.
-    ///
-    /// FIXME: This are very different semantics from length(), we should
-    /// probably rename this.
-    #[inline]
-    pub fn percentage(&self) -> CSSFloat {
-        match *self {
-            Self::Length(..) => 0.,
-            Self::Percentage(p) => p.0,
-            Self::Calc(ref c) => c.percentage.0,
-        }
-    }
-
-    /// Returns the `<length>` component of this `calc()`, clamped.
-    #[inline]
-    pub fn as_percentage(&self) -> Option<Percentage> {
-        match *self {
-            Self::Length(..) => None,
-            Self::Percentage(p) => Some(p),
-            Self::Calc(ref c) => c.as_percentage(),
-        }
-    }
-
-    /// Resolves the percentage.
-    #[inline]
-    pub fn resolve(&self, basis: Length) -> Length {
-        match *self {
-            Self::Length(l) => l,
-            Self::Percentage(p) => Length::new(basis.0 * p.0),
-            Self::Calc(ref c) => c.resolve(basis),
-        }
-    }
-
-    /// Resolves the percentage. Just an alias of resolve().
-    #[inline]
-    pub fn percentage_relative_to(&self, basis: Length) -> Length {
-        self.resolve(basis)
-    }
-
-    /// Return whether there's any percentage in this value.
-    #[inline]
-    pub fn has_percentage(&self) -> bool {
-        match *self {
-            Self::Length(..) => false,
-            Self::Percentage(..) => true,
-            Self::Calc(ref c) => c.has_percentage,
-        }
-    }
-
-    /// Return the specified percentage if any.
-    #[inline]
-    pub fn specified_percentage(&self) -> Option<Percentage> {
-        match *self {
-            Self::Length(..) => None,
-            Self::Percentage(p) => Some(p),
-            Self::Calc(ref c) => c.specified_percentage(),
-        }
-    }
-
-    /// Returns the used value.
-    #[inline]
-    pub fn to_used_value(&self, containing_length: Au) -> Au {
-        Au::from(self.to_pixel_length(containing_length))
-    }
-
-    /// Returns the used value as CSSPixelLength.
-    #[inline]
-    pub fn to_pixel_length(&self, containing_length: Au) -> Length {
-        self.resolve(containing_length.into())
-    }
-
-    /// Convert the computed value into used value.
-    #[inline]
-    fn maybe_to_used_value(&self, container_len: Option<Length>) -> Option<Au> {
-        self.maybe_percentage_relative_to(container_len).map(Au::from)
-    }
-
-    /// If there are special rules for computing percentages in a value (e.g.
-    /// the height property), they apply whenever a calc() expression contains
-    /// percentages.
-    pub fn maybe_percentage_relative_to(&self, container_len: Option<Length>) -> Option<Length> {
-        if self.has_percentage() {
-            return Some(self.resolve(container_len?));
-        }
-        Some(self.length())
-    }
-
-    /// Returns the clamped non-negative values.
-    #[inline]
-    pub fn clamp_to_non_negative(self) -> Self {
-        match self {
-            Self::Length(l) => Self::Length(l.clamp_to_non_negative()),
-            Self::Percentage(p) => Self::Percentage(p.clamp_to_non_negative()),
-            Self::Calc(c) => c.clamp_to_non_negative().to_length_percentge(),
-        }
-    }
-}
-
-impl CalcLengthPercentage {
-    /// Returns a new `LengthPercentage`.
-    #[inline]
-    pub fn new(length: Length, percentage: Option<Percentage>) -> Self {
-        Self::with_clamping_mode(length, percentage, AllowedNumericType::All)
-    }
-
-    /// Converts this to a `LengthPercentage`, simplifying if possible.
-    #[inline]
-    pub fn to_length_percentge(self) -> LengthPercentage {
-        if !self.has_percentage {
-            return LengthPercentage::Length(self.length_component())
-        }
-        if self.length.is_zero() {
-            return LengthPercentage::Percentage(Percentage(self.clamping_mode.clamp(self.percentage.0)));
-        }
-        LengthPercentage::Calc(Box::new(self))
-    }
-
-    fn specified_percentage(&self) -> Option<Percentage> {
-        if self.has_percentage {
-            Some(self.percentage)
-        } else {
-            None
-        }
-    }
-
-    /// Returns a new `LengthPercentage` with a specific clamping mode.
-    #[inline]
-    fn with_clamping_mode(
-        length: Length,
-        percentage: Option<Percentage>,
-        clamping_mode: AllowedNumericType,
-    ) -> Self {
-        Self {
-            clamping_mode,
-            length,
-            percentage: percentage.unwrap_or_default(),
-            has_percentage: percentage.is_some(),
-        }
-    }
-
-    /// Returns the length component of this `calc()`
-    #[inline]
-    fn length_component(&self) -> CSSPixelLength {
-        Length::new(self.clamping_mode.clamp(self.length.px()))
-    }
-
-    /// Returns the percentage component if this could be represented as a
-    /// non-calc percentage.
-    fn as_percentage(&self) -> Option<Percentage> {
-        if !self.has_percentage || self.length.px() != 0. {
-            return None;
-        }
-
-        Some(Percentage(self.clamping_mode.clamp(self.percentage.0)))
-    }
-
-    /// Resolves the percentage.
-    #[inline]
-    pub fn resolve(&self, basis: Length) -> Length {
-        let length = self.length.0 + basis.0 * self.percentage.0;
-        Length::new(self.clamping_mode.clamp(length))
-    }
-
-    /// Resolves the percentage.
-    #[inline]
-    pub fn percentage_relative_to(&self, basis: Length) -> Length {
-        self.resolve(basis)
-    }
-
-    /// Returns the length, without clamping.
-    #[inline]
-    pub fn unclamped_length(&self) -> Length {
-        self.length
-    }
-
-    /// Returns true if the computed value is absolute 0 or 0%.
-    #[inline]
-    fn is_definitely_zero(&self) -> bool {
-        self.length.px() == 0.0 && self.percentage.0 == 0.0
-    }
-
-    /// Returns the clamped non-negative values.
-    #[inline]
-    fn clamp_to_non_negative(self) -> Self {
-        if self.has_percentage {
-            // If we can eagerly clamp the percentage then just do that.
-            if self.length.is_zero() {
-                return Self::with_clamping_mode(
-                    Length::zero(),
-                    Some(self.percentage.clamp_to_non_negative()),
-                    AllowedNumericType::NonNegative,
-                );
-            }
-            return Self::with_clamping_mode(self.length, Some(self.percentage), AllowedNumericType::NonNegative);
-        }
-
-        Self::with_clamping_mode(
-            self.length.clamp_to_non_negative(),
-            None,
-            AllowedNumericType::NonNegative,
-        )
-    }
-}
-
-impl ToComputedValue for specified::LengthPercentage {
-    type ComputedValue = LengthPercentage;
-
-    fn to_computed_value(&self, context: &Context) -> LengthPercentage {
-        match *self {
-            specified::LengthPercentage::Length(ref value) => {
-                LengthPercentage::Length(value.to_computed_value(context))
-            },
-            specified::LengthPercentage::Percentage(value) => {
-                LengthPercentage::Percentage(value)
-            },
-            specified::LengthPercentage::Calc(ref calc) => {
-                (**calc).to_computed_value(context).to_length_percentge()
-            },
-        }
-    }
-
-    fn from_computed_value(computed: &LengthPercentage) -> Self {
-        match *computed {
-            LengthPercentage::Length(ref l) => {
-                specified::LengthPercentage::Length(ToComputedValue::from_computed_value(l))
-            }
-            LengthPercentage::Percentage(p) => {
-                specified::LengthPercentage::Percentage(p)
-            }
-            LengthPercentage::Calc(ref c) => {
-                if let Some(p) = c.as_percentage() {
-                    return specified::LengthPercentage::Percentage(p)
-                }
-                if !c.has_percentage {
-                    return specified::LengthPercentage::Length(ToComputedValue::from_computed_value(&c.length_component()))
-                }
-                specified::LengthPercentage::Calc(Box::new(specified::CalcLengthPercentage::from_computed_value(c)))
-            }
-        }
-    }
-}
-
-impl Zero for LengthPercentage {
-    fn zero() -> Self {
-        LengthPercentage::Length(Length::zero())
-    }
-
-    #[inline]
-    fn is_zero(&self) -> bool {
-        self.is_definitely_zero()
-    }
-}
-
 /// Some boilerplate to share between negative and non-negative
 /// length-percentage or auto.
 macro_rules! computed_length_percentage_or_auto {
@@ -640,70 +142,6 @@ impl NonNegativeLengthPercentageOrAuto {
     computed_length_percentage_or_auto!(NonNegativeLengthPercentage);
 }
 
-/// A wrapper of LengthPercentage, whose value must be >= 0.
-pub type NonNegativeLengthPercentage = NonNegative<LengthPercentage>;
-
-impl ToAnimatedValue for NonNegativeLengthPercentage {
-    type AnimatedValue = LengthPercentage;
-
-    #[inline]
-    fn to_animated_value(self) -> Self::AnimatedValue {
-        self.0
-    }
-
-    #[inline]
-    fn from_animated_value(animated: Self::AnimatedValue) -> Self {
-        NonNegative(animated.clamp_to_non_negative())
-    }
-}
-
-impl From<NonNegativeLength> for NonNegativeLengthPercentage {
-    #[inline]
-    fn from(length: NonNegativeLength) -> Self {
-        NonNegative(LengthPercentage::new_length(length.0))
-    }
-}
-
-impl From<LengthPercentage> for NonNegativeLengthPercentage {
-    #[inline]
-    fn from(lp: LengthPercentage) -> Self {
-        NonNegative(lp)
-    }
-}
-
-// TODO(emilio): This is a really generic impl which is only needed to implement
-// Animated and co for Spacing<>. Get rid of this, probably?
-impl From<Au> for LengthPercentage {
-    #[inline]
-    fn from(length: Au) -> Self {
-        LengthPercentage::new_length(length.into())
-    }
-}
-
-impl NonNegativeLengthPercentage {
-    /// Returns true if the computed value is absolute 0 or 0%.
-    #[inline]
-    pub fn is_definitely_zero(&self) -> bool {
-        self.0.is_definitely_zero()
-    }
-
-    /// Returns the used value.
-    #[inline]
-    pub fn to_used_value(&self, containing_length: Au) -> Au {
-        let resolved = self.0.to_used_value(containing_length);
-        std::cmp::max(resolved, Au(0))
-    }
-
-    /// Convert the computed value into used value.
-    #[inline]
-    pub fn maybe_to_used_value(&self, containing_length: Option<Au>) -> Option<Au> {
-        let resolved = self
-            .0
-            .maybe_to_used_value(containing_length.map(|v| v.into()))?;
-        Some(std::cmp::max(resolved, Au(0)))
-    }
-}
-
 #[cfg(feature = "servo")]
 impl MaxSize {
     /// Convert the computed value into used value.
diff --git a/components/style/values/computed/length_percentage.rs b/components/style/values/computed/length_percentage.rs
new file mode 100644
index 00000000000..ad108b9487a
--- /dev/null
+++ b/components/style/values/computed/length_percentage.rs
@@ -0,0 +1,559 @@
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+//! `<length-percentage>` computed values, and related ones.
+
+use super::{Context, Length, Percentage, ToComputedValue};
+use crate::values::animated::ToAnimatedValue;
+use crate::values::distance::{ComputeSquaredDistance, SquaredDistance};
+use crate::values::generics::NonNegative;
+use crate::values::specified::length::FontBaseSize;
+use crate::values::{specified, CSSFloat};
+use crate::Zero;
+use app_units::Au;
+use std::fmt::{self, Write};
+use style_traits::values::specified::AllowedNumericType;
+use style_traits::{CssWriter, ToCss};
+
+/// A `<length-percentage>` value. This can be either a `<length>`, a
+/// `<percentage>`, or a combination of both via `calc()`.
+///
+/// cbindgen:private-default-tagged-enum-constructor=false
+/// cbindgen:derive-mut-casts=true
+///
+/// https://drafts.csswg.org/css-values-4/#typedef-length-percentage
+#[allow(missing_docs)]
+#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, ToAnimatedZero, ToResolvedValue)]
+#[repr(u8)]
+pub enum LengthPercentage {
+    Length(Length),
+    Percentage(Percentage),
+    Calc(Box<CalcLengthPercentage>),
+}
+
+impl LengthPercentage {
+    /// 1px length value for SVG defaults
+    #[inline]
+    pub fn one() -> Self {
+        Self::new_length(Length::new(1.))
+    }
+
+    /// Constructs a length value.
+    #[inline]
+    pub fn new_length(l: Length) -> Self {
+        Self::Length(l)
+    }
+
+    /// Constructs a percentage value.
+    #[inline]
+    pub fn new_percent(p: Percentage) -> Self {
+        Self::Percentage(p)
+    }
+
+    /// Constructs a `calc()` value.
+    #[inline]
+    pub fn new_calc(l: Length, percentage: Option<Percentage>) -> Self {
+        CalcLengthPercentage::new(l, percentage).to_length_percentge()
+    }
+
+    /// Returns true if the computed value is absolute 0 or 0%.
+    #[inline]
+    pub fn is_definitely_zero(&self) -> bool {
+        match *self {
+            Self::Length(l) => l.px() == 0.0,
+            Self::Percentage(p) => p.0 == 0.0,
+            Self::Calc(ref c) => c.is_definitely_zero(),
+        }
+    }
+
+    /// Returns the `<length>` component of this `calc()`, unclamped.
+    #[inline]
+    pub fn unclamped_length(&self) -> Length {
+        match *self {
+            Self::Length(l) => l,
+            Self::Percentage(..) => Zero::zero(),
+            Self::Calc(ref c) => c.unclamped_length(),
+        }
+    }
+
+    /// Returns this `calc()` as a `<length>`.
+    ///
+    /// Panics in debug mode if a percentage is present in the expression.
+    #[inline]
+    fn length(&self) -> Length {
+        debug_assert!(!self.has_percentage());
+        self.length_component()
+    }
+
+    /// Returns the `<length>` component of this `calc()`, clamped.
+    #[inline]
+    pub fn length_component(&self) -> Length {
+        match *self {
+            Self::Length(l) => l,
+            Self::Percentage(..) => Zero::zero(),
+            Self::Calc(ref c) => c.length_component(),
+        }
+    }
+
+    /// Returns the `<percentage>` component of this `calc()`, unclamped, as a
+    /// float.
+    ///
+    /// FIXME: This are very different semantics from length(), we should
+    /// probably rename this.
+    #[inline]
+    pub fn percentage(&self) -> CSSFloat {
+        match *self {
+            Self::Length(..) => 0.,
+            Self::Percentage(p) => p.0,
+            Self::Calc(ref c) => c.percentage.0,
+        }
+    }
+
+    /// Returns the `<length>` component of this `calc()`, clamped.
+    #[inline]
+    pub fn as_percentage(&self) -> Option<Percentage> {
+        match *self {
+            Self::Length(..) => None,
+            Self::Percentage(p) => Some(p),
+            Self::Calc(ref c) => c.as_percentage(),
+        }
+    }
+
+    /// Resolves the percentage.
+    #[inline]
+    pub fn resolve(&self, basis: Length) -> Length {
+        match *self {
+            Self::Length(l) => l,
+            Self::Percentage(p) => Length::new(basis.px() * p.0),
+            Self::Calc(ref c) => c.resolve(basis),
+        }
+    }
+
+    /// Resolves the percentage. Just an alias of resolve().
+    #[inline]
+    pub fn percentage_relative_to(&self, basis: Length) -> Length {
+        self.resolve(basis)
+    }
+
+    /// Return whether there's any percentage in this value.
+    #[inline]
+    pub fn has_percentage(&self) -> bool {
+        match *self {
+            Self::Length(..) => false,
+            Self::Percentage(..) => true,
+            Self::Calc(ref c) => c.has_percentage,
+        }
+    }
+
+    /// Return the specified percentage if any.
+    #[inline]
+    pub fn specified_percentage(&self) -> Option<Percentage> {
+        match *self {
+            Self::Length(..) => None,
+            Self::Percentage(p) => Some(p),
+            Self::Calc(ref c) => c.specified_percentage(),
+        }
+    }
+
+    /// Returns the used value.
+    #[inline]
+    pub fn to_used_value(&self, containing_length: Au) -> Au {
+        Au::from(self.to_pixel_length(containing_length))
+    }
+
+    /// Returns the used value as CSSPixelLength.
+    #[inline]
+    pub fn to_pixel_length(&self, containing_length: Au) -> Length {
+        self.resolve(containing_length.into())
+    }
+
+    /// Convert the computed value into used value.
+    #[inline]
+    fn maybe_to_used_value(&self, container_len: Option<Length>) -> Option<Au> {
+        self.maybe_percentage_relative_to(container_len).map(Au::from)
+    }
+
+    /// If there are special rules for computing percentages in a value (e.g.
+    /// the height property), they apply whenever a calc() expression contains
+    /// percentages.
+    pub fn maybe_percentage_relative_to(&self, container_len: Option<Length>) -> Option<Length> {
+        if self.has_percentage() {
+            return Some(self.resolve(container_len?));
+        }
+        Some(self.length())
+    }
+
+    /// Returns the clamped non-negative values.
+    #[inline]
+    pub fn clamp_to_non_negative(self) -> Self {
+        match self {
+            Self::Length(l) => Self::Length(l.clamp_to_non_negative()),
+            Self::Percentage(p) => Self::Percentage(p.clamp_to_non_negative()),
+            Self::Calc(c) => c.clamp_to_non_negative().to_length_percentge(),
+        }
+    }
+}
+
+impl ToComputedValue for specified::LengthPercentage {
+    type ComputedValue = LengthPercentage;
+
+    fn to_computed_value(&self, context: &Context) -> LengthPercentage {
+        match *self {
+            specified::LengthPercentage::Length(ref value) => {
+                LengthPercentage::Length(value.to_computed_value(context))
+            },
+            specified::LengthPercentage::Percentage(value) => {
+                LengthPercentage::Percentage(value)
+            },
+            specified::LengthPercentage::Calc(ref calc) => {
+                (**calc).to_computed_value(context).to_length_percentge()
+            },
+        }
+    }
+
+    fn from_computed_value(computed: &LengthPercentage) -> Self {
+        match *computed {
+            LengthPercentage::Length(ref l) => {
+                specified::LengthPercentage::Length(ToComputedValue::from_computed_value(l))
+            }
+            LengthPercentage::Percentage(p) => {
+                specified::LengthPercentage::Percentage(p)
+            }
+            LengthPercentage::Calc(ref c) => {
+                if let Some(p) = c.as_percentage() {
+                    return specified::LengthPercentage::Percentage(p)
+                }
+                if !c.has_percentage {
+                    return specified::LengthPercentage::Length(ToComputedValue::from_computed_value(&c.length_component()))
+                }
+                specified::LengthPercentage::Calc(Box::new(specified::CalcLengthPercentage::from_computed_value(c)))
+            }
+        }
+    }
+}
+
+impl ComputeSquaredDistance for LengthPercentage {
+    #[inline]
+    fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> {
+        // FIXME(nox): This looks incorrect to me, to add a distance between lengths
+        // with a distance between percentages.
+        Ok(self
+            .unclamped_length()
+            .compute_squared_distance(&other.unclamped_length())? +
+            self.percentage()
+                .compute_squared_distance(&other.percentage())?)
+    }
+}
+
+impl ToCss for LengthPercentage {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        specified::LengthPercentage::from_computed_value(self).to_css(dest)
+    }
+}
+
+impl Zero for LengthPercentage {
+    fn zero() -> Self {
+        LengthPercentage::Length(Length::zero())
+    }
+
+    #[inline]
+    fn is_zero(&self) -> bool {
+        self.is_definitely_zero()
+    }
+}
+
+/// The representation of a calc() function.
+#[derive(
+    Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue,
+)]
+#[repr(C)]
+pub struct CalcLengthPercentage {
+    length: Length,
+
+    percentage: Percentage,
+
+    #[animation(constant)]
+    clamping_mode: AllowedNumericType,
+
+    /// Whether we specified a percentage or not.
+    #[animation(constant)]
+    pub has_percentage: bool,
+}
+
+impl CalcLengthPercentage {
+    /// Returns a new `LengthPercentage`.
+    #[inline]
+    pub fn new(length: Length, percentage: Option<Percentage>) -> Self {
+        Self::with_clamping_mode(length, percentage, AllowedNumericType::All)
+    }
+
+    /// Converts this to a `LengthPercentage`, simplifying if possible.
+    #[inline]
+    pub fn to_length_percentge(self) -> LengthPercentage {
+        if !self.has_percentage {
+            return LengthPercentage::Length(self.length_component())
+        }
+        if self.length.is_zero() {
+            return LengthPercentage::Percentage(Percentage(self.clamping_mode.clamp(self.percentage.0)));
+        }
+        LengthPercentage::Calc(Box::new(self))
+    }
+
+    fn specified_percentage(&self) -> Option<Percentage> {
+        if self.has_percentage {
+            Some(self.percentage)
+        } else {
+            None
+        }
+    }
+
+    /// Returns a new `LengthPercentage` with a specific clamping mode.
+    #[inline]
+    fn with_clamping_mode(
+        length: Length,
+        percentage: Option<Percentage>,
+        clamping_mode: AllowedNumericType,
+    ) -> Self {
+        Self {
+            clamping_mode,
+            length,
+            percentage: percentage.unwrap_or_default(),
+            has_percentage: percentage.is_some(),
+        }
+    }
+
+    /// Returns the length component of this `calc()`, clamped.
+    #[inline]
+    pub fn length_component(&self) -> Length {
+        Length::new(self.clamping_mode.clamp(self.length.px()))
+    }
+
+    /// Returns the percentage component if this could be represented as a
+    /// non-calc percentage.
+    fn as_percentage(&self) -> Option<Percentage> {
+        if !self.has_percentage || self.length.px() != 0. {
+            return None;
+        }
+
+        Some(Percentage(self.clamping_mode.clamp(self.percentage.0)))
+    }
+
+    /// Resolves the percentage.
+    #[inline]
+    pub fn resolve(&self, basis: Length) -> Length {
+        let length = self.length.px() + basis.px() * self.percentage.0;
+        Length::new(self.clamping_mode.clamp(length))
+    }
+
+    /// Resolves the percentage.
+    #[inline]
+    pub fn percentage_relative_to(&self, basis: Length) -> Length {
+        self.resolve(basis)
+    }
+
+    /// Returns the length, without clamping.
+    #[inline]
+    pub fn unclamped_length(&self) -> Length {
+        self.length
+    }
+
+    /// Returns true if the computed value is absolute 0 or 0%.
+    #[inline]
+    fn is_definitely_zero(&self) -> bool {
+        self.length.px() == 0.0 && self.percentage.0 == 0.0
+    }
+
+    /// Returns the clamped non-negative values.
+    #[inline]
+    fn clamp_to_non_negative(self) -> Self {
+        if self.has_percentage {
+            // If we can eagerly clamp the percentage then just do that.
+            if self.length.is_zero() {
+                return Self::with_clamping_mode(
+                    Length::zero(),
+                    Some(self.percentage.clamp_to_non_negative()),
+                    AllowedNumericType::NonNegative,
+                );
+            }
+            return Self::with_clamping_mode(self.length, Some(self.percentage), AllowedNumericType::NonNegative);
+        }
+
+        Self::with_clamping_mode(
+            self.length.clamp_to_non_negative(),
+            None,
+            AllowedNumericType::NonNegative,
+        )
+    }
+}
+
+// NOTE(emilio): We don't compare `clamping_mode` since we want to preserve the
+// invariant that `from_computed_value(length).to_computed_value(..) == length`.
+//
+// Right now for e.g. a non-negative length, we set clamping_mode to `All`
+// unconditionally for non-calc values, and to `NonNegative` for calc.
+//
+// If we determine that it's sound, from_computed_value() can generate an
+// absolute length, which then would get `All` as the clamping mode.
+//
+// We may want to just eagerly-detect whether we can clamp in
+// `LengthPercentage::new` and switch to `AllowedNumericType::NonNegative` then,
+// maybe.
+impl PartialEq for CalcLengthPercentage {
+    fn eq(&self, other: &Self) -> bool {
+        self.length == other.length &&
+            self.percentage == other.percentage &&
+            self.has_percentage == other.has_percentage
+    }
+}
+
+impl specified::CalcLengthPercentage {
+    /// Compute the value, zooming any absolute units by the zoom function.
+    fn to_computed_value_with_zoom<F>(
+        &self,
+        context: &Context,
+        zoom_fn: F,
+        base_size: FontBaseSize,
+    ) -> CalcLengthPercentage
+    where
+        F: Fn(Length) -> Length,
+    {
+        use std::f32;
+        use crate::values::specified::length::{ViewportPercentageLength, FontRelativeLength};
+
+        let mut length = 0.;
+
+        if let Some(absolute) = self.absolute {
+            length += zoom_fn(absolute.to_computed_value(context)).px();
+        }
+
+        for val in &[
+            self.vw.map(ViewportPercentageLength::Vw),
+            self.vh.map(ViewportPercentageLength::Vh),
+            self.vmin.map(ViewportPercentageLength::Vmin),
+            self.vmax.map(ViewportPercentageLength::Vmax),
+        ] {
+            if let Some(val) = *val {
+                let viewport_size = context.viewport_size_for_viewport_unit_resolution();
+                length += val.to_computed_value(viewport_size).px();
+            }
+        }
+
+        for val in &[
+            self.ch.map(FontRelativeLength::Ch),
+            self.em.map(FontRelativeLength::Em),
+            self.ex.map(FontRelativeLength::Ex),
+            self.rem.map(FontRelativeLength::Rem),
+        ] {
+            if let Some(val) = *val {
+                length += val.to_computed_value(context, base_size).px();
+            }
+        }
+
+        CalcLengthPercentage::with_clamping_mode(
+            Length::new(length.min(f32::MAX).max(f32::MIN)),
+            self.percentage,
+            self.clamping_mode,
+        )
+    }
+
+    /// Compute font-size or line-height taking into account text-zoom if necessary.
+    pub fn to_computed_value_zoomed(
+        &self,
+        context: &Context,
+        base_size: FontBaseSize,
+    ) -> CalcLengthPercentage {
+        self.to_computed_value_with_zoom(
+            context,
+            |abs| context.maybe_zoom_text(abs.into()),
+            base_size,
+        )
+    }
+
+    /// Compute the value into pixel length as CSSFloat without context,
+    /// so it returns Err(()) if there is any non-absolute unit.
+    pub fn to_computed_pixel_length_without_context(&self) -> Result<CSSFloat, ()> {
+        if self.vw.is_some() ||
+            self.vh.is_some() ||
+            self.vmin.is_some() ||
+            self.vmax.is_some() ||
+            self.em.is_some() ||
+            self.ex.is_some() ||
+            self.ch.is_some() ||
+            self.rem.is_some() ||
+            self.percentage.is_some()
+        {
+            return Err(());
+        }
+
+        match self.absolute {
+            Some(abs) => Ok(abs.to_px()),
+            None => {
+                debug_assert!(false, "Someone forgot to handle an unit here: {:?}", self);
+                Err(())
+            },
+        }
+    }
+
+    /// Compute the calc using the current font-size (and without text-zoom).
+    pub fn to_computed_value(&self, context: &Context) -> CalcLengthPercentage {
+        self.to_computed_value_with_zoom(context, |abs| abs, FontBaseSize::CurrentStyle)
+    }
+
+    #[inline]
+    fn from_computed_value(computed: &CalcLengthPercentage) -> Self {
+        use crate::values::specified::length::AbsoluteLength;
+
+        specified::CalcLengthPercentage {
+            clamping_mode: computed.clamping_mode,
+            absolute: Some(AbsoluteLength::from_computed_value(&computed.length)),
+            percentage: computed.specified_percentage(),
+            ..Default::default()
+        }
+    }
+}
+
+/// A wrapper of LengthPercentage, whose value must be >= 0.
+pub type NonNegativeLengthPercentage = NonNegative<LengthPercentage>;
+
+impl ToAnimatedValue for NonNegativeLengthPercentage {
+    type AnimatedValue = LengthPercentage;
+
+    #[inline]
+    fn to_animated_value(self) -> Self::AnimatedValue {
+        self.0
+    }
+
+    #[inline]
+    fn from_animated_value(animated: Self::AnimatedValue) -> Self {
+        NonNegative(animated.clamp_to_non_negative())
+    }
+}
+
+impl NonNegativeLengthPercentage {
+    /// Returns true if the computed value is absolute 0 or 0%.
+    #[inline]
+    pub fn is_definitely_zero(&self) -> bool {
+        self.0.is_definitely_zero()
+    }
+
+    /// Returns the used value.
+    #[inline]
+    pub fn to_used_value(&self, containing_length: Au) -> Au {
+        let resolved = self.0.to_used_value(containing_length);
+        std::cmp::max(resolved, Au(0))
+    }
+
+    /// Convert the computed value into used value.
+    #[inline]
+    pub fn maybe_to_used_value(&self, containing_length: Option<Au>) -> Option<Au> {
+        let resolved = self
+            .0
+            .maybe_to_used_value(containing_length.map(|v| v.into()))?;
+        Some(std::cmp::max(resolved, Au(0)))
+    }
+}
+
diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs
index 958deaaf44e..87c430fb265 100644
--- a/components/style/values/computed/mod.rs
+++ b/components/style/values/computed/mod.rs
@@ -108,6 +108,7 @@ pub mod flex;
 pub mod font;
 pub mod image;
 pub mod length;
+pub mod length_percentage;
 pub mod list;
 pub mod motion;
 pub mod outline;
diff --git a/components/style/values/specified/position.rs b/components/style/values/specified/position.rs
index 420133810ed..57a6715b0a6 100644
--- a/components/style/values/specified/position.rs
+++ b/components/style/values/specified/position.rs
@@ -297,7 +297,7 @@ impl<S: Side> ToComputedValue for PositionComponent<S> {
                 let p = Percentage(1. - length.percentage());
                 let l = -length.unclamped_length();
                 // We represent `<end-side> <length>` as `calc(100% - <length>)`.
-                ComputedLengthPercentage::new_calc(l, p)
+                ComputedLengthPercentage::new_calc(l, Some(p))
             },
             PositionComponent::Side(_, Some(ref length)) |
             PositionComponent::Length(ref length) => length.to_computed_value(context),

From 88fe64d845feb6a6e3d2ae31b2d45edec2a31628 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 13 Jan 2020 13:23:22 +0000
Subject: [PATCH 14/66] style: Pack LengthPercentage better.

So that it takes one pointer instead of two, and doesn't make nsStylePosition's
size blow up.

This is not as ugly as I was fearing, thankfully, though it requires a bit of
boilerplate. I think it's acceptable.

Differential Revision: https://phabricator.services.mozilla.com/D58702
---
 .../values/computed/length_percentage.rs      | 372 +++++++++++++++---
 components/style/values/resolved/mod.rs       |   1 +
 2 files changed, 315 insertions(+), 58 deletions(-)

diff --git a/components/style/values/computed/length_percentage.rs b/components/style/values/computed/length_percentage.rs
index ad108b9487a..bf489197b5a 100644
--- a/components/style/values/computed/length_percentage.rs
+++ b/components/style/values/computed/length_percentage.rs
@@ -3,19 +3,83 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 //! `<length-percentage>` computed values, and related ones.
+//!
+//! The over-all design is a tagged pointer, with the lower bits of the pointer
+//! being non-zero if it is a non-calc value.
+//!
+//! It is expected to take 64 bits both in x86 and x86-64. This is implemented
+//! as a `union`, with 4 different variants:
+//!
+//!  * The length and percentage variants have a { tag, f32 } (effectively)
+//!    layout. The tag has to overlap with the lower 2 bits of the calc variant.
+//!
+//!  * The `calc()` variant is a { tag, pointer } in x86 (so same as the
+//!    others), or just a { pointer } in x86-64 (so that the two bits of the tag
+//!    can be obtained from the lower bits of the pointer).
+//!
+//!  * There's a `tag` variant just to make clear when only the tag is intended
+//!    to be read. Note that the tag needs to be masked always by `TAG_MASK`, to
+//!    deal with the pointer variant in x86-64.
+//!
+//! The assertions in the constructor methods ensure that the tag getter matches
+//! our expectations.
 
 use super::{Context, Length, Percentage, ToComputedValue};
-use crate::values::animated::ToAnimatedValue;
+use crate::values::animated::{ToAnimatedValue, ToAnimatedZero};
 use crate::values::distance::{ComputeSquaredDistance, SquaredDistance};
 use crate::values::generics::NonNegative;
 use crate::values::specified::length::FontBaseSize;
 use crate::values::{specified, CSSFloat};
 use crate::Zero;
 use app_units::Au;
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
+use serde::{Serialize, Deserialize};
 use std::fmt::{self, Write};
 use style_traits::values::specified::AllowedNumericType;
 use style_traits::{CssWriter, ToCss};
 
+#[doc(hidden)]
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct LengthVariant {
+    tag: u32,
+    length: Length,
+}
+
+#[doc(hidden)]
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct PercentageVariant {
+    tag: u32,
+    percentage: Percentage,
+}
+
+// NOTE(emilio): cbindgen only understands the #[cfg] on the top level
+// definition.
+#[doc(hidden)]
+#[derive(Copy, Clone)]
+#[repr(C)]
+#[cfg(target_pointer_width = "32")]
+pub struct CalcVariant {
+    tag: u32,
+    ptr: *mut CalcLengthPercentage,
+}
+
+#[doc(hidden)]
+#[derive(Copy, Clone)]
+#[repr(C)]
+#[cfg(target_pointer_width = "64")]
+pub struct CalcVariant {
+    ptr: *mut CalcLengthPercentage,
+}
+
+#[doc(hidden)]
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct TagVariant {
+    tag: u32,
+}
+
 /// A `<length-percentage>` value. This can be either a `<length>`, a
 /// `<percentage>`, or a combination of both via `calc()`.
 ///
@@ -23,13 +87,87 @@ use style_traits::{CssWriter, ToCss};
 /// cbindgen:derive-mut-casts=true
 ///
 /// https://drafts.csswg.org/css-values-4/#typedef-length-percentage
-#[allow(missing_docs)]
-#[derive(Clone, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, ToAnimatedZero, ToResolvedValue)]
-#[repr(u8)]
-pub enum LengthPercentage {
+///
+/// The tag is stored in the lower two bits.
+///
+/// We need to use a struct instead of the union directly because unions with
+/// Drop implementations are unstable, looks like.
+///
+/// Also we need the union and the variants to be `pub` (even though the member
+/// is private) so that cbindgen generates it. They're not part of the public
+/// API otherwise.
+#[repr(transparent)]
+pub struct LengthPercentage(LengthPercentageUnion);
+
+#[doc(hidden)]
+#[repr(C)]
+pub union LengthPercentageUnion {
+    length: LengthVariant,
+    percentage: PercentageVariant,
+    calc: CalcVariant,
+    tag: TagVariant,
+}
+
+impl LengthPercentageUnion {
+    #[doc(hidden)] // Need to be public so that cbindgen generates it.
+    pub const TAG_CALC: u32 = 0;
+    #[doc(hidden)]
+    pub const TAG_LENGTH: u32 = 1;
+    #[doc(hidden)]
+    pub const TAG_PERCENTAGE: u32 = 2;
+    #[doc(hidden)]
+    pub const TAG_MASK: u32 = 0b11;
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(u32)]
+enum Tag {
+    Calc = LengthPercentageUnion::TAG_CALC,
+    Length = LengthPercentageUnion::TAG_LENGTH,
+    Percentage = LengthPercentageUnion::TAG_PERCENTAGE,
+}
+
+// All the members should be 64 bits, even in 32-bit builds.
+#[allow(unused)]
+unsafe fn static_assert() {
+    std::mem::transmute::<u64, LengthVariant>(0u64);
+    std::mem::transmute::<u64, PercentageVariant>(0u64);
+    std::mem::transmute::<u64, CalcVariant>(0u64);
+    std::mem::transmute::<u64, LengthPercentage>(0u64);
+}
+
+impl Drop for LengthPercentage {
+    fn drop(&mut self) {
+        if self.tag() == Tag::Calc {
+            let _ = unsafe { Box::from_raw(self.0.calc.ptr) };
+        }
+    }
+}
+
+impl MallocSizeOf for LengthPercentage {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        match self.unpack() {
+            Unpacked::Length(..) | Unpacked::Percentage(..) => 0,
+            Unpacked::Calc(c) => unsafe { ops.malloc_size_of(c) },
+        }
+    }
+}
+
+/// An unpacked `<length-percentage>` that borrows the `calc()` variant.
+#[derive(Clone, Debug, PartialEq)]
+enum Unpacked<'a> {
+    Calc(&'a CalcLengthPercentage),
+    Length(Length),
+    Percentage(Percentage),
+}
+
+/// An unpacked `<length-percentage>` that owns the `calc()` variant, for
+/// serialization purposes.
+#[derive(Deserialize, Serialize, PartialEq)]
+enum Serializable {
+    Calc(CalcLengthPercentage),
     Length(Length),
     Percentage(Percentage),
-    Calc(Box<CalcLengthPercentage>),
 }
 
 impl LengthPercentage {
@@ -41,14 +179,28 @@ impl LengthPercentage {
 
     /// Constructs a length value.
     #[inline]
-    pub fn new_length(l: Length) -> Self {
-        Self::Length(l)
+    pub fn new_length(length: Length) -> Self {
+        let length = Self(LengthPercentageUnion {
+            length: LengthVariant {
+                tag: LengthPercentageUnion::TAG_LENGTH,
+                length,
+            }
+        });
+        debug_assert_eq!(length.tag(), Tag::Length);
+        length
     }
 
     /// Constructs a percentage value.
     #[inline]
-    pub fn new_percent(p: Percentage) -> Self {
-        Self::Percentage(p)
+    pub fn new_percent(percentage: Percentage) -> Self {
+        let percent = Self(LengthPercentageUnion {
+            percentage: PercentageVariant {
+                tag: LengthPercentageUnion::TAG_PERCENTAGE,
+                percentage,
+            }
+        });
+        debug_assert_eq!(percent.tag(), Tag::Percentage);
+        percent
     }
 
     /// Constructs a `calc()` value.
@@ -57,23 +209,77 @@ impl LengthPercentage {
         CalcLengthPercentage::new(l, percentage).to_length_percentge()
     }
 
+    /// Private version of new_calc() that constructs a calc() variant without
+    /// checking.
+    fn new_calc_unchecked(calc: Box<CalcLengthPercentage>) -> Self {
+        let ptr = Box::into_raw(calc);
+        let calc = Self(LengthPercentageUnion {
+            calc: CalcVariant {
+                #[cfg(target_pointer_width = "32")]
+                tag: LengthPercentageUnion::TAG_CALC,
+                ptr,
+            }
+        });
+        debug_assert_eq!(calc.tag(), Tag::Calc);
+        calc
+    }
+
+    #[inline]
+    fn tag(&self) -> Tag {
+        match unsafe { self.0.tag.tag & LengthPercentageUnion::TAG_MASK } {
+            LengthPercentageUnion::TAG_CALC => Tag::Calc,
+            LengthPercentageUnion::TAG_LENGTH => Tag::Length,
+            LengthPercentageUnion::TAG_PERCENTAGE => Tag::Percentage,
+            _ => unreachable!("Bogus tag?"),
+        }
+    }
+
+    #[inline]
+    fn unpack<'a>(&'a self) -> Unpacked<'a> {
+        unsafe {
+            match self.tag() {
+                Tag::Calc => Unpacked::Calc(&*self.0.calc.ptr),
+                Tag::Length => Unpacked::Length(self.0.length.length),
+                Tag::Percentage => Unpacked::Percentage(self.0.percentage.percentage),
+            }
+        }
+    }
+
+    #[inline]
+    fn to_serializable(&self) -> Serializable {
+        match self.unpack() {
+            Unpacked::Calc(c) => Serializable::Calc(c.clone()),
+            Unpacked::Length(l) => Serializable::Length(l),
+            Unpacked::Percentage(p) => Serializable::Percentage(p),
+        }
+    }
+
+    #[inline]
+    fn from_serializable(s: Serializable) -> Self {
+        match s {
+            Serializable::Calc(c) => Self::new_calc_unchecked(Box::new(c)),
+            Serializable::Length(l) => Self::new_length(l),
+            Serializable::Percentage(p) => Self::new_percent(p),
+        }
+    }
+
     /// Returns true if the computed value is absolute 0 or 0%.
     #[inline]
     pub fn is_definitely_zero(&self) -> bool {
-        match *self {
-            Self::Length(l) => l.px() == 0.0,
-            Self::Percentage(p) => p.0 == 0.0,
-            Self::Calc(ref c) => c.is_definitely_zero(),
+        match self.unpack() {
+            Unpacked::Length(l) => l.px() == 0.0,
+            Unpacked::Percentage(p) => p.0 == 0.0,
+            Unpacked::Calc(ref c) => c.is_definitely_zero(),
         }
     }
 
     /// Returns the `<length>` component of this `calc()`, unclamped.
     #[inline]
     pub fn unclamped_length(&self) -> Length {
-        match *self {
-            Self::Length(l) => l,
-            Self::Percentage(..) => Zero::zero(),
-            Self::Calc(ref c) => c.unclamped_length(),
+        match self.unpack() {
+            Unpacked::Length(l) => l,
+            Unpacked::Percentage(..) => Zero::zero(),
+            Unpacked::Calc(c) => c.unclamped_length(),
         }
     }
 
@@ -89,10 +295,10 @@ impl LengthPercentage {
     /// Returns the `<length>` component of this `calc()`, clamped.
     #[inline]
     pub fn length_component(&self) -> Length {
-        match *self {
-            Self::Length(l) => l,
-            Self::Percentage(..) => Zero::zero(),
-            Self::Calc(ref c) => c.length_component(),
+        match self.unpack() {
+            Unpacked::Length(l) => l,
+            Unpacked::Percentage(..) => Zero::zero(),
+            Unpacked::Calc(c) => c.length_component(),
         }
     }
 
@@ -103,30 +309,30 @@ impl LengthPercentage {
     /// probably rename this.
     #[inline]
     pub fn percentage(&self) -> CSSFloat {
-        match *self {
-            Self::Length(..) => 0.,
-            Self::Percentage(p) => p.0,
-            Self::Calc(ref c) => c.percentage.0,
+        match self.unpack() {
+            Unpacked::Length(..) => 0.,
+            Unpacked::Percentage(p) => p.0,
+            Unpacked::Calc(c) => c.percentage.0,
         }
     }
 
     /// Returns the `<length>` component of this `calc()`, clamped.
     #[inline]
     pub fn as_percentage(&self) -> Option<Percentage> {
-        match *self {
-            Self::Length(..) => None,
-            Self::Percentage(p) => Some(p),
-            Self::Calc(ref c) => c.as_percentage(),
+        match self.unpack() {
+            Unpacked::Length(..) => None,
+            Unpacked::Percentage(p) => Some(p),
+            Unpacked::Calc(ref c) => c.as_percentage(),
         }
     }
 
     /// Resolves the percentage.
     #[inline]
     pub fn resolve(&self, basis: Length) -> Length {
-        match *self {
-            Self::Length(l) => l,
-            Self::Percentage(p) => Length::new(basis.px() * p.0),
-            Self::Calc(ref c) => c.resolve(basis),
+        match self.unpack() {
+            Unpacked::Length(l) => l,
+            Unpacked::Percentage(p) => Length::new(basis.px() * p.0),
+            Unpacked::Calc(ref c) => c.resolve(basis),
         }
     }
 
@@ -139,20 +345,20 @@ impl LengthPercentage {
     /// Return whether there's any percentage in this value.
     #[inline]
     pub fn has_percentage(&self) -> bool {
-        match *self {
-            Self::Length(..) => false,
-            Self::Percentage(..) => true,
-            Self::Calc(ref c) => c.has_percentage,
+        match self.unpack() {
+            Unpacked::Length(..) => false,
+            Unpacked::Percentage(..) => true,
+            Unpacked::Calc(ref c) => c.has_percentage,
         }
     }
 
     /// Return the specified percentage if any.
     #[inline]
     pub fn specified_percentage(&self) -> Option<Percentage> {
-        match *self {
-            Self::Length(..) => None,
-            Self::Percentage(p) => Some(p),
-            Self::Calc(ref c) => c.specified_percentage(),
+        match self.unpack() {
+            Unpacked::Length(..) => None,
+            Unpacked::Percentage(p) => Some(p),
+            Unpacked::Calc(ref c) => c.specified_percentage(),
         }
     }
 
@@ -186,11 +392,43 @@ impl LengthPercentage {
 
     /// Returns the clamped non-negative values.
     #[inline]
-    pub fn clamp_to_non_negative(self) -> Self {
-        match self {
-            Self::Length(l) => Self::Length(l.clamp_to_non_negative()),
-            Self::Percentage(p) => Self::Percentage(p.clamp_to_non_negative()),
-            Self::Calc(c) => c.clamp_to_non_negative().to_length_percentge(),
+    pub fn clamp_to_non_negative(&self) -> Self {
+        match self.unpack() {
+            Unpacked::Length(l) => Self::new_length(l.clamp_to_non_negative()),
+            Unpacked::Percentage(p) => Self::new_percent(p.clamp_to_non_negative()),
+            Unpacked::Calc(c) => c.clamp_to_non_negative().to_length_percentge(),
+        }
+    }
+}
+
+impl PartialEq for LengthPercentage {
+    fn eq(&self, other: &Self) -> bool {
+        self.unpack() == other.unpack()
+    }
+}
+
+impl fmt::Debug for LengthPercentage {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        self.unpack().fmt(formatter)
+    }
+}
+
+impl ToAnimatedZero for LengthPercentage {
+    fn to_animated_zero(&self) -> Result<Self, ()> {
+        Ok(match self.unpack() {
+            Unpacked::Length(l) => Self::new_length(l.to_animated_zero()?),
+            Unpacked::Percentage(p) => Self::new_percent(p.to_animated_zero()?),
+            Unpacked::Calc(c) => Self::new_calc_unchecked(Box::new(c.to_animated_zero()?)),
+        })
+    }
+}
+
+impl Clone for LengthPercentage {
+    fn clone(&self) -> Self {
+        match self.unpack() {
+            Unpacked::Length(l) => Self::new_length(l),
+            Unpacked::Percentage(p) => Self::new_percent(p),
+            Unpacked::Calc(c) => Self::new_calc_unchecked(Box::new(c.clone()))
         }
     }
 }
@@ -201,10 +439,10 @@ impl ToComputedValue for specified::LengthPercentage {
     fn to_computed_value(&self, context: &Context) -> LengthPercentage {
         match *self {
             specified::LengthPercentage::Length(ref value) => {
-                LengthPercentage::Length(value.to_computed_value(context))
+                LengthPercentage::new_length(value.to_computed_value(context))
             },
             specified::LengthPercentage::Percentage(value) => {
-                LengthPercentage::Percentage(value)
+                LengthPercentage::new_percent(value)
             },
             specified::LengthPercentage::Calc(ref calc) => {
                 (**calc).to_computed_value(context).to_length_percentge()
@@ -213,14 +451,14 @@ impl ToComputedValue for specified::LengthPercentage {
     }
 
     fn from_computed_value(computed: &LengthPercentage) -> Self {
-        match *computed {
-            LengthPercentage::Length(ref l) => {
+        match computed.unpack() {
+            Unpacked::Length(ref l) => {
                 specified::LengthPercentage::Length(ToComputedValue::from_computed_value(l))
             }
-            LengthPercentage::Percentage(p) => {
+            Unpacked::Percentage(p) => {
                 specified::LengthPercentage::Percentage(p)
             }
-            LengthPercentage::Calc(ref c) => {
+            Unpacked::Calc(c) => {
                 if let Some(p) = c.as_percentage() {
                     return specified::LengthPercentage::Percentage(p)
                 }
@@ -257,7 +495,7 @@ impl ToCss for LengthPercentage {
 
 impl Zero for LengthPercentage {
     fn zero() -> Self {
-        LengthPercentage::Length(Length::zero())
+        LengthPercentage::new_length(Length::zero())
     }
 
     #[inline]
@@ -266,6 +504,24 @@ impl Zero for LengthPercentage {
     }
 }
 
+impl Serialize for LengthPercentage {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        self.to_serializable().serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for LengthPercentage {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        Ok(Self::from_serializable(Serializable::deserialize(deserializer)?))
+    }
+}
+
 /// The representation of a calc() function.
 #[derive(
     Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue,
@@ -295,12 +551,12 @@ impl CalcLengthPercentage {
     #[inline]
     pub fn to_length_percentge(self) -> LengthPercentage {
         if !self.has_percentage {
-            return LengthPercentage::Length(self.length_component())
+            return LengthPercentage::new_length(self.length_component())
         }
         if self.length.is_zero() {
-            return LengthPercentage::Percentage(Percentage(self.clamping_mode.clamp(self.percentage.0)));
+            return LengthPercentage::new_percent(Percentage(self.clamping_mode.clamp(self.percentage.0)));
         }
-        LengthPercentage::Calc(Box::new(self))
+        LengthPercentage::new_calc_unchecked(Box::new(self))
     }
 
     fn specified_percentage(&self) -> Option<Percentage> {
@@ -369,7 +625,7 @@ impl CalcLengthPercentage {
 
     /// Returns the clamped non-negative values.
     #[inline]
-    fn clamp_to_non_negative(self) -> Self {
+    fn clamp_to_non_negative(&self) -> Self {
         if self.has_percentage {
             // If we can eagerly clamp the percentage then just do that.
             if self.length.is_zero() {
diff --git a/components/style/values/resolved/mod.rs b/components/style/values/resolved/mod.rs
index f50f58b5db4..022cb7893c6 100644
--- a/components/style/values/resolved/mod.rs
+++ b/components/style/values/resolved/mod.rs
@@ -78,6 +78,7 @@ trivial_to_resolved_value!(computed::url::ComputedUrl);
 trivial_to_resolved_value!(computed::url::ComputedImageUrl);
 #[cfg(feature = "servo")]
 trivial_to_resolved_value!(html5ever::Prefix);
+trivial_to_resolved_value!(computed::LengthPercentage);
 
 impl<A, B> ToResolvedValue for (A, B)
 where

From c5bd98354d111de7a380835a1d97a43a55b248c1 Mon Sep 17 00:00:00 2001
From: Makoto Kato <m_kato@ga2.so-net.ne.jp>
Date: Wed, 8 Jan 2020 11:55:28 +0000
Subject: [PATCH 15/66] style: Always use CssEnvironment from media query's
 device.

Although CssEnvironment is in Device of media query implementation, some code
creates CssEnvironment instance without Device. So I would like always to use it from Device of media query.

Differential Revision: https://phabricator.services.mozilla.com/D52506
---
 components/style/properties/declaration_block.rs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/components/style/properties/declaration_block.rs b/components/style/properties/declaration_block.rs
index 90dec0a47d7..d51701b2ced 100644
--- a/components/style/properties/declaration_block.rs
+++ b/components/style/properties/declaration_block.rs
@@ -778,6 +778,7 @@ impl PropertyDeclarationBlock {
         dest: &mut CssStringWriter,
         computed_values: Option<&ComputedValues>,
         custom_properties_block: Option<&PropertyDeclarationBlock>,
+        environment: &CssEnvironment,
     ) -> fmt::Result {
         if let Ok(shorthand) = property.as_shorthand() {
             return self.shorthand_to_css(shorthand, dest);
@@ -790,19 +791,13 @@ impl PropertyDeclarationBlock {
             None => return Err(fmt::Error),
         };
 
-        // TODO(emilio): When we implement any environment variable without
-        // hard-coding the values we're going to need to get something
-        // meaningful out of here... All this code path is so terribly hacky
-        // ;_;.
-        let env = CssEnvironment;
-
         let custom_properties = if let Some(cv) = computed_values {
             // If there are extra custom properties for this declaration block,
             // factor them in too.
             if let Some(block) = custom_properties_block {
                 // FIXME(emilio): This is not super-efficient here, and all this
                 // feels like a hack anyway...
-                block.cascade_custom_properties(cv.custom_properties(), &env)
+                block.cascade_custom_properties(cv.custom_properties(), environment)
             } else {
                 cv.custom_properties().cloned()
             }
@@ -825,7 +820,7 @@ impl PropertyDeclarationBlock {
                         declaration.id,
                         custom_properties.as_ref(),
                         QuirksMode::NoQuirks,
-                        &env,
+                        environment,
                     )
                     .to_css(dest)
             },

From 80a1b6438450b7df5b854112c43f7305b0fa34e2 Mon Sep 17 00:00:00 2001
From: Makoto Kato <m_kato@ga2.so-net.ne.jp>
Date: Wed, 8 Jan 2020 11:56:25 +0000
Subject: [PATCH 16/66] style: Part 2. Use Device for parameter instead of
 CssEnvironment.

CssEnvironment always is in Device, so use Device as parameter instead of CssEnvironment.

Differential Revision: https://phabricator.services.mozilla.com/D52507
---
 components/style/custom_properties.rs         | 37 ++++++++++---------
 components/style/properties/cascade.rs        |  4 +-
 .../style/properties/declaration_block.rs     | 14 +++----
 .../helpers/animated_properties.mako.rs       |  2 +-
 .../style/properties/properties.mako.rs       |  4 +-
 5 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/components/style/custom_properties.rs b/components/style/custom_properties.rs
index 3717e1f0614..a8ccd96effb 100644
--- a/components/style/custom_properties.rs
+++ b/components/style/custom_properties.rs
@@ -7,6 +7,7 @@
 //! [custom]: https://drafts.csswg.org/css-variables/
 
 use crate::hash::map::Entry;
+use crate::media_queries::Device;
 use crate::properties::{CSSWideKeyword, CustomDeclaration, CustomDeclarationValue};
 use crate::selector_map::{PrecomputedHashMap, PrecomputedHashSet, PrecomputedHasher};
 use crate::stylesheets::{Origin, PerOrigin};
@@ -497,14 +498,14 @@ pub struct CustomPropertiesBuilder<'a> {
     may_have_cycles: bool,
     custom_properties: Option<CustomPropertiesMap>,
     inherited: Option<&'a Arc<CustomPropertiesMap>>,
-    environment: &'a CssEnvironment,
+    device: &'a Device,
 }
 
 impl<'a> CustomPropertiesBuilder<'a> {
     /// Create a new builder, inheriting from a given custom properties map.
     pub fn new(
         inherited: Option<&'a Arc<CustomPropertiesMap>>,
-        environment: &'a CssEnvironment,
+        device: &'a Device,
     ) -> Self {
         Self {
             seen: PrecomputedHashSet::default(),
@@ -512,7 +513,7 @@ impl<'a> CustomPropertiesBuilder<'a> {
             may_have_cycles: false,
             custom_properties: None,
             inherited,
-            environment,
+            device,
         }
     }
 
@@ -554,7 +555,7 @@ impl<'a> CustomPropertiesBuilder<'a> {
                 // of forcing a full traversal in `substitute_all` afterwards.
                 let value = if !has_references && unparsed_value.references_environment {
                     let result =
-                        substitute_references_in_value(unparsed_value, &map, &self.environment);
+                        substitute_references_in_value(unparsed_value, &map, &self.device);
                     match result {
                         Ok(new_value) => Arc::new(new_value),
                         Err(..) => {
@@ -632,7 +633,7 @@ impl<'a> CustomPropertiesBuilder<'a> {
             None => return self.inherited.cloned(),
         };
         if self.may_have_cycles {
-            substitute_all(&mut map, self.environment);
+            substitute_all(&mut map, self.device);
         }
         Some(Arc::new(map))
     }
@@ -641,7 +642,7 @@ impl<'a> CustomPropertiesBuilder<'a> {
 /// Resolve all custom properties to either substituted or invalid.
 ///
 /// It does cycle dependencies removal at the same time as substitution.
-fn substitute_all(custom_properties_map: &mut CustomPropertiesMap, environment: &CssEnvironment) {
+fn substitute_all(custom_properties_map: &mut CustomPropertiesMap, device: &Device) {
     // The cycle dependencies removal in this function is a variant
     // of Tarjan's algorithm. It is mostly based on the pseudo-code
     // listed in
@@ -677,8 +678,8 @@ fn substitute_all(custom_properties_map: &mut CustomPropertiesMap, environment:
         /// all unfinished strong connected components.
         stack: SmallVec<[usize; 5]>,
         map: &'a mut CustomPropertiesMap,
-        /// The environment to substitute `env()` variables.
-        environment: &'a CssEnvironment,
+        /// to resolve the environment to substitute `env()` variables.
+        device: &'a Device,
     }
 
     /// This function combines the traversal for cycle removal and value
@@ -813,7 +814,7 @@ fn substitute_all(custom_properties_map: &mut CustomPropertiesMap, environment:
         // Now we have shown that this variable is not in a loop, and
         // all of its dependencies should have been resolved. We can
         // start substitution now.
-        let result = substitute_references_in_value(&value, &context.map, &context.environment);
+        let result = substitute_references_in_value(&value, &context.map, &context.device);
 
         match result {
             Ok(computed_value) => {
@@ -838,7 +839,7 @@ fn substitute_all(custom_properties_map: &mut CustomPropertiesMap, environment:
             stack: SmallVec::new(),
             var_info: SmallVec::new(),
             map: custom_properties_map,
-            environment,
+            device,
         };
         traverse(name, &mut context);
     }
@@ -848,7 +849,7 @@ fn substitute_all(custom_properties_map: &mut CustomPropertiesMap, environment:
 fn substitute_references_in_value<'i>(
     value: &'i VariableValue,
     custom_properties: &CustomPropertiesMap,
-    environment: &CssEnvironment,
+    device: &Device,
 ) -> Result<ComputedValue, ParseError<'i>> {
     debug_assert!(!value.references.is_empty() || value.references_environment);
 
@@ -862,7 +863,7 @@ fn substitute_references_in_value<'i>(
         &mut position,
         &mut computed_value,
         custom_properties,
-        environment,
+        device,
     )?;
 
     computed_value.push_from(&input, position, last_token_type)?;
@@ -884,7 +885,7 @@ fn substitute_block<'i>(
     position: &mut (SourcePosition, TokenSerializationType),
     partial_computed_value: &mut ComputedValue,
     custom_properties: &CustomPropertiesMap,
-    env: &CssEnvironment,
+    device: &Device,
 ) -> Result<TokenSerializationType, ParseError<'i>> {
     let mut last_token_type = TokenSerializationType::nothing();
     let mut set_position_at_next_iteration = false;
@@ -929,7 +930,7 @@ fn substitute_block<'i>(
                     };
 
                     let value = if is_env {
-                        env.get(&name)
+                        device.environment().get(&name)
                     } else {
                         custom_properties.get(&name).map(|v| &**v)
                     };
@@ -956,7 +957,7 @@ fn substitute_block<'i>(
                             &mut position,
                             partial_computed_value,
                             custom_properties,
-                            env,
+                            device,
                         )?;
                         partial_computed_value.push_from(input, position, last_token_type)?;
                     }
@@ -974,7 +975,7 @@ fn substitute_block<'i>(
                         position,
                         partial_computed_value,
                         custom_properties,
-                        env,
+                        device,
                     )
                 })?;
                 // It's the same type for CloseCurlyBracket and CloseSquareBracket.
@@ -1000,7 +1001,7 @@ pub fn substitute<'i>(
     input: &'i str,
     first_token_type: TokenSerializationType,
     computed_values_map: Option<&Arc<CustomPropertiesMap>>,
-    env: &CssEnvironment,
+    device: &Device,
 ) -> Result<String, ParseError<'i>> {
     let mut substituted = ComputedValue::empty();
     let mut input = ParserInput::new(input);
@@ -1016,7 +1017,7 @@ pub fn substitute<'i>(
         &mut position,
         &mut substituted,
         &custom_properties,
-        env,
+        device,
     )?;
     substituted.push_from(&input, position, last_token_type)?;
     Ok(substituted.css)
diff --git a/components/style/properties/cascade.rs b/components/style/properties/cascade.rs
index dd87916cf7d..234e06703bc 100644
--- a/components/style/properties/cascade.rs
+++ b/components/style/properties/cascade.rs
@@ -250,7 +250,7 @@ where
     let custom_properties = {
         let mut builder = CustomPropertiesBuilder::new(
             inherited_style.custom_properties(),
-            device.environment(),
+            device,
         );
 
         for (declaration, origin) in iter_declarations() {
@@ -424,7 +424,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
             declaration.id,
             self.context.builder.custom_properties.as_ref(),
             self.context.quirks_mode,
-            self.context.device().environment(),
+            self.context.device(),
         ))
     }
 
diff --git a/components/style/properties/declaration_block.rs b/components/style/properties/declaration_block.rs
index d51701b2ced..53b483887ce 100644
--- a/components/style/properties/declaration_block.rs
+++ b/components/style/properties/declaration_block.rs
@@ -8,7 +8,7 @@
 
 use super::*;
 use crate::context::QuirksMode;
-use crate::custom_properties::{CssEnvironment, CustomPropertiesBuilder};
+use crate::custom_properties::CustomPropertiesBuilder;
 use crate::error_reporting::{ContextualParseError, ParseErrorReporter};
 use crate::parser::ParserContext;
 use crate::properties::animated_properties::{AnimationValue, AnimationValueMap};
@@ -778,7 +778,7 @@ impl PropertyDeclarationBlock {
         dest: &mut CssStringWriter,
         computed_values: Option<&ComputedValues>,
         custom_properties_block: Option<&PropertyDeclarationBlock>,
-        environment: &CssEnvironment,
+        device: &Device,
     ) -> fmt::Result {
         if let Ok(shorthand) = property.as_shorthand() {
             return self.shorthand_to_css(shorthand, dest);
@@ -797,7 +797,7 @@ impl PropertyDeclarationBlock {
             if let Some(block) = custom_properties_block {
                 // FIXME(emilio): This is not super-efficient here, and all this
                 // feels like a hack anyway...
-                block.cascade_custom_properties(cv.custom_properties(), environment)
+                block.cascade_custom_properties(cv.custom_properties(), device)
             } else {
                 cv.custom_properties().cloned()
             }
@@ -820,7 +820,7 @@ impl PropertyDeclarationBlock {
                         declaration.id,
                         custom_properties.as_ref(),
                         QuirksMode::NoQuirks,
-                        environment,
+                        device,
                     )
                     .to_css(dest)
             },
@@ -868,7 +868,7 @@ impl PropertyDeclarationBlock {
     ) -> Option<Arc<crate::custom_properties::CustomPropertiesMap>> {
         self.cascade_custom_properties(
             context.style().custom_properties(),
-            context.device().environment(),
+            context.device(),
         )
     }
 
@@ -878,9 +878,9 @@ impl PropertyDeclarationBlock {
     fn cascade_custom_properties(
         &self,
         inherited_custom_properties: Option<&Arc<crate::custom_properties::CustomPropertiesMap>>,
-        environment: &CssEnvironment,
+        device: &Device,
     ) -> Option<Arc<crate::custom_properties::CustomPropertiesMap>> {
-        let mut builder = CustomPropertiesBuilder::new(inherited_custom_properties, environment);
+        let mut builder = CustomPropertiesBuilder::new(inherited_custom_properties, device);
 
         for declaration in self.normal_declaration_iter() {
             if let PropertyDeclaration::Custom(ref declaration) = *declaration {
diff --git a/components/style/properties/helpers/animated_properties.mako.rs b/components/style/properties/helpers/animated_properties.mako.rs
index c81e186a129..84f843ec728 100644
--- a/components/style/properties/helpers/animated_properties.mako.rs
+++ b/components/style/properties/helpers/animated_properties.mako.rs
@@ -507,7 +507,7 @@ impl AnimationValue {
                         declaration.id,
                         custom_properties,
                         context.quirks_mode,
-                        context.device().environment(),
+                        context.device(),
                     )
                 };
                 return AnimationValue::from_declaration(
diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs
index e4a07da1c77..d04d6d43d2e 100644
--- a/components/style/properties/properties.mako.rs
+++ b/components/style/properties/properties.mako.rs
@@ -1584,7 +1584,7 @@ impl UnparsedValue {
         longhand_id: LonghandId,
         custom_properties: Option<<&Arc<crate::custom_properties::CustomPropertiesMap>>,
         quirks_mode: QuirksMode,
-        environment: &::custom_properties::CssEnvironment,
+        device: &Device,
     ) -> PropertyDeclaration {
         let invalid_at_computed_value_time = || {
             let keyword = if longhand_id.inherited() {
@@ -1602,7 +1602,7 @@ impl UnparsedValue {
             &self.css,
             self.first_token_type,
             custom_properties,
-            environment,
+            device,
         ) {
             Ok(css) => css,
             Err(..) => return invalid_at_computed_value_time(),

From e9c14bb9fcd2a2f634eb234806865a214b0a75a3 Mon Sep 17 00:00:00 2001
From: Makoto Kato <m_kato@ga2.so-net.ne.jp>
Date: Wed, 8 Jan 2020 11:56:25 +0000
Subject: [PATCH 17/66] style: Don't use hardcoded value for safearea.

To implement safe area support on Gecko, we should get safe area from Device.

Differential Revision: https://phabricator.services.mozilla.com/D52504
---
 components/style/custom_properties.rs   | 84 +++++++++++++++++--------
 components/style/gecko/media_queries.rs |  7 ++-
 components/style/servo/media_queries.rs |  7 ++-
 3 files changed, 69 insertions(+), 29 deletions(-)

diff --git a/components/style/custom_properties.rs b/components/style/custom_properties.rs
index a8ccd96effb..06d0e71cb8b 100644
--- a/components/style/custom_properties.rs
+++ b/components/style/custom_properties.rs
@@ -12,7 +12,7 @@ use crate::properties::{CSSWideKeyword, CustomDeclaration, CustomDeclarationValu
 use crate::selector_map::{PrecomputedHashMap, PrecomputedHashSet, PrecomputedHasher};
 use crate::stylesheets::{Origin, PerOrigin};
 use crate::Atom;
-use cssparser::{Delimiter, Parser, ParserInput, SourcePosition, Token, TokenSerializationType};
+use cssparser::{CowRcStr, Delimiter, Parser, ParserInput, SourcePosition, Token, TokenSerializationType};
 use indexmap::IndexMap;
 use selectors::parser::SelectorParseErrorKind;
 use servo_arc::Arc;
@@ -30,50 +30,52 @@ use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
 #[derive(Debug, MallocSizeOf)]
 pub struct CssEnvironment;
 
+type EnvironmentEvaluator = fn(device: &Device) -> VariableValue;
+
 struct EnvironmentVariable {
     name: Atom,
-    value: VariableValue,
+    evaluator: EnvironmentEvaluator,
 }
 
 macro_rules! make_variable {
-    ($name:expr, $value:expr) => {{
+    ($name:expr, $evaluator:expr) => {{
         EnvironmentVariable {
             name: $name,
-            value: {
-                // TODO(emilio): We could make this be more efficient (though a
-                // bit less convenient).
-                let mut input = ParserInput::new($value);
-                let mut input = Parser::new(&mut input);
-
-                let (first_token_type, css, last_token_type) =
-                    parse_self_contained_declaration_value(&mut input, None).unwrap();
-
-                VariableValue {
-                    css: css.into_owned(),
-                    first_token_type,
-                    last_token_type,
-                    references: Default::default(),
-                    references_environment: false,
-                }
-            },
+            evaluator: $evaluator,
         }
     }};
 }
 
+fn get_safearea_inset_top(device: &Device) -> VariableValue {
+    VariableValue::pixel(device.safe_area_insets().top)
+}
+
+fn get_safearea_inset_bottom(device: &Device) -> VariableValue {
+    VariableValue::pixel(device.safe_area_insets().bottom)
+}
+
+fn get_safearea_inset_left(device: &Device) -> VariableValue {
+    VariableValue::pixel(device.safe_area_insets().left)
+}
+
+fn get_safearea_inset_right(device: &Device) -> VariableValue {
+    VariableValue::pixel(device.safe_area_insets().right)
+}
+
 lazy_static! {
     static ref ENVIRONMENT_VARIABLES: [EnvironmentVariable; 4] = [
-        make_variable!(atom!("safe-area-inset-top"), "0px"),
-        make_variable!(atom!("safe-area-inset-bottom"), "0px"),
-        make_variable!(atom!("safe-area-inset-left"), "0px"),
-        make_variable!(atom!("safe-area-inset-right"), "0px"),
+        make_variable!(atom!("safe-area-inset-top"), get_safearea_inset_top),
+        make_variable!(atom!("safe-area-inset-bottom"), get_safearea_inset_bottom),
+        make_variable!(atom!("safe-area-inset-left"), get_safearea_inset_left),
+        make_variable!(atom!("safe-area-inset-right"), get_safearea_inset_right),
     ];
 }
 
 impl CssEnvironment {
     #[inline]
-    fn get(&self, name: &Atom) -> Option<&VariableValue> {
+    fn get(&self, name: &Atom, device: &Device) -> Option<VariableValue> {
         let var = ENVIRONMENT_VARIABLES.iter().find(|var| var.name == *name)?;
-        Some(&var.value)
+        Some((var.evaluator)(device))
     }
 }
 
@@ -253,6 +255,28 @@ impl VariableValue {
             references_environment: references.references_environment,
         }))
     }
+
+    /// Create VariableValue from css pixel value
+    pub fn pixel(number: f32) -> Self {
+        // FIXME (https://github.com/servo/rust-cssparser/issues/266):
+        // No way to get TokenSerializationType::Dimension without creating
+        // Token object.
+        let token = Token::Dimension {
+            has_sign: false,
+            value: number,
+            int_value: None,
+            unit: CowRcStr::from("px"),
+        };
+        let token_type = token.serialization_type();
+
+        VariableValue {
+            css: token.to_css_string(),
+            first_token_type: token_type,
+            last_token_type: token_type,
+            references: Default::default(),
+            references_environment: false,
+        }
+    }
 }
 
 /// Parse the value of a non-custom property that contains `var()` references.
@@ -929,8 +953,14 @@ fn substitute_block<'i>(
                         }
                     };
 
+                    let env_value;
                     let value = if is_env {
-                        device.environment().get(&name)
+                        if let Some(v) = device.environment().get(&name, device) {
+                            env_value = v;
+                            Some(&env_value)
+                        } else {
+                            None
+                        }
                     } else {
                         custom_properties.get(&name).map(|v| &**v)
                     };
diff --git a/components/style/gecko/media_queries.rs b/components/style/gecko/media_queries.rs
index 390c1d4fe58..39b99a4fefe 100644
--- a/components/style/gecko/media_queries.rs
+++ b/components/style/gecko/media_queries.rs
@@ -16,7 +16,7 @@ use crate::values::{CustomIdent, KeyframesName};
 use app_units::{Au, AU_PER_PX};
 use cssparser::RGBA;
 use euclid::default::Size2D;
-use euclid::Scale;
+use euclid::{Scale, SideOffsets2D};
 use servo_arc::Arc;
 use std::fmt;
 use std::sync::atomic::{AtomicBool, AtomicIsize, AtomicUsize, Ordering};
@@ -301,4 +301,9 @@ impl Device {
     pub fn unzoom_text(&self, size: Au) -> Au {
         size.scale_by(1. / self.effective_text_zoom())
     }
+
+    /// Returns safe area insets
+    pub fn safe_area_insets(&self) -> SideOffsets2D<f32, CSSPixel> {
+        SideOffsets2D::zero()
+    }
 }
diff --git a/components/style/servo/media_queries.rs b/components/style/servo/media_queries.rs
index 4cdfc80eef7..b1e752234e5 100644
--- a/components/style/servo/media_queries.rs
+++ b/components/style/servo/media_queries.rs
@@ -16,7 +16,7 @@ use crate::values::KeyframesName;
 use app_units::Au;
 use cssparser::RGBA;
 use euclid::default::Size2D as UntypedSize2D;
-use euclid::{Scale, Size2D};
+use euclid::{Scale, Size2D, SideOffsets2D};
 use std::sync::atomic::{AtomicBool, AtomicIsize, Ordering};
 use style_traits::viewport::ViewportConstraints;
 use style_traits::{CSSPixel, DevicePixel};
@@ -164,6 +164,11 @@ impl Device {
     pub fn default_background_color(&self) -> RGBA {
         RGBA::new(255, 255, 255, 255)
     }
+
+    /// Returns safe area insets
+    pub fn safe_area_insets(&self) -> SideOffsets2D<f32, CSSPixel> {
+        SideOffsets2D::zero()
+    }
 }
 
 /// https://drafts.csswg.org/mediaqueries-4/#width

From c569d314a526074fefc660bb91ac7f53f2b30ff2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Tue, 14 Jan 2020 20:25:03 +0000
Subject: [PATCH 18/66] style: Do not ignore color: transparent in high
 contrast mode.

PDFJS uses it, for example to allow text selection. It's not great if it shows
on top of the actual PDF :-)

Differential Revision: https://phabricator.services.mozilla.com/D58703
---
 components/style/gecko/media_queries.rs |  5 ++++
 components/style/properties/cascade.rs  | 36 ++++++++++++++-----------
 2 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/components/style/gecko/media_queries.rs b/components/style/gecko/media_queries.rs
index 39b99a4fefe..ae4bad7a25a 100644
--- a/components/style/gecko/media_queries.rs
+++ b/components/style/gecko/media_queries.rs
@@ -280,6 +280,11 @@ impl Device {
         convert_nscolor_to_rgba(self.pref_sheet_prefs().mDefaultBackgroundColor)
     }
 
+    /// Returns the default foreground color.
+    pub fn default_color(&self) -> RGBA {
+        convert_nscolor_to_rgba(self.pref_sheet_prefs().mDefaultColor)
+    }
+
     /// Returns the current effective text zoom.
     #[inline]
     fn effective_text_zoom(&self) -> f32 {
diff --git a/components/style/properties/cascade.rs b/components/style/properties/cascade.rs
index 234e06703bc..f9f17a57121 100644
--- a/components/style/properties/cascade.rs
+++ b/components/style/properties/cascade.rs
@@ -25,7 +25,7 @@ use smallvec::SmallVec;
 use std::borrow::Cow;
 use std::cell::RefCell;
 use crate::style_adjuster::StyleAdjuster;
-use crate::values::computed;
+use crate::values::{computed, specified};
 
 /// We split the cascade in two phases: 'early' properties, and 'late'
 /// properties.
@@ -365,24 +365,28 @@ fn should_ignore_declaration_when_ignoring_document_colors(
     // a background image, if we're ignoring document colors).
     // Here we check backplate status to decide if ignoring background-image
     // is the right decision.
-    {
-        let background_color = match **declaration {
-            PropertyDeclaration::BackgroundColor(ref color) => color,
-            // In the future, if/when we remove the backplate pref, we can remove this
-            // special case along with the 'ignored_when_colors_disabled=True' mako line
-            // for the "background-image" property.
-            #[cfg(feature = "gecko")]
-            PropertyDeclaration::BackgroundImage(..) => return !static_prefs::pref!("browser.display.permit_backplate"),
-            _ => return true,
-        };
+    let (is_background, is_transparent) = match **declaration {
+        PropertyDeclaration::BackgroundColor(ref color) => (true, color.is_transparent()),
+        PropertyDeclaration::Color(ref color) => (false, color.0.is_transparent()),
+        // In the future, if/when we remove the backplate pref, we can remove this
+        // special case along with the 'ignored_when_colors_disabled=True' mako line
+        // for the "background-image" property.
+        #[cfg(feature = "gecko")]
+        PropertyDeclaration::BackgroundImage(..) => return !static_prefs::pref!("browser.display.permit_backplate"),
+        _ => return true,
+    };
 
-        if background_color.is_transparent() {
-            return false;
-        }
+    if is_transparent {
+        return false;
     }
 
-    let color = device.default_background_color();
-    *declaration.to_mut() = PropertyDeclaration::BackgroundColor(color.into());
+    if is_background {
+        let color = device.default_background_color();
+        *declaration.to_mut() = PropertyDeclaration::BackgroundColor(color.into());
+    } else {
+        let color = device.default_color();
+        *declaration.to_mut() = PropertyDeclaration::Color(specified::ColorPropertyValue(color.into()));
+    }
 
     false
 }

From 9026720f0477412b271d4e1979041278d6e3a087 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Tue, 14 Jan 2020 19:01:05 +0000
Subject: [PATCH 19/66] style: Rewrite <input type=number> to avoid an
 anonymous input.

Instead, subclass nsTextControlFrame. This simplifies the code and avoids
correctness issues.

I kept the localization functionality though it is not spec compliant. But I
filed a bug to remove it in a followup.

Differential Revision: https://phabricator.services.mozilla.com/D57193
---
 components/style/gecko/wrapper.rs | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

diff --git a/components/style/gecko/wrapper.rs b/components/style/gecko/wrapper.rs
index e4b2d7f0be1..9a1196a11b5 100644
--- a/components/style/gecko/wrapper.rs
+++ b/components/style/gecko/wrapper.rs
@@ -1869,22 +1869,7 @@ impl<'le> ::selectors::Element for GeckoElement<'le> {
     #[inline]
     fn pseudo_element_originating_element(&self) -> Option<Self> {
         debug_assert!(self.is_pseudo_element());
-        let parent = self.closest_anon_subtree_root_parent()?;
-
-        // FIXME(emilio): Special-case for <input type="number">s
-        // pseudo-elements, which are nested NAC. Probably nsNumberControlFrame
-        // should instead inherit from nsTextControlFrame, and then this could
-        // go away.
-        if let Some(PseudoElement::MozNumberText) = parent.implemented_pseudo_element() {
-            debug_assert_eq!(
-                self.implemented_pseudo_element().unwrap(),
-                PseudoElement::Placeholder,
-                "You added a new pseudo, do you really want this?"
-            );
-            return parent.closest_anon_subtree_root_parent();
-        }
-
-        Some(parent)
+        self.closest_anon_subtree_root_parent()
     }
 
     #[inline]

From d74f90e3a7c6d6aff05ad50d378ac6b8d8304cbb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Wed, 15 Jan 2020 00:46:01 +0000
Subject: [PATCH 20/66] style: Centralize calc function parsing.

So that extending it to support other math functions like min / max / etc is
simpler.

There should be no behavior change with this patch, though I added a comment to
some places where we don't do calc() clamping correctly (though other browsers
don't either so...).

Differential Revision: https://phabricator.services.mozilla.com/D59939
---
 components/style/values/specified/angle.rs    | 15 ++--
 components/style/values/specified/calc.rs     | 73 +++++++++++++++----
 components/style/values/specified/color.rs    | 14 ++--
 components/style/values/specified/length.rs   | 17 ++---
 components/style/values/specified/mod.rs      | 28 +++----
 .../style/values/specified/percentage.rs      |  8 +-
 components/style/values/specified/time.rs     | 19 +++--
 7 files changed, 116 insertions(+), 58 deletions(-)

diff --git a/components/style/values/specified/angle.rs b/components/style/values/specified/angle.rs
index 458f4178e59..6485bca6f8f 100644
--- a/components/style/values/specified/angle.rs
+++ b/components/style/values/specified/angle.rs
@@ -208,7 +208,9 @@ impl Angle {
         input: &mut Parser<'i, 't>,
         allow_unitless_zero: AllowUnitlessZeroAngle,
     ) -> Result<Self, ParseError<'i>> {
+        let location = input.current_source_location();
         let t = input.next()?;
+        let allow_unitless_zero = matches!(allow_unitless_zero, AllowUnitlessZeroAngle::Yes);
         match *t {
             Token::Dimension {
                 value, ref unit, ..
@@ -221,15 +223,12 @@ impl Angle {
                     },
                 }
             },
-            Token::Number { value, .. } if value == 0. => match allow_unitless_zero {
-                AllowUnitlessZeroAngle::Yes => Ok(Angle::zero()),
-                AllowUnitlessZeroAngle::No => {
-                    let t = t.clone();
-                    Err(input.new_unexpected_token_error(t))
-                },
+            Token::Function(ref name) => {
+                let function = CalcNode::math_function(name, location)?;
+                CalcNode::parse_angle(context, input, function)
             },
-            Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
-                return input.parse_nested_block(|i| CalcNode::parse_angle(context, i));
+            Token::Number { value, .. } if value == 0. && allow_unitless_zero => {
+                Ok(Angle::zero())
             },
             ref t => {
                 let t = t.clone();
diff --git a/components/style/values/specified/calc.rs b/components/style/values/specified/calc.rs
index f9feb616fff..d951d0de08e 100644
--- a/components/style/values/specified/calc.rs
+++ b/components/style/values/specified/calc.rs
@@ -12,11 +12,19 @@ use crate::values::specified::length::ViewportPercentageLength;
 use crate::values::specified::length::{AbsoluteLength, FontRelativeLength, NoCalcLength};
 use crate::values::specified::{Angle, Time};
 use crate::values::{CSSFloat, CSSInteger};
-use cssparser::{AngleOrNumber, NumberOrPercentage, Parser, Token};
+use cssparser::{AngleOrNumber, CowRcStr, NumberOrPercentage, Parser, Token};
 use std::fmt::{self, Write};
 use style_traits::values::specified::AllowedNumericType;
 use style_traits::{CssWriter, ParseError, SpecifiedValueInfo, StyleParseErrorKind, ToCss};
 
+/// The name of the mathematical function that we're parsing.
+#[derive(Debug, Copy, Clone)]
+pub enum MathFunction {
+    /// `calc()`
+    Calc,
+    // FIXME: min() / max() / clamp
+}
+
 /// A node inside a `Calc` expression's AST.
 #[derive(Clone, Debug)]
 pub enum CalcNode {
@@ -204,10 +212,13 @@ impl CalcNode {
                 Ok(CalcNode::Percentage(unit_value))
             },
             (&Token::ParenthesisBlock, _) => {
-                input.parse_nested_block(|i| CalcNode::parse(context, i, expected_unit))
+                input.parse_nested_block(|input| {
+                    CalcNode::parse_argument(context, input, expected_unit)
+                })
             },
-            (&Token::Function(ref name), _) if name.eq_ignore_ascii_case("calc") => {
-                input.parse_nested_block(|i| CalcNode::parse(context, i, expected_unit))
+            (&Token::Function(ref name), _) => {
+                let function = CalcNode::math_function(name, location)?;
+                CalcNode::parse(context, input, function, expected_unit)
             },
             (t, _) => Err(location.new_unexpected_token_error(t.clone())),
         }
@@ -217,6 +228,20 @@ impl CalcNode {
     ///
     /// This is in charge of parsing, for example, `2 + 3 * 100%`.
     fn parse<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+        _function: MathFunction,
+        expected_unit: CalcUnit,
+    ) -> Result<Self, ParseError<'i>> {
+        // TODO: Do something different based on the function name. In
+        // particular, for non-calc function we need to take a list of
+        // comma-separated arguments and such.
+        input.parse_nested_block(|input| {
+            Self::parse_argument(context, input, expected_unit)
+        })
+    }
+
+    fn parse_argument<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         expected_unit: CalcUnit,
@@ -526,12 +551,26 @@ impl CalcNode {
         })
     }
 
+    /// Given a function name, and the location from where the token came from,
+    /// return a mathematical function corresponding to that name or an error.
+    #[inline]
+    pub fn math_function<'i>(
+        name: &CowRcStr<'i>,
+        location: cssparser::SourceLocation,
+    ) -> Result<MathFunction, ParseError<'i>> {
+        if !name.eq_ignore_ascii_case("calc") {
+            return Err(location.new_unexpected_token_error(Token::Function(name.clone())));
+        }
+        Ok(MathFunction::Calc)
+    }
+
     /// Convenience parsing function for integers.
     pub fn parse_integer<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
+        function: MathFunction,
     ) -> Result<CSSInteger, ParseError<'i>> {
-        Self::parse_number(context, input).map(|n| n.round() as CSSInteger)
+        Self::parse_number(context, input, function).map(|n| n.round() as CSSInteger)
     }
 
     /// Convenience parsing function for `<length> | <percentage>`.
@@ -539,8 +578,9 @@ impl CalcNode {
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         clamping_mode: AllowedNumericType,
+        function: MathFunction,
     ) -> Result<CalcLengthPercentage, ParseError<'i>> {
-        Self::parse(context, input, CalcUnit::LengthPercentage)?
+        Self::parse(context, input, function, CalcUnit::LengthPercentage)?
             .to_length_or_percentage(clamping_mode)
             .map_err(|()| input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
     }
@@ -549,8 +589,9 @@ impl CalcNode {
     pub fn parse_percentage<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
+        function: MathFunction,
     ) -> Result<CSSFloat, ParseError<'i>> {
-        Self::parse(context, input, CalcUnit::Percentage)?
+        Self::parse(context, input, function, CalcUnit::Percentage)?
             .to_percentage()
             .map_err(|()| input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
     }
@@ -560,8 +601,9 @@ impl CalcNode {
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         clamping_mode: AllowedNumericType,
+        function: MathFunction,
     ) -> Result<CalcLengthPercentage, ParseError<'i>> {
-        Self::parse(context, input, CalcUnit::Length)?
+        Self::parse(context, input, function, CalcUnit::Length)?
             .to_length_or_percentage(clamping_mode)
             .map_err(|()| input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
     }
@@ -570,8 +612,9 @@ impl CalcNode {
     pub fn parse_number<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
+        function: MathFunction,
     ) -> Result<CSSFloat, ParseError<'i>> {
-        Self::parse(context, input, CalcUnit::Number)?
+        Self::parse(context, input, function, CalcUnit::Number)?
             .to_number()
             .map_err(|()| input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
     }
@@ -580,8 +623,9 @@ impl CalcNode {
     pub fn parse_angle<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
+        function: MathFunction,
     ) -> Result<Angle, ParseError<'i>> {
-        Self::parse(context, input, CalcUnit::Angle)?
+        Self::parse(context, input, function, CalcUnit::Angle)?
             .to_angle()
             .map_err(|()| input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
     }
@@ -590,8 +634,9 @@ impl CalcNode {
     pub fn parse_time<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
+        function: MathFunction,
     ) -> Result<Time, ParseError<'i>> {
-        Self::parse(context, input, CalcUnit::Time)?
+        Self::parse(context, input, function, CalcUnit::Time)?
             .to_time()
             .map_err(|()| input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
     }
@@ -600,8 +645,9 @@ impl CalcNode {
     pub fn parse_number_or_percentage<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
+        function: MathFunction,
     ) -> Result<NumberOrPercentage, ParseError<'i>> {
-        let node = Self::parse(context, input, CalcUnit::Percentage)?;
+        let node = Self::parse(context, input, function, CalcUnit::Percentage)?;
 
         if let Ok(value) = node.to_number() {
             return Ok(NumberOrPercentage::Number { value });
@@ -617,8 +663,9 @@ impl CalcNode {
     pub fn parse_angle_or_number<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
+        function: MathFunction,
     ) -> Result<AngleOrNumber, ParseError<'i>> {
-        let node = Self::parse(context, input, CalcUnit::Angle)?;
+        let node = Self::parse(context, input, function, CalcUnit::Angle)?;
 
         if let Ok(angle) = node.to_angle() {
             let degrees = angle.degrees();
diff --git a/components/style/values/specified/color.rs b/components/style/values/specified/color.rs
index 4e761f95338..be969f27cd4 100644
--- a/components/style/values/specified/color.rs
+++ b/components/style/values/specified/color.rs
@@ -298,8 +298,9 @@ impl<'a, 'b: 'a, 'i: 'a> ::cssparser::ColorComponentParser<'i> for ColorComponen
                 Ok(AngleOrNumber::Angle { degrees })
             },
             Token::Number { value, .. } => Ok(AngleOrNumber::Number { value }),
-            Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
-                input.parse_nested_block(|i| CalcNode::parse_angle_or_number(self.0, i))
+            Token::Function(ref name) => {
+                let function = CalcNode::math_function(name, location)?;
+                CalcNode::parse_angle_or_number(self.0, input, function)
             },
             t => return Err(location.new_unexpected_token_error(t)),
         }
@@ -323,15 +324,16 @@ impl<'a, 'b: 'a, 'i: 'a> ::cssparser::ColorComponentParser<'i> for ColorComponen
     ) -> Result<NumberOrPercentage, ParseError<'i>> {
         let location = input.current_source_location();
 
-        match input.next()?.clone() {
+        match *input.next()? {
             Token::Number { value, .. } => Ok(NumberOrPercentage::Number { value }),
             Token::Percentage { unit_value, .. } => {
                 Ok(NumberOrPercentage::Percentage { unit_value })
             },
-            Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
-                input.parse_nested_block(|i| CalcNode::parse_number_or_percentage(self.0, i))
+            Token::Function(ref name) => {
+                let function = CalcNode::math_function(name, location)?;
+                CalcNode::parse_number_or_percentage(self.0, input, function)
             },
-            t => return Err(location.new_unexpected_token_error(t)),
+            ref t => return Err(location.new_unexpected_token_error(t.clone())),
         }
     }
 }
diff --git a/components/style/values/specified/length.rs b/components/style/values/specified/length.rs
index d9a51665ead..1ef76054382 100644
--- a/components/style/values/specified/length.rs
+++ b/components/style/values/specified/length.rs
@@ -599,11 +599,11 @@ impl Length {
                     value,
                 ))))
             },
-            Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => input
-                .parse_nested_block(|input| {
-                    CalcNode::parse_length(context, input, num_context)
-                        .map(|calc| Length::Calc(Box::new(calc)))
-                }),
+            Token::Function(ref name) => {
+                let function = CalcNode::math_function(name, location)?;
+                let calc = CalcNode::parse_length(context, input, num_context, function)?;
+                Ok(Length::Calc(Box::new(calc)))
+            },
             ref token => return Err(location.new_unexpected_token_error(token.clone())),
         }
     }
@@ -822,10 +822,9 @@ impl LengthPercentage {
                     return Ok(LengthPercentage::Length(NoCalcLength::from_px(value)));
                 }
             },
-            Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
-                let calc = input.parse_nested_block(|i| {
-                    CalcNode::parse_length_or_percentage(context, i, num_context)
-                })?;
+            Token::Function(ref name) => {
+                let function = CalcNode::math_function(name, location)?;
+                let calc = CalcNode::parse_length_or_percentage(context, input, num_context, function)?;
                 Ok(LengthPercentage::Calc(Box::new(calc)))
             },
             _ => return Err(location.new_unexpected_token_error(token.clone())),
diff --git a/components/style/values/specified/mod.rs b/components/style/values/specified/mod.rs
index 7e16ba09601..8399456a491 100644
--- a/components/style/values/specified/mod.rs
+++ b/components/style/values/specified/mod.rs
@@ -144,8 +144,9 @@ fn parse_number_with_clamping_mode<'i, 't>(
                 calc_clamping_mode: None,
             })
         },
-        Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
-            let result = input.parse_nested_block(|i| CalcNode::parse_number(context, i))?;
+        Token::Function(ref name) => {
+            let function = CalcNode::math_function(name, location)?;
+            let result = CalcNode::parse_number(context, input, function)?;
             Ok(Number {
                 value: result.min(f32::MAX).max(f32::MIN),
                 calc_clamping_mode: Some(clamping_mode),
@@ -543,8 +544,9 @@ impl Parse for Integer {
             Token::Number {
                 int_value: Some(v), ..
             } => Ok(Integer::new(v)),
-            Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
-                let result = input.parse_nested_block(|i| CalcNode::parse_integer(context, i))?;
+            Token::Function(ref name) => {
+                let function = CalcNode::math_function(name, location)?;
+                let result = CalcNode::parse_integer(context, input, function)?;
                 Ok(Integer::from_calc(result))
             },
             ref t => Err(location.new_unexpected_token_error(t.clone())),
@@ -559,16 +561,16 @@ impl Integer {
         input: &mut Parser<'i, 't>,
         min: i32,
     ) -> Result<Integer, ParseError<'i>> {
-        match Integer::parse(context, input) {
-            // FIXME(emilio): The spec asks us to avoid rejecting it at parse
-            // time except until computed value time.
-            //
-            // It's not totally clear it's worth it though, and no other browser
-            // does this.
-            Ok(value) if value.value() >= min => Ok(value),
-            Ok(_value) => Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)),
-            Err(e) => Err(e),
+        let value = Integer::parse(context, input)?;
+        // FIXME(emilio): The spec asks us to avoid rejecting it at parse
+        // time except until computed value time.
+        //
+        // It's not totally clear it's worth it though, and no other browser
+        // does this.
+        if value.value() < min {
+            return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
         }
+        Ok(value)
     }
 
     /// Parse a non-negative integer.
diff --git a/components/style/values/specified/percentage.rs b/components/style/values/specified/percentage.rs
index 50ebbb3bcf6..75549dca3be 100644
--- a/components/style/values/specified/percentage.rs
+++ b/components/style/values/specified/percentage.rs
@@ -117,14 +117,14 @@ impl Percentage {
             {
                 Ok(Percentage::new(unit_value))
             },
-            Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
-                let result =
-                    input.parse_nested_block(|i| CalcNode::parse_percentage(context, i))?;
+            Token::Function(ref name) => {
+                let function = CalcNode::math_function(name, location)?;
+                let value = CalcNode::parse_percentage(context, input, function)?;
 
                 // TODO(emilio): -moz-image-rect is the only thing that uses
                 // the clamping mode... I guess we could disallow it...
                 Ok(Percentage {
-                    value: result,
+                    value,
                     calc_clamping_mode: Some(num_context),
                 })
             },
diff --git a/components/style/values/specified/time.rs b/components/style/values/specified/time.rs
index 0006ec45923..aba3f0a828f 100644
--- a/components/style/values/specified/time.rs
+++ b/components/style/values/specified/time.rs
@@ -69,7 +69,7 @@ impl Time {
     /// Returns a `Time` value from a CSS `calc()` expression.
     pub fn from_calc(seconds: CSSFloat) -> Self {
         Time {
-            seconds: seconds,
+            seconds,
             unit: TimeUnit::Second,
             was_calc: true,
         }
@@ -95,11 +95,20 @@ impl Time {
                 Time::parse_dimension(value, unit, /* from_calc = */ false)
                     .map_err(|()| location.new_custom_error(StyleParseErrorKind::UnspecifiedError))
             },
-            Token::Function(ref name) if name.eq_ignore_ascii_case("calc") => {
-                match input.parse_nested_block(|i| CalcNode::parse_time(context, i)) {
-                    Ok(time) if clamping_mode.is_ok(ParsingMode::DEFAULT, time.seconds) => Ok(time),
-                    _ => Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)),
+            Token::Function(ref name) => {
+                let function = CalcNode::math_function(name, location)?;
+                let time = CalcNode::parse_time(context, input, function)?;
+
+                // FIXME(emilio): Rejecting calc() at parse time is wrong,
+                // was_calc should probably be replaced by calc_clamping_mode or
+                // something like we do for numbers, or we should do the
+                // clamping here instead (simpler, but technically incorrect,
+                // though still more correct than this!).
+                if !clamping_mode.is_ok(ParsingMode::DEFAULT, time.seconds) {
+                    return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
                 }
+
+                Ok(time)
             },
             ref t => return Err(location.new_unexpected_token_error(t.clone())),
         }

From 6fa03e1d04ce0e4ad5ba0776fdf02b8af28eb74e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Wed, 15 Jan 2020 19:43:08 +0000
Subject: [PATCH 21/66] style: Implement min() / max() / clamp() for simple css
 types behind a pref.

So for everything but <length> and <length-percentage>, which have more complex
mechanics.

The pref is off for now of course.

Differential Revision: https://phabricator.services.mozilla.com/D60012
---
 components/style/values/specified/calc.rs | 284 ++++++++++++----------
 1 file changed, 155 insertions(+), 129 deletions(-)

diff --git a/components/style/values/specified/calc.rs b/components/style/values/specified/calc.rs
index d951d0de08e..4fb3c009e04 100644
--- a/components/style/values/specified/calc.rs
+++ b/components/style/values/specified/calc.rs
@@ -20,9 +20,14 @@ use style_traits::{CssWriter, ParseError, SpecifiedValueInfo, StyleParseErrorKin
 /// The name of the mathematical function that we're parsing.
 #[derive(Debug, Copy, Clone)]
 pub enum MathFunction {
-    /// `calc()`
+    /// `calc()`: https://drafts.csswg.org/css-values-4/#funcdef-calc
     Calc,
-    // FIXME: min() / max() / clamp
+    /// `min()`: https://drafts.csswg.org/css-values-4/#funcdef-min
+    Min,
+    /// `max()`: https://drafts.csswg.org/css-values-4/#funcdef-max
+    Max,
+    /// `clamp()`: https://drafts.csswg.org/css-values-4/#funcdef-clamp
+    Clamp,
 }
 
 /// A node inside a `Calc` expression's AST.
@@ -46,6 +51,19 @@ pub enum CalcNode {
     Mul(Box<CalcNode>, Box<CalcNode>),
     /// An expression of the form `x / y`
     Div(Box<CalcNode>, Box<CalcNode>),
+    /// A `min()` function.
+    Min(Box<[CalcNode]>),
+    /// A `max()` function.
+    Max(Box<[CalcNode]>),
+    /// A `clamp()` function.
+    Clamp {
+        /// The minimum value.
+        min: Box<CalcNode>,
+        /// The central value.
+        center: Box<CalcNode>,
+        /// The maximum value.
+        max: Box<CalcNode>,
+    },
 }
 
 /// An expected unit we intend to parse within a `calc()` expression.
@@ -158,6 +176,80 @@ impl ToCss for CalcLengthPercentage {
 
 impl SpecifiedValueInfo for CalcLengthPercentage {}
 
+macro_rules! impl_generic_to_type {
+    ($self:ident, $self_variant:ident, $to_self:ident, $to_float:ident, $from_float:path) => {{
+        if let Self::$self_variant(ref v) = *$self {
+            return Ok(v.clone());
+        }
+
+        Ok(match *$self {
+            Self::Sub(ref a, ref b) => $from_float(a.$to_self()?.$to_float() - b.$to_self()?.$to_float()),
+            Self::Sum(ref a, ref b) => $from_float(a.$to_self()?.$to_float() + b.$to_self()?.$to_float()),
+            Self::Mul(ref a, ref b) => match a.$to_self() {
+                Ok(lhs) => {
+                    let rhs = b.to_number()?;
+                    $from_float(lhs.$to_float() * rhs)
+                },
+                Err(..) => {
+                    let lhs = a.to_number()?;
+                    let rhs = b.$to_self()?;
+                    $from_float(lhs * rhs.$to_float())
+                },
+            },
+            Self::Div(ref a, ref b) => {
+                let lhs = a.$to_self()?;
+                let rhs = b.to_number()?;
+                if rhs == 0. {
+                    return Err(());
+                }
+                $from_float(lhs.$to_float() / rhs)
+            },
+            Self::Clamp { ref min, ref center, ref max } => {
+                let min = min.$to_self()?;
+                let center = center.$to_self()?;
+                let max = max.$to_self()?;
+
+                // Equivalent to cmp::max(min, cmp::min(center, max))
+                //
+                // But preserving units when appropriate.
+                let mut result = center;
+                if result.$to_float() > max.$to_float() {
+                    result = max;
+                }
+                if result.$to_float() < min.$to_float() {
+                    result = min;
+                }
+                result
+            },
+            Self::Min(ref nodes) => {
+                let mut min = nodes[0].$to_self()?;
+                for node in nodes.iter().skip(1) {
+                    let candidate = node.$to_self()?;
+                    if candidate.$to_float() < min.$to_float() {
+                        min = candidate;
+                    }
+                }
+                min
+            },
+            Self::Max(ref nodes) => {
+                let mut max = nodes[0].$to_self()?;
+                for node in nodes.iter().skip(1) {
+                    let candidate = node.$to_self()?;
+                    if candidate.$to_float() > max.$to_float() {
+                        max = candidate;
+                    }
+                }
+                max
+            },
+            Self::Length(..) |
+            Self::Angle(..) |
+            Self::Time(..) |
+            Self::Percentage(..) |
+            Self::Number(..) => return Err(()),
+        })
+    }}
+}
+
 impl CalcNode {
     /// Tries to parse a single element in the expression, that is, a
     /// `<length>`, `<angle>`, `<time>`, `<percentage>`, according to
@@ -230,14 +322,45 @@ impl CalcNode {
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
-        _function: MathFunction,
+        function: MathFunction,
         expected_unit: CalcUnit,
     ) -> Result<Self, ParseError<'i>> {
         // TODO: Do something different based on the function name. In
         // particular, for non-calc function we need to take a list of
         // comma-separated arguments and such.
         input.parse_nested_block(|input| {
-            Self::parse_argument(context, input, expected_unit)
+            match function {
+                MathFunction::Calc => Self::parse_argument(context, input, expected_unit),
+                MathFunction::Clamp => {
+                    let min = Self::parse_argument(context, input, expected_unit)?;
+                    input.expect_comma()?;
+                    let center = Self::parse_argument(context, input, expected_unit)?;
+                    input.expect_comma()?;
+                    let max = Self::parse_argument(context, input, expected_unit)?;
+                    Ok(Self::Clamp {
+                        min: Box::new(min),
+                        center: Box::new(center),
+                        max: Box::new(max),
+                    })
+                },
+                MathFunction::Min |
+                MathFunction::Max => {
+                    // TODO(emilio): The common case for parse_comma_separated
+                    // is just one element, but for min / max is two, really...
+                    //
+                    // Consider adding an API to cssparser to specify the
+                    // initial vector capacity?
+                    let arguments = input.parse_comma_separated(|input| {
+                        Self::parse_argument(context, input, expected_unit)
+                    })?.into_boxed_slice();
+
+                    Ok(match function {
+                        MathFunction::Min => Self::Min(arguments),
+                        MathFunction::Max => Self::Max(arguments),
+                        _ => unreachable!(),
+                    })
+                }
+            }
         })
     }
 
@@ -328,45 +451,13 @@ impl CalcNode {
         clamping_mode: AllowedNumericType,
     ) -> Result<CalcLengthPercentage, ()> {
         let mut ret = CalcLengthPercentage {
-            clamping_mode: clamping_mode,
+            clamping_mode,
             ..Default::default()
         };
         self.add_length_or_percentage_to(&mut ret, 1.0)?;
         Ok(ret)
     }
 
-    /// Tries to simplify this expression into a `<percentage>` value.
-    fn to_percentage(&self) -> Result<CSSFloat, ()> {
-        Ok(match *self {
-            CalcNode::Percentage(percentage) => percentage,
-            CalcNode::Sub(ref a, ref b) => a.to_percentage()? - b.to_percentage()?,
-            CalcNode::Sum(ref a, ref b) => a.to_percentage()? + b.to_percentage()?,
-            CalcNode::Mul(ref a, ref b) => match a.to_percentage() {
-                Ok(lhs) => {
-                    let rhs = b.to_number()?;
-                    lhs * rhs
-                },
-                Err(..) => {
-                    let lhs = a.to_number()?;
-                    let rhs = b.to_percentage()?;
-                    lhs * rhs
-                },
-            },
-            CalcNode::Div(ref a, ref b) => {
-                let lhs = a.to_percentage()?;
-                let rhs = b.to_number()?;
-                if rhs == 0. {
-                    return Err(());
-                }
-                lhs / rhs
-            },
-            CalcNode::Number(..) |
-            CalcNode::Length(..) |
-            CalcNode::Angle(..) |
-            CalcNode::Time(..) => return Err(()),
-        })
-    }
-
     /// Puts this `<length>` or `<percentage>` into `ret`, or error.
     ///
     /// `factor` is the sign or multiplicative factor to account for the sign
@@ -443,6 +534,12 @@ impl CalcNode {
                 }
                 a.add_length_or_percentage_to(ret, factor / new_factor)?;
             },
+            CalcNode::Max(..) |
+            CalcNode::Min(..) |
+            CalcNode::Clamp { .. } => {
+                // FIXME(emilio): Implement min/max/clamp for length-percentage.
+                return Err(())
+            },
             CalcNode::Angle(..) | CalcNode::Time(..) | CalcNode::Number(..) => return Err(()),
         }
 
@@ -451,104 +548,22 @@ impl CalcNode {
 
     /// Tries to simplify this expression into a `<time>` value.
     fn to_time(&self) -> Result<Time, ()> {
-        Ok(match *self {
-            CalcNode::Time(ref time) => time.clone(),
-            CalcNode::Sub(ref a, ref b) => {
-                let lhs = a.to_time()?;
-                let rhs = b.to_time()?;
-                Time::from_calc(lhs.seconds() - rhs.seconds())
-            },
-            CalcNode::Sum(ref a, ref b) => {
-                let lhs = a.to_time()?;
-                let rhs = b.to_time()?;
-                Time::from_calc(lhs.seconds() + rhs.seconds())
-            },
-            CalcNode::Mul(ref a, ref b) => match b.to_number() {
-                Ok(rhs) => {
-                    let lhs = a.to_time()?;
-                    Time::from_calc(lhs.seconds() * rhs)
-                },
-                Err(()) => {
-                    let lhs = a.to_number()?;
-                    let rhs = b.to_time()?;
-                    Time::from_calc(lhs * rhs.seconds())
-                },
-            },
-            CalcNode::Div(ref a, ref b) => {
-                let lhs = a.to_time()?;
-                let rhs = b.to_number()?;
-                if rhs == 0. {
-                    return Err(());
-                }
-                Time::from_calc(lhs.seconds() / rhs)
-            },
-            CalcNode::Number(..) |
-            CalcNode::Length(..) |
-            CalcNode::Percentage(..) |
-            CalcNode::Angle(..) => return Err(()),
-        })
+        impl_generic_to_type!(self, Time, to_time, seconds, Time::from_calc)
     }
 
     /// Tries to simplify this expression into an `Angle` value.
     fn to_angle(&self) -> Result<Angle, ()> {
-        Ok(match *self {
-            CalcNode::Angle(ref angle) => angle.clone(),
-            CalcNode::Sub(ref a, ref b) => {
-                let lhs = a.to_angle()?;
-                let rhs = b.to_angle()?;
-                Angle::from_calc(lhs.degrees() - rhs.degrees())
-            },
-            CalcNode::Sum(ref a, ref b) => {
-                let lhs = a.to_angle()?;
-                let rhs = b.to_angle()?;
-                Angle::from_calc(lhs.degrees() + rhs.degrees())
-            },
-            CalcNode::Mul(ref a, ref b) => match a.to_angle() {
-                Ok(lhs) => {
-                    let rhs = b.to_number()?;
-                    Angle::from_calc(lhs.degrees() * rhs)
-                },
-                Err(..) => {
-                    let lhs = a.to_number()?;
-                    let rhs = b.to_angle()?;
-                    Angle::from_calc(lhs * rhs.degrees())
-                },
-            },
-            CalcNode::Div(ref a, ref b) => {
-                let lhs = a.to_angle()?;
-                let rhs = b.to_number()?;
-                if rhs == 0. {
-                    return Err(());
-                }
-                Angle::from_calc(lhs.degrees() / rhs)
-            },
-            CalcNode::Number(..) |
-            CalcNode::Length(..) |
-            CalcNode::Percentage(..) |
-            CalcNode::Time(..) => return Err(()),
-        })
+        impl_generic_to_type!(self, Angle, to_angle, degrees, Angle::from_calc)
     }
 
     /// Tries to simplify this expression into a `<number>` value.
     fn to_number(&self) -> Result<CSSFloat, ()> {
-        Ok(match *self {
-            CalcNode::Number(n) => n,
-            CalcNode::Sum(ref a, ref b) => a.to_number()? + b.to_number()?,
-            CalcNode::Sub(ref a, ref b) => a.to_number()? - b.to_number()?,
-            CalcNode::Mul(ref a, ref b) => a.to_number()? * b.to_number()?,
-            CalcNode::Div(ref a, ref b) => {
-                let lhs = a.to_number()?;
-                let rhs = b.to_number()?;
-                if rhs == 0. {
-                    return Err(());
-                }
-                lhs / rhs
-            },
-            CalcNode::Length(..) |
-            CalcNode::Percentage(..) |
-            CalcNode::Angle(..) |
-            CalcNode::Time(..) => return Err(()),
-        })
+        impl_generic_to_type!(self, Number, to_number, clone, From::from)
+    }
+
+    /// Tries to simplify this expression into a `<percentage>` value.
+    fn to_percentage(&self) -> Result<CSSFloat, ()> {
+        impl_generic_to_type!(self, Percentage, to_percentage, clone, From::from)
     }
 
     /// Given a function name, and the location from where the token came from,
@@ -558,10 +573,21 @@ impl CalcNode {
         name: &CowRcStr<'i>,
         location: cssparser::SourceLocation,
     ) -> Result<MathFunction, ParseError<'i>> {
-        if !name.eq_ignore_ascii_case("calc") {
+        // TODO(emilio): Unify below when the pref for math functions is gone.
+        if name.eq_ignore_ascii_case("calc") {
+            return Ok(MathFunction::Calc);
+        }
+
+        if !static_prefs::pref!("layout.css.comparison-functions.enabled") {
             return Err(location.new_unexpected_token_error(Token::Function(name.clone())));
         }
-        Ok(MathFunction::Calc)
+
+        Ok(match_ignore_ascii_case! { &*name,
+            "min" => MathFunction::Min,
+            "max" => MathFunction::Max,
+            "clamp" => MathFunction::Clamp,
+            _ => return Err(location.new_unexpected_token_error(Token::Function(name.clone()))),
+        })
     }
 
     /// Convenience parsing function for integers.

From 9817ca386ce5ca224cad42bd7f9a0c89981857bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Thu, 16 Jan 2020 05:41:16 +0000
Subject: [PATCH 22/66] style: Remove lazy_static usage from
 custom_properties.rs.

Differential Revision: https://phabricator.services.mozilla.com/D60039
---
 components/style/custom_properties.rs | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/components/style/custom_properties.rs b/components/style/custom_properties.rs
index 06d0e71cb8b..b7ef6cf21d0 100644
--- a/components/style/custom_properties.rs
+++ b/components/style/custom_properties.rs
@@ -62,14 +62,12 @@ fn get_safearea_inset_right(device: &Device) -> VariableValue {
     VariableValue::pixel(device.safe_area_insets().right)
 }
 
-lazy_static! {
-    static ref ENVIRONMENT_VARIABLES: [EnvironmentVariable; 4] = [
-        make_variable!(atom!("safe-area-inset-top"), get_safearea_inset_top),
-        make_variable!(atom!("safe-area-inset-bottom"), get_safearea_inset_bottom),
-        make_variable!(atom!("safe-area-inset-left"), get_safearea_inset_left),
-        make_variable!(atom!("safe-area-inset-right"), get_safearea_inset_right),
-    ];
-}
+static ENVIRONMENT_VARIABLES: [EnvironmentVariable; 4] = [
+    make_variable!(atom!("safe-area-inset-top"), get_safearea_inset_top),
+    make_variable!(atom!("safe-area-inset-bottom"), get_safearea_inset_bottom),
+    make_variable!(atom!("safe-area-inset-left"), get_safearea_inset_left),
+    make_variable!(atom!("safe-area-inset-right"), get_safearea_inset_right),
+];
 
 impl CssEnvironment {
     #[inline]

From 5043695c784ddf120aac7903f07081adf3cdc298 Mon Sep 17 00:00:00 2001
From: Ting-Yu Lin <tlin@mozilla.com>
Date: Thu, 16 Jan 2020 21:45:19 +0000
Subject: [PATCH 23/66] style: Remove moz-prefixed aliases for column-gap and
 CSS multi-column properties.

Introduce a new pref "layout.css.prefixes.columns" to guard the prefixed
aliases.

The modification to `properties-db.js` was generated by
`./mach devtools-css-db`.

Differential Revision: https://phabricator.services.mozilla.com/D59564
---
 .../style/properties/longhands/column.mako.rs      | 14 +++++++-------
 .../style/properties/longhands/position.mako.rs    |  2 +-
 .../style/properties/shorthands/column.mako.rs     |  5 +++--
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/components/style/properties/longhands/column.mako.rs b/components/style/properties/longhands/column.mako.rs
index b987990844d..1974e82d137 100644
--- a/components/style/properties/longhands/column.mako.rs
+++ b/components/style/properties/longhands/column.mako.rs
@@ -13,7 +13,7 @@ ${helpers.predefined_type(
     engines="gecko servo-2013 servo-2020",
     servo_2020_pref="layout.2020.unimplemented",
     initial_specified_value="specified::length::NonNegativeLengthOrAuto::auto()",
-    extra_prefixes="moz",
+    extra_prefixes="moz:layout.css.prefixes.columns",
     animation_value_type="NonNegativeLengthOrAuto",
     servo_2013_pref="layout.columns.enabled",
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-width",
@@ -29,7 +29,7 @@ ${helpers.predefined_type(
     initial_specified_value="specified::ColumnCount::auto()",
     servo_2013_pref="layout.columns.enabled",
     animation_value_type="AnimatedColumnCount",
-    extra_prefixes="moz",
+    extra_prefixes="moz:layout.css.prefixes.columns",
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-count",
     servo_restyle_damage="rebuild_and_reflow",
 )}
@@ -38,7 +38,7 @@ ${helpers.single_keyword(
     "column-fill",
     "balance auto",
     engines="gecko",
-    extra_prefixes="moz",
+    extra_prefixes="moz:layout.css.prefixes.columns",
     animation_value_type="discrete",
     gecko_enum_prefix="StyleColumnFill",
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-fill",
@@ -53,7 +53,7 @@ ${helpers.predefined_type(
     computed_type="crate::values::computed::NonNegativeLength",
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-rule-width",
     animation_value_type="NonNegativeLength",
-    extra_prefixes="moz",
+    extra_prefixes="moz:layout.css.prefixes.columns",
 )}
 
 // https://drafts.csswg.org/css-multicol-1/#crc
@@ -64,7 +64,7 @@ ${helpers.predefined_type(
     engines="gecko",
     initial_specified_value="specified::Color::currentcolor()",
     animation_value_type="AnimatedColor",
-    extra_prefixes="moz",
+    extra_prefixes="moz:layout.css.prefixes.columns",
     ignored_when_colors_disabled=True,
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-rule-color",
 )}
@@ -76,7 +76,7 @@ ${helpers.single_keyword(
     animation_value_type="discrete",
     gecko_enum_prefix="StyleColumnSpan",
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-span",
-    extra_prefixes="moz",
+    extra_prefixes="moz:layout.css.prefixes.columns",
 )}
 
 ${helpers.predefined_type(
@@ -86,7 +86,7 @@ ${helpers.predefined_type(
     engines="gecko",
     needs_context=False,
     initial_specified_value="specified::BorderStyle::None",
-    extra_prefixes="moz",
+    extra_prefixes="moz:layout.css.prefixes.columns",
     animation_value_type="discrete",
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-rule-style",
 )}
diff --git a/components/style/properties/longhands/position.mako.rs b/components/style/properties/longhands/position.mako.rs
index d974a0f5915..5e3cbf1324c 100644
--- a/components/style/properties/longhands/position.mako.rs
+++ b/components/style/properties/longhands/position.mako.rs
@@ -398,7 +398,7 @@ ${helpers.predefined_type(
     "computed::length::NonNegativeLengthPercentageOrNormal::normal()",
     engines="gecko servo-2013",
     alias="grid-column-gap" if engine == "gecko" else "",
-    extra_prefixes="moz",
+    extra_prefixes="moz:layout.css.prefixes.columns",
     servo_2013_pref="layout.columns.enabled",
     spec="https://drafts.csswg.org/css-align-3/#propdef-column-gap",
     animation_value_type="NonNegativeLengthPercentageOrNormal",
diff --git a/components/style/properties/shorthands/column.mako.rs b/components/style/properties/shorthands/column.mako.rs
index f9612fd6c0c..d5e385faa4c 100644
--- a/components/style/properties/shorthands/column.mako.rs
+++ b/components/style/properties/shorthands/column.mako.rs
@@ -9,7 +9,8 @@
                     sub_properties="column-width column-count"
                     servo_2013_pref="layout.columns.enabled",
                     derive_serialize="True"
-                    extra_prefixes="moz" spec="https://drafts.csswg.org/css-multicol/#propdef-columns">
+                    extra_prefixes="moz:layout.css.prefixes.columns"
+                    spec="https://drafts.csswg.org/css-multicol/#propdef-columns">
     use crate::properties::longhands::{column_count, column_width};
 
     pub fn parse_value<'i, 't>(
@@ -59,7 +60,7 @@
 <%helpers:shorthand
     name="column-rule"
     engines="gecko"
-    extra_prefixes="moz"
+    extra_prefixes="moz:layout.css.prefixes.columns"
     sub_properties="column-rule-width column-rule-style column-rule-color"
     derive_serialize="True"
     spec="https://drafts.csswg.org/css-multicol/#propdef-column-rule"

From 238e9ca2fb22641e123855de74a44f10ce4e2256 Mon Sep 17 00:00:00 2001
From: Boris Chiou <boris.chiou@gmail.com>
Date: Wed, 22 Jan 2020 20:18:31 +0000
Subject: [PATCH 24/66] style: Use Serde for rotate, scale, and translate
 properties.

The only drawback is: we resolve LengthPercentage value before passing
translate property through IPC, so its percentage part is redundant.
However, this makes us easier to maintain the Rust type.

Differential Revision: https://phabricator.services.mozilla.com/D60044
---
 components/style/values/generics/transform.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/components/style/values/generics/transform.rs b/components/style/values/generics/transform.rs
index 3322323e76e..d452b215c6a 100644
--- a/components/style/values/generics/transform.rs
+++ b/components/style/values/generics/transform.rs
@@ -611,8 +611,10 @@ pub fn get_normalized_vector_and_angle<T: Zero>(
     Clone,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedZero,
     ToComputedValue,
@@ -623,6 +625,7 @@ pub fn get_normalized_vector_and_angle<T: Zero>(
 /// A value of the `Rotate` property
 ///
 /// <https://drafts.csswg.org/css-transforms-2/#individual-transforms>
+/// cbindgen:private-default-tagged-enum-constructor=false
 pub enum GenericRotate<Number, Angle> {
     /// 'none'
     None,
@@ -685,8 +688,10 @@ where
     Clone,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedZero,
     ToComputedValue,
@@ -697,6 +702,7 @@ where
 /// A value of the `Scale` property
 ///
 /// <https://drafts.csswg.org/css-transforms-2/#individual-transforms>
+/// cbindgen:private-default-tagged-enum-constructor=false
 pub enum GenericScale<Number> {
     /// 'none'
     None,
@@ -749,8 +755,10 @@ fn y_axis_and_z_axis_are_zero<LengthPercentage: Zero, Length: Zero>(
 #[derive(
     Clone,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedZero,
     ToComputedValue,
@@ -772,6 +780,7 @@ fn y_axis_and_z_axis_are_zero<LengthPercentage: Zero, Length: Zero>(
 /// https://github.com/w3c/csswg-drafts/issues/3305
 ///
 /// <https://drafts.csswg.org/css-transforms-2/#individual-transforms>
+/// cbindgen:private-default-tagged-enum-constructor=false
 pub enum GenericTranslate<LengthPercentage, Length>
 where
     LengthPercentage: Zero,

From 5ac08e47808fd3237d5a352151b5393819634de5 Mon Sep 17 00:00:00 2001
From: Boris Chiou <boris.chiou@gmail.com>
Date: Wed, 22 Jan 2020 20:20:38 +0000
Subject: [PATCH 25/66] style: Use Serde for Transform.

Though this may make us use more space when serializing
StyleTransform, but we don't have to do extra conversion on the compostior
side, and this makes us easier to maintain the Rust type.

Differential Revision: https://phabricator.services.mozilla.com/D60045
---
 components/style/values/generics/transform.rs |  8 +++++++
 components/style_traits/owned_slice.rs        | 21 +++++++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/components/style/values/generics/transform.rs b/components/style/values/generics/transform.rs
index d452b215c6a..42a5197311f 100644
--- a/components/style/values/generics/transform.rs
+++ b/components/style/values/generics/transform.rs
@@ -23,8 +23,10 @@ use style_traits::{CssWriter, ToCss};
     Clone,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToComputedValue,
     ToCss,
@@ -51,8 +53,10 @@ pub use self::GenericMatrix as Matrix;
     Clone,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToComputedValue,
     ToCss,
@@ -141,8 +145,10 @@ fn is_same<N: PartialEq>(x: &N, y: &N) -> bool {
 #[derive(
     Clone,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToComputedValue,
     ToCss,
@@ -267,8 +273,10 @@ pub use self::GenericTransformOperation as TransformOperation;
 #[derive(
     Clone,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToComputedValue,
     ToCss,
diff --git a/components/style_traits/owned_slice.rs b/components/style_traits/owned_slice.rs
index 33d3ac1c2ab..bbce7065196 100644
--- a/components/style_traits/owned_slice.rs
+++ b/components/style_traits/owned_slice.rs
@@ -7,6 +7,8 @@
 //! A replacement for `Box<[T]>` that cbindgen can understand.
 
 use malloc_size_of::{MallocShallowSizeOf, MallocSizeOf, MallocSizeOfOps};
+use serde::de::{Deserialize, Deserializer};
+use serde::ser::{Serialize, Serializer};
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 use std::ptr::NonNull;
@@ -171,3 +173,22 @@ impl<T> iter::FromIterator<T> for OwnedSlice<T> {
         Vec::from_iter(iter).into()
     }
 }
+
+impl<T: Serialize> Serialize for OwnedSlice<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.deref().serialize(serializer)
+    }
+}
+
+impl<'de, T: Deserialize<'de>> Deserialize<'de> for OwnedSlice<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let r = Box::<[T]>::deserialize(deserializer)?;
+        Ok(r.into())
+    }
+}

From 2b3ef3ff371fb0d8631b7af213de48ea27ddc90a Mon Sep 17 00:00:00 2001
From: Boris Chiou <boris.chiou@gmail.com>
Date: Wed, 22 Jan 2020 20:18:35 +0000
Subject: [PATCH 26/66] style: Use Serde for SVGOffsetPath.

Differential Revision: https://phabricator.services.mozilla.com/D60087
---
 components/style/values/generics/motion.rs    |  3 +++
 components/style/values/specified/svg_path.rs | 12 ++++++++++-
 components/style_traits/arc_slice.rs          | 21 +++++++++++++++++++
 3 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/components/style/values/generics/motion.rs b/components/style/values/generics/motion.rs
index 685eaad43e2..25ba5873adc 100644
--- a/components/style/values/generics/motion.rs
+++ b/components/style/values/generics/motion.rs
@@ -73,13 +73,16 @@ pub struct RayFunction<Angle> {
 /// The offset-path value.
 ///
 /// https://drafts.fxtf.org/motion-1/#offset-path-property
+/// cbindgen:private-default-tagged-enum-constructor=false
 #[derive(
     Animate,
     Clone,
     ComputeSquaredDistance,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedZero,
     ToComputedValue,
diff --git a/components/style/values/specified/svg_path.rs b/components/style/values/specified/svg_path.rs
index 9a94af6a82f..b5461bb37fc 100644
--- a/components/style/values/specified/svg_path.rs
+++ b/components/style/values/specified/svg_path.rs
@@ -21,8 +21,10 @@ use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
 #[derive(
     Clone,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedZero,
     ToComputedValue,
@@ -156,8 +158,10 @@ impl ComputeSquaredDistance for SVGPathData {
     ComputeSquaredDistance,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedZero,
     ToShmem,
@@ -483,8 +487,10 @@ impl ToCss for PathCommand {
     ComputeSquaredDistance,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedZero,
     ToShmem,
@@ -511,8 +517,10 @@ impl IsAbsolute {
     ComputeSquaredDistance,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedZero,
     ToCss,
@@ -530,7 +538,9 @@ impl CoordPair {
 }
 
 /// The EllipticalArc flag type.
-#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToShmem)]
+#[derive(
+    Clone, Copy, Debug, Deserialize, MallocSizeOf, PartialEq, Serialize, SpecifiedValueInfo, ToShmem,
+)]
 #[repr(C)]
 pub struct ArcFlag(bool);
 
diff --git a/components/style_traits/arc_slice.rs b/components/style_traits/arc_slice.rs
index bbbac1a0757..f5d0c56e7fc 100644
--- a/components/style_traits/arc_slice.rs
+++ b/components/style_traits/arc_slice.rs
@@ -4,6 +4,8 @@
 
 //! A thin atomically-reference-counted slice.
 
+use serde::de::{Deserialize, Deserializer};
+use serde::ser::{Serialize, Serializer};
 use servo_arc::ThinArc;
 use std::ops::Deref;
 use std::ptr::NonNull;
@@ -60,6 +62,25 @@ impl<T> Default for ArcSlice<T> {
     }
 }
 
+impl<T: Serialize> Serialize for ArcSlice<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.deref().serialize(serializer)
+    }
+}
+
+impl<'de, T: Deserialize<'de>> Deserialize<'de> for ArcSlice<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let r = Vec::deserialize(deserializer)?;
+        Ok(ArcSlice::from_iter(r.into_iter()))
+    }
+}
+
 impl<T> ArcSlice<T> {
     /// Creates an Arc for a slice using the given iterator to generate the
     /// slice.

From 83daa7484dcd42441480014f8bd32108b9ff9063 Mon Sep 17 00:00:00 2001
From: Boris Chiou <boris.chiou@gmail.com>
Date: Wed, 22 Jan 2020 20:18:38 +0000
Subject: [PATCH 27/66] style: Use Serde for OffsetRotate and PositionOrAuto.

Differential Revision: https://phabricator.services.mozilla.com/D60088
---
 components/style/values/computed/motion.rs   | 2 ++
 components/style/values/generics/position.rs | 5 +++++
 2 files changed, 7 insertions(+)

diff --git a/components/style/values/computed/motion.rs b/components/style/values/computed/motion.rs
index 88a5b7c7280..e2565ff3468 100644
--- a/components/style/values/computed/motion.rs
+++ b/components/style/values/computed/motion.rs
@@ -23,8 +23,10 @@ fn is_auto_zero_angle(auto: &bool, angle: &Angle) -> bool {
     ComputeSquaredDistance,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     ToAnimatedZero,
     ToCss,
     ToResolvedValue,
diff --git a/components/style/values/generics/position.rs b/components/style/values/generics/position.rs
index 2742dd87913..a3552ea3eab 100644
--- a/components/style/values/generics/position.rs
+++ b/components/style/values/generics/position.rs
@@ -12,8 +12,10 @@
     ComputeSquaredDistance,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedValue,
     ToAnimatedZero,
@@ -44,15 +46,18 @@ impl<H, V> Position<H, V> {
 /// A generic type for representing an `Auto | <position>`.
 /// This is used by <offset-anchor> for now.
 /// https://drafts.fxtf.org/motion-1/#offset-anchor-property
+/// cbindgen:private-default-tagged-enum-constructor=false
 #[derive(
     Animate,
     Clone,
     ComputeSquaredDistance,
     Copy,
     Debug,
+    Deserialize,
     MallocSizeOf,
     Parse,
     PartialEq,
+    Serialize,
     SpecifiedValueInfo,
     ToAnimatedZero,
     ToComputedValue,

From e7e6e62ed36a5aa9798e9a12e5b4212736db25bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Wed, 22 Jan 2020 23:46:24 +0000
Subject: [PATCH 28/66] style: Remove font-size calc() hack to propagate
 keyword information.

It does not make any sense with min() / max() / clamp. So just forget the
keyword info when calc() is used. This also removes a bit of complex / hacky
code.

Differential Revision: https://phabricator.services.mozilla.com/D60663
---
 components/style/gecko/wrapper.rs           |  5 +--
 components/style/values/specified/font.rs   | 42 ++-------------------
 components/style/values/specified/length.rs | 12 +-----
 3 files changed, 8 insertions(+), 51 deletions(-)

diff --git a/components/style/gecko/wrapper.rs b/components/style/gecko/wrapper.rs
index 9a1196a11b5..ba1c724d58f 100644
--- a/components/style/gecko/wrapper.rs
+++ b/components/style/gecko/wrapper.rs
@@ -956,9 +956,8 @@ impl FontMetricsProvider for GeckoFontMetricsProvider {
 
         let (wm, font) = match base_size {
             FontBaseSize::CurrentStyle => (style.writing_mode, style.get_font()),
-            // These are only used for font-size computation, and the first is
-            // really dubious...
-            FontBaseSize::InheritedStyleButStripEmUnits | FontBaseSize::InheritedStyle => {
+            // This is only used for font-size computation.
+            FontBaseSize::InheritedStyle => {
                 (*style.inherited_writing_mode(), style.get_parent_font())
             },
         };
diff --git a/components/style/values/specified/font.rs b/components/style/values/specified/font.rs
index 05a29c94087..86a00ef97df 100644
--- a/components/style/values/specified/font.rs
+++ b/components/style/values/specified/font.rs
@@ -574,11 +574,11 @@ impl KeywordInfo {
 
     /// Given a parent keyword info (self), apply an additional factor/offset to
     /// it.
-    pub fn compose(self, factor: f32, offset: CSSPixelLength) -> Self {
+    fn compose(self, factor: f32) -> Self {
         KeywordInfo {
             kw: self.kw,
             factor: self.factor * factor,
-            offset: self.offset * factor + offset,
+            offset: self.offset * factor,
         }
     }
 }
@@ -901,7 +901,7 @@ impl FontSize {
                 .get_parent_font()
                 .clone_font_size()
                 .keyword_info
-                .map(|i| i.compose(factor, CSSPixelLength::new(0.)))
+                .map(|i| i.compose(factor))
         };
         let mut info = None;
         let size = match *self {
@@ -927,42 +927,8 @@ impl FontSize {
                 base_size.resolve(context) * pc.0
             },
             FontSize::Length(LengthPercentage::Calc(ref calc)) => {
-                let parent = context.style().get_parent_font().clone_font_size();
-                // if we contain em/% units and the parent was keyword derived, this is too
-                // Extract the ratio/offset and compose it
-                if (calc.em.is_some() || calc.percentage.is_some()) && parent.keyword_info.is_some()
-                {
-                    let ratio = calc.em.unwrap_or(0.) + calc.percentage.map_or(0., |pc| pc.0);
-                    // Compute it, but shave off the font-relative part (em, %).
-                    //
-                    // This will mean that other font-relative units like ex and
-                    // ch will be computed against the old parent font even when
-                    // the font changes.
-                    //
-                    // There's no particular "right answer" for what to do here,
-                    // Gecko recascades as if the font had changed, we instead
-                    // track the changes and reapply, which means that we carry
-                    // over old computed ex/ch values whilst Gecko recomputes
-                    // new ones.
-                    //
-                    // This is enough of an edge case to not really matter.
-                    let abs = calc
-                        .to_computed_value_zoomed(
-                            context,
-                            FontBaseSize::InheritedStyleButStripEmUnits,
-                        )
-                        .unclamped_length();
-
-                    info = parent.keyword_info.map(|i| i.compose(ratio, abs));
-                }
                 let calc = calc.to_computed_value_zoomed(context, base_size);
-                // FIXME(emilio): we _could_ use clamp_to_non_negative()
-                // everywhere, without affecting behavior in theory, since the
-                // others should reject negatives during parsing. But SMIL
-                // allows parsing negatives, and relies on us _not_ doing that
-                // clamping. That's so bonkers :(
-                calc.percentage_relative_to(base_size.resolve(context))
-                    .clamp_to_non_negative()
+                calc.resolve(base_size.resolve(context))
             },
             FontSize::Keyword(i) => {
                 // As a specified keyword, this is keyword derived
diff --git a/components/style/values/specified/length.rs b/components/style/values/specified/length.rs
index 1ef76054382..3ac1f0a9762 100644
--- a/components/style/values/specified/length.rs
+++ b/components/style/values/specified/length.rs
@@ -71,10 +71,6 @@ pub enum FontBaseSize {
     CurrentStyle,
     /// Use the inherited font-size.
     InheritedStyle,
-    /// Use the inherited font-size, but strip em units.
-    ///
-    /// FIXME(emilio): This is very complex, and should go away.
-    InheritedStyleButStripEmUnits,
 }
 
 impl FontBaseSize {
@@ -82,7 +78,7 @@ impl FontBaseSize {
     pub fn resolve(&self, context: &Context) -> computed::Length {
         match *self {
             FontBaseSize::CurrentStyle => context.style().get_font().clone_font_size().size(),
-            FontBaseSize::InheritedStyleButStripEmUnits | FontBaseSize::InheritedStyle => {
+            FontBaseSize::InheritedStyle => {
                 context.style().get_parent_font().clone_font_size().size()
             },
         }
@@ -144,11 +140,7 @@ impl FontRelativeLength {
                     }
                 }
 
-                if base_size == FontBaseSize::InheritedStyleButStripEmUnits {
-                    (Zero::zero(), length)
-                } else {
-                    (reference_font_size, length)
-                }
+                (reference_font_size, length)
             },
             FontRelativeLength::Ex(length) => {
                 if context.for_non_inherited_property.is_some() {

From 5237d4fac8a81ec682a1f1121a77295ff354755a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Thu, 23 Jan 2020 09:18:39 +0000
Subject: [PATCH 29/66] style: Forbid accessing the length and percentage parts
 of a LengthPercentage separately.

This is just not a thing you can do if you have min() / max() / etc, as the min
/ max value may depend on the percentage basis.

Differential Revision: https://phabricator.services.mozilla.com/D60168
---
 components/style/values/animated/transform.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/components/style/values/animated/transform.rs b/components/style/values/animated/transform.rs
index 3d93ae93f6d..621ae60084d 100644
--- a/components/style/values/animated/transform.rs
+++ b/components/style/values/animated/transform.rs
@@ -1168,10 +1168,11 @@ impl ComputeSquaredDistance for ComputedTransformOperation {
                 // However, dropping percentage makes us impossible to compute
                 // the distance for the percentage-percentage case, but Gecko
                 // uses the same formula, so it's fine for now.
-                let fx = fx.length_component().px();
-                let fy = fy.length_component().px();
-                let tx = tx.length_component().px();
-                let ty = ty.length_component().px();
+                let basis = Length::new(0.);
+                let fx = fx.resolve(basis).px();
+                let fy = fy.resolve(basis).px();
+                let tx = tx.resolve(basis).px();
+                let ty = ty.resolve(basis).px();
 
                 Ok(fx.compute_squared_distance(&tx)? +
                     fy.compute_squared_distance(&ty)? +

From 16e5331950ab8bbea5bf01c0a3298a9b1f71a1f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Thu, 23 Jan 2020 09:18:39 +0000
Subject: [PATCH 30/66] style: Simplify calc expressions earlier.

This simplifies a bit the code, and guarantees that all calc()s have percentages
and lengths.

I also wanted to remove unclamped_length() / specified_percentage() (for the
same reason as the above patch), but they're needed for animations for now. When
I implement min() / max() for <length-percentage> they'll be fixed.

Differential Revision: https://phabricator.services.mozilla.com/D60194
---
 components/style/values/animated/length.rs    |   7 +-
 components/style/values/computed/length.rs    |   2 +-
 .../values/computed/length_percentage.rs      | 185 ++++++------------
 components/style/values/generics/transform.rs |   2 +-
 components/style/values/specified/font.rs     |   6 -
 components/style/values/specified/position.rs |   3 +-
 components/style/values/specified/text.rs     |   2 +-
 7 files changed, 67 insertions(+), 140 deletions(-)

diff --git a/components/style/values/animated/length.rs b/components/style/values/animated/length.rs
index 837b3ee86c3..09724362441 100644
--- a/components/style/values/animated/length.rs
+++ b/components/style/values/animated/length.rs
@@ -7,6 +7,7 @@
 use super::{Animate, Procedure};
 use crate::values::computed::length::LengthPercentage;
 use crate::values::computed::Percentage;
+use style_traits::values::specified::AllowedNumericType;
 
 /// <https://drafts.csswg.org/css-transitions/#animtype-lpcalc>
 impl Animate for LengthPercentage {
@@ -27,8 +28,8 @@ impl Animate for LengthPercentage {
         let percentage =
             animate_percentage_half(self.specified_percentage(), other.specified_percentage())?;
 
-        // Gets clamped as needed after the animation, so no need to specify any
-        // particular AllowedNumericType.
-        Ok(LengthPercentage::new_calc(length, percentage))
+        // Gets clamped as needed after the animation if needed, so no need to
+        // specify any particular AllowedNumericType.
+        Ok(LengthPercentage::new_calc(length, percentage, AllowedNumericType::All))
     }
 }
diff --git a/components/style/values/computed/length.rs b/components/style/values/computed/length.rs
index d90e4e543b7..0c59b640558 100644
--- a/components/style/values/computed/length.rs
+++ b/components/style/values/computed/length.rs
@@ -57,7 +57,7 @@ impl ToComputedValue for specified::Length {
     fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
         match *self {
             specified::Length::NoCalc(l) => l.to_computed_value(context),
-            specified::Length::Calc(ref calc) => calc.to_computed_value(context).length_component(),
+            specified::Length::Calc(ref calc) => calc.to_computed_value(context).to_length().unwrap(),
         }
     }
 
diff --git a/components/style/values/computed/length_percentage.rs b/components/style/values/computed/length_percentage.rs
index bf489197b5a..f6537c3ecef 100644
--- a/components/style/values/computed/length_percentage.rs
+++ b/components/style/values/computed/length_percentage.rs
@@ -205,8 +205,23 @@ impl LengthPercentage {
 
     /// Constructs a `calc()` value.
     #[inline]
-    pub fn new_calc(l: Length, percentage: Option<Percentage>) -> Self {
-        CalcLengthPercentage::new(l, percentage).to_length_percentge()
+    pub fn new_calc(
+        length: Length,
+        percentage: Option<Percentage>,
+        clamping_mode: AllowedNumericType,
+    ) -> Self {
+        let percentage = match percentage {
+            Some(p) => p,
+            None => return Self::new_length(Length::new(clamping_mode.clamp(length.px()))),
+        };
+        if length.is_zero() {
+            return Self::new_percent(Percentage(clamping_mode.clamp(percentage.0)))
+        }
+        Self::new_calc_unchecked(Box::new(CalcLengthPercentage {
+            length,
+            percentage,
+            clamping_mode,
+        }))
     }
 
     /// Private version of new_calc() that constructs a calc() variant without
@@ -269,7 +284,10 @@ impl LengthPercentage {
         match self.unpack() {
             Unpacked::Length(l) => l.px() == 0.0,
             Unpacked::Percentage(p) => p.0 == 0.0,
-            Unpacked::Calc(ref c) => c.is_definitely_zero(),
+            Unpacked::Calc(ref c) => {
+                debug_assert_ne!(c.length.px(), 0.0, "Should've been simplified to a percentage");
+                false
+            },
         }
     }
 
@@ -316,16 +334,6 @@ impl LengthPercentage {
         }
     }
 
-    /// Returns the `<length>` component of this `calc()`, clamped.
-    #[inline]
-    pub fn as_percentage(&self) -> Option<Percentage> {
-        match self.unpack() {
-            Unpacked::Length(..) => None,
-            Unpacked::Percentage(p) => Some(p),
-            Unpacked::Calc(ref c) => c.as_percentage(),
-        }
-    }
-
     /// Resolves the percentage.
     #[inline]
     pub fn resolve(&self, basis: Length) -> Length {
@@ -347,8 +355,18 @@ impl LengthPercentage {
     pub fn has_percentage(&self) -> bool {
         match self.unpack() {
             Unpacked::Length(..) => false,
-            Unpacked::Percentage(..) => true,
-            Unpacked::Calc(ref c) => c.has_percentage,
+            Unpacked::Percentage(..) | Unpacked::Calc(..) => true,
+        }
+    }
+
+    /// Converts to a `<length>` if possible.
+    pub fn to_length(&self) -> Option<Length> {
+        match self.unpack() {
+            Unpacked::Length(l) => Some(l),
+            Unpacked::Percentage(..) | Unpacked::Calc(..) => {
+                debug_assert!(self.has_percentage());
+                return None;
+            }
         }
     }
 
@@ -358,7 +376,10 @@ impl LengthPercentage {
         match self.unpack() {
             Unpacked::Length(..) => None,
             Unpacked::Percentage(p) => Some(p),
-            Unpacked::Calc(ref c) => c.specified_percentage(),
+            Unpacked::Calc(ref c) => {
+                debug_assert!(self.has_percentage());
+                Some(c.percentage)
+            }
         }
     }
 
@@ -396,7 +417,7 @@ impl LengthPercentage {
         match self.unpack() {
             Unpacked::Length(l) => Self::new_length(l.clamp_to_non_negative()),
             Unpacked::Percentage(p) => Self::new_percent(p.clamp_to_non_negative()),
-            Unpacked::Calc(c) => c.clamp_to_non_negative().to_length_percentge(),
+            Unpacked::Calc(c) => c.clamp_to_non_negative(),
         }
     }
 }
@@ -445,7 +466,7 @@ impl ToComputedValue for specified::LengthPercentage {
                 LengthPercentage::new_percent(value)
             },
             specified::LengthPercentage::Calc(ref calc) => {
-                (**calc).to_computed_value(context).to_length_percentge()
+                (**calc).to_computed_value(context)
             },
         }
     }
@@ -459,12 +480,8 @@ impl ToComputedValue for specified::LengthPercentage {
                 specified::LengthPercentage::Percentage(p)
             }
             Unpacked::Calc(c) => {
-                if let Some(p) = c.as_percentage() {
-                    return specified::LengthPercentage::Percentage(p)
-                }
-                if !c.has_percentage {
-                    return specified::LengthPercentage::Length(ToComputedValue::from_computed_value(&c.length_component()))
-                }
+                // We simplify before constructing the LengthPercentage if
+                // needed, so this is always fine.
                 specified::LengthPercentage::Calc(Box::new(specified::CalcLengthPercentage::from_computed_value(c)))
             }
         }
@@ -474,13 +491,12 @@ impl ToComputedValue for specified::LengthPercentage {
 impl ComputeSquaredDistance for LengthPercentage {
     #[inline]
     fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> {
-        // FIXME(nox): This looks incorrect to me, to add a distance between lengths
-        // with a distance between percentages.
-        Ok(self
-            .unclamped_length()
-            .compute_squared_distance(&other.unclamped_length())? +
-            self.percentage()
-                .compute_squared_distance(&other.percentage())?)
+        // A somewhat arbitrary base, it doesn't really make sense to mix
+        // lengths with percentages, but we can't do much better here, and this
+        // ensures that the distance between length-only and percentage-only
+        // lengths makes sense.
+        let basis = Length::new(100.);
+        self.resolve(basis).compute_squared_distance(&other.resolve(basis))
     }
 }
 
@@ -522,7 +538,7 @@ impl<'de> Deserialize<'de> for LengthPercentage {
     }
 }
 
-/// The representation of a calc() function.
+/// The representation of a calc() function with mixed lengths and percentages.
 #[derive(
     Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue,
 )]
@@ -534,70 +550,15 @@ pub struct CalcLengthPercentage {
 
     #[animation(constant)]
     clamping_mode: AllowedNumericType,
-
-    /// Whether we specified a percentage or not.
-    #[animation(constant)]
-    pub has_percentage: bool,
 }
 
 impl CalcLengthPercentage {
-    /// Returns a new `LengthPercentage`.
-    #[inline]
-    pub fn new(length: Length, percentage: Option<Percentage>) -> Self {
-        Self::with_clamping_mode(length, percentage, AllowedNumericType::All)
-    }
-
-    /// Converts this to a `LengthPercentage`, simplifying if possible.
-    #[inline]
-    pub fn to_length_percentge(self) -> LengthPercentage {
-        if !self.has_percentage {
-            return LengthPercentage::new_length(self.length_component())
-        }
-        if self.length.is_zero() {
-            return LengthPercentage::new_percent(Percentage(self.clamping_mode.clamp(self.percentage.0)));
-        }
-        LengthPercentage::new_calc_unchecked(Box::new(self))
-    }
-
-    fn specified_percentage(&self) -> Option<Percentage> {
-        if self.has_percentage {
-            Some(self.percentage)
-        } else {
-            None
-        }
-    }
-
-    /// Returns a new `LengthPercentage` with a specific clamping mode.
-    #[inline]
-    fn with_clamping_mode(
-        length: Length,
-        percentage: Option<Percentage>,
-        clamping_mode: AllowedNumericType,
-    ) -> Self {
-        Self {
-            clamping_mode,
-            length,
-            percentage: percentage.unwrap_or_default(),
-            has_percentage: percentage.is_some(),
-        }
-    }
-
     /// Returns the length component of this `calc()`, clamped.
     #[inline]
-    pub fn length_component(&self) -> Length {
+    fn length_component(&self) -> Length {
         Length::new(self.clamping_mode.clamp(self.length.px()))
     }
 
-    /// Returns the percentage component if this could be represented as a
-    /// non-calc percentage.
-    fn as_percentage(&self) -> Option<Percentage> {
-        if !self.has_percentage || self.length.px() != 0. {
-            return None;
-        }
-
-        Some(Percentage(self.clamping_mode.clamp(self.percentage.0)))
-    }
-
     /// Resolves the percentage.
     #[inline]
     pub fn resolve(&self, basis: Length) -> Length {
@@ -605,44 +566,16 @@ impl CalcLengthPercentage {
         Length::new(self.clamping_mode.clamp(length))
     }
 
-    /// Resolves the percentage.
-    #[inline]
-    pub fn percentage_relative_to(&self, basis: Length) -> Length {
-        self.resolve(basis)
-    }
-
     /// Returns the length, without clamping.
     #[inline]
-    pub fn unclamped_length(&self) -> Length {
+    fn unclamped_length(&self) -> Length {
         self.length
     }
 
-    /// Returns true if the computed value is absolute 0 or 0%.
-    #[inline]
-    fn is_definitely_zero(&self) -> bool {
-        self.length.px() == 0.0 && self.percentage.0 == 0.0
-    }
-
     /// Returns the clamped non-negative values.
     #[inline]
-    fn clamp_to_non_negative(&self) -> Self {
-        if self.has_percentage {
-            // If we can eagerly clamp the percentage then just do that.
-            if self.length.is_zero() {
-                return Self::with_clamping_mode(
-                    Length::zero(),
-                    Some(self.percentage.clamp_to_non_negative()),
-                    AllowedNumericType::NonNegative,
-                );
-            }
-            return Self::with_clamping_mode(self.length, Some(self.percentage), AllowedNumericType::NonNegative);
-        }
-
-        Self::with_clamping_mode(
-            self.length.clamp_to_non_negative(),
-            None,
-            AllowedNumericType::NonNegative,
-        )
+    fn clamp_to_non_negative(&self) -> LengthPercentage {
+        LengthPercentage::new_calc(self.length, Some(self.percentage), AllowedNumericType::NonNegative)
     }
 }
 
@@ -660,9 +593,7 @@ impl CalcLengthPercentage {
 // maybe.
 impl PartialEq for CalcLengthPercentage {
     fn eq(&self, other: &Self) -> bool {
-        self.length == other.length &&
-            self.percentage == other.percentage &&
-            self.has_percentage == other.has_percentage
+        self.length == other.length && self.percentage == other.percentage
     }
 }
 
@@ -673,7 +604,7 @@ impl specified::CalcLengthPercentage {
         context: &Context,
         zoom_fn: F,
         base_size: FontBaseSize,
-    ) -> CalcLengthPercentage
+    ) -> LengthPercentage
     where
         F: Fn(Length) -> Length,
     {
@@ -709,7 +640,7 @@ impl specified::CalcLengthPercentage {
             }
         }
 
-        CalcLengthPercentage::with_clamping_mode(
+        LengthPercentage::new_calc(
             Length::new(length.min(f32::MAX).max(f32::MIN)),
             self.percentage,
             self.clamping_mode,
@@ -721,7 +652,7 @@ impl specified::CalcLengthPercentage {
         &self,
         context: &Context,
         base_size: FontBaseSize,
-    ) -> CalcLengthPercentage {
+    ) -> LengthPercentage {
         self.to_computed_value_with_zoom(
             context,
             |abs| context.maybe_zoom_text(abs.into()),
@@ -755,7 +686,7 @@ impl specified::CalcLengthPercentage {
     }
 
     /// Compute the calc using the current font-size (and without text-zoom).
-    pub fn to_computed_value(&self, context: &Context) -> CalcLengthPercentage {
+    pub fn to_computed_value(&self, context: &Context) -> LengthPercentage {
         self.to_computed_value_with_zoom(context, |abs| abs, FontBaseSize::CurrentStyle)
     }
 
@@ -766,7 +697,7 @@ impl specified::CalcLengthPercentage {
         specified::CalcLengthPercentage {
             clamping_mode: computed.clamping_mode,
             absolute: Some(AbsoluteLength::from_computed_value(&computed.length)),
-            percentage: computed.specified_percentage(),
+            percentage: Some(computed.percentage),
             ..Default::default()
         }
     }
diff --git a/components/style/values/generics/transform.rs b/components/style/values/generics/transform.rs
index 42a5197311f..6583f9ebe10 100644
--- a/components/style/values/generics/transform.rs
+++ b/components/style/values/generics/transform.rs
@@ -377,7 +377,7 @@ impl ToAbsoluteLength for ComputedLengthPercentage {
             // distance without any layout info.
             //
             // FIXME(emilio): This looks wrong.
-            None => Ok(self.length_component().px()),
+            None => Ok(self.resolve(Zero::zero()).px()),
         }
     }
 }
diff --git a/components/style/values/specified/font.rs b/components/style/values/specified/font.rs
index 86a00ef97df..84c5141ed92 100644
--- a/components/style/values/specified/font.rs
+++ b/components/style/values/specified/font.rs
@@ -614,12 +614,6 @@ pub enum FontSize {
     System(SystemFont),
 }
 
-impl From<LengthPercentage> for FontSize {
-    fn from(other: LengthPercentage) -> Self {
-        FontSize::Length(other)
-    }
-}
-
 /// Specifies a prioritized list of font family names or generic family names.
 #[derive(Clone, Debug, Eq, PartialEq, ToCss, ToShmem)]
 #[cfg_attr(feature = "servo", derive(Hash))]
diff --git a/components/style/values/specified/position.rs b/components/style/values/specified/position.rs
index 57a6715b0a6..d599d6a85d9 100644
--- a/components/style/values/specified/position.rs
+++ b/components/style/values/specified/position.rs
@@ -23,6 +23,7 @@ use selectors::parser::SelectorParseErrorKind;
 use servo_arc::Arc;
 use std::fmt::{self, Write};
 use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
+use style_traits::values::specified::AllowedNumericType;
 
 /// The specified value of a CSS `<position>`
 pub type Position = GenericPosition<HorizontalPosition, VerticalPosition>;
@@ -297,7 +298,7 @@ impl<S: Side> ToComputedValue for PositionComponent<S> {
                 let p = Percentage(1. - length.percentage());
                 let l = -length.unclamped_length();
                 // We represent `<end-side> <length>` as `calc(100% - <length>)`.
-                ComputedLengthPercentage::new_calc(l, Some(p))
+                ComputedLengthPercentage::new_calc(l, Some(p), AllowedNumericType::All)
             },
             PositionComponent::Side(_, Some(ref length)) |
             PositionComponent::Length(ref length) => length.to_computed_value(context),
diff --git a/components/style/values/specified/text.rs b/components/style/values/specified/text.rs
index 8c50a61ef94..b1f5e1f5c3e 100644
--- a/components/style/values/specified/text.rs
+++ b/components/style/values/specified/text.rs
@@ -97,7 +97,7 @@ impl ToComputedValue for LineHeight {
                         let computed_calc =
                             calc.to_computed_value_zoomed(context, FontBaseSize::CurrentStyle);
                         let base = context.style().get_font().clone_font_size().size();
-                        computed_calc.percentage_relative_to(base)
+                        computed_calc.resolve(base)
                     },
                 };
                 GenericLineHeight::Length(result.into())

From 55f76be5e2be1c775dc1d2f96a2c83d2c780d7b1 Mon Sep 17 00:00:00 2001
From: Martin McNickle <mmcnickle@gmail.com>
Date: Thu, 23 Jan 2020 17:19:27 +0000
Subject: [PATCH 31/66] style: Convert stroke-linejoin #defines to an enum
 class.

Differential Revision: https://phabricator.services.mozilla.com/D60865
---
 components/style/properties/longhands/inherited_svg.mako.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/style/properties/longhands/inherited_svg.mako.rs b/components/style/properties/longhands/inherited_svg.mako.rs
index 1d75df08bd8..7cb4e4f1da0 100644
--- a/components/style/properties/longhands/inherited_svg.mako.rs
+++ b/components/style/properties/longhands/inherited_svg.mako.rs
@@ -118,6 +118,7 @@ ${helpers.single_keyword(
     engines="gecko",
     animation_value_type="discrete",
     spec="https://www.w3.org/TR/SVG11/painting.html#StrokeLinejoinProperty",
+    gecko_enum_prefix = "StyleStrokeLinejoin",
 )}
 
 ${helpers.predefined_type(

From 3991ab9999111cba58cdcc0ee43daf49da1e22d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Fri, 24 Jan 2020 11:46:14 +0000
Subject: [PATCH 32/66] style: Make direction use an enum class.

Differential Revision: https://phabricator.services.mozilla.com/D60857
---
 components/style/properties/helpers.mako.rs                 | 3 ++-
 components/style/properties/longhands/inherited_box.mako.rs | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/components/style/properties/helpers.mako.rs b/components/style/properties/helpers.mako.rs
index 4d3895440d5..7a25b2569ea 100644
--- a/components/style/properties/helpers.mako.rs
+++ b/components/style/properties/helpers.mako.rs
@@ -563,6 +563,7 @@
                 Copy,
                 Debug,
                 Eq,
+                FromPrimitive,
                 Hash,
                 MallocSizeOf,
                 Parse,
@@ -762,7 +763,7 @@
         % endif
         pub mod computed_value {
             #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
-            #[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToCss, ToResolvedValue)]
+            #[derive(Clone, Copy, Debug, Eq, FromPrimitive, MallocSizeOf, PartialEq, ToCss, ToResolvedValue)]
             % if not extra_specified:
             #[derive(Parse, SpecifiedValueInfo, ToComputedValue, ToShmem)]
             % endif
diff --git a/components/style/properties/longhands/inherited_box.mako.rs b/components/style/properties/longhands/inherited_box.mako.rs
index 78c2e6023ee..e7715431b5e 100644
--- a/components/style/properties/longhands/inherited_box.mako.rs
+++ b/components/style/properties/longhands/inherited_box.mako.rs
@@ -43,7 +43,7 @@ ${helpers.single_keyword(
     servo_2020_pref="layout.2020.unimplemented",
     animation_value_type="none",
     spec="https://drafts.csswg.org/css-writing-modes/#propdef-direction",
-    needs_conversion=True,
+    gecko_enum_prefix="StyleDirection",
     servo_restyle_damage="rebuild_and_reflow",
 )}
 

From 9aed1de6a5279c79e4cf217693009775365e4a26 Mon Sep 17 00:00:00 2001
From: Boris Chiou <boris.chiou@gmail.com>
Date: Fri, 24 Jan 2020 18:59:03 +0000
Subject: [PATCH 33/66] style: Make the empty svg path valid.

Per SVG2 spec, the EBNF allows the path data string to be empty.
An empty path data string disables rendering of the path.
Therefore, we should make path('') a valid path string.

The related spec issue: https://github.com/w3c/fxtf-drafts/issues/392.
Now we serialize `path("")` as `path("")` for offset-path and clip-path.

Differential Revision: https://phabricator.services.mozilla.com/D60771
---
 components/style/values/specified/svg_path.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/components/style/values/specified/svg_path.rs b/components/style/values/specified/svg_path.rs
index b5461bb37fc..288f396b73c 100644
--- a/components/style/values/specified/svg_path.rs
+++ b/components/style/values/specified/svg_path.rs
@@ -42,7 +42,6 @@ impl SVGPathData {
     /// Get the array of PathCommand.
     #[inline]
     pub fn commands(&self) -> &[PathCommand] {
-        debug_assert!(!self.0.is_empty());
         &self.0
     }
 
@@ -92,10 +91,6 @@ impl Parse for SVGPathData {
     ) -> Result<Self, ParseError<'i>> {
         let location = input.current_source_location();
         let path_string = input.expect_string()?.as_ref();
-        if path_string.is_empty() {
-            // Treat an empty string as invalid, so we will not set it.
-            return Err(location.new_custom_error(StyleParseErrorKind::UnspecifiedError));
-        }
 
         // Parse the svg path string as multiple sub-paths.
         let mut path_parser = PathParser::new(path_string);

From 017d6f041696db394b2487e346d83ae346be7a5a Mon Sep 17 00:00:00 2001
From: Sakura Mochizuki <mochimoon@protonmail.com>
Date: Sat, 25 Jan 2020 10:51:24 +0000
Subject: [PATCH 34/66] style: Convert dominant-baseline #defines to an enum
 class.

Differential Revision: https://phabricator.services.mozilla.com/D61046
---
 components/style/properties/longhands/inherited_svg.mako.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/style/properties/longhands/inherited_svg.mako.rs b/components/style/properties/longhands/inherited_svg.mako.rs
index 7cb4e4f1da0..1839f90d6e6 100644
--- a/components/style/properties/longhands/inherited_svg.mako.rs
+++ b/components/style/properties/longhands/inherited_svg.mako.rs
@@ -17,6 +17,7 @@ ${helpers.single_keyword(
     engines="gecko",
     animation_value_type="discrete",
     spec="https://www.w3.org/TR/css-inline-3/#propdef-dominant-baseline",
+    gecko_enum_prefix="StyleDominantBaseline",
 )}
 
 ${helpers.single_keyword(

From 13d12d0d5f015a7dea164599cf061a2b9d332577 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Sun, 26 Jan 2020 22:57:21 +0000
Subject: [PATCH 35/66] style: Tweak background-color and color handling in
 ignored-colors mode.

We're resetting `color` to the default color when there's a declaration that
applies in order to make stuff like this:

<div style="color: transparent">
  <div style="color: red">
    Red
  </div>
</div>

To not show transparent. But the behavior we want is more like "override with
default color iff there's no other declaration that would set the color from an
user or UA sheet".

This implements that behavior, plus avoids it if we're not inheriting
from transparent, so that stuff like this preserves the behavior from before bug
844349:

<a href="foo">
  <span style="color: red">Should be the red color</span>
</a>

Differential Revision: https://phabricator.services.mozilla.com/D60391
---
 components/style/properties/cascade.rs | 117 +++++++++++++++++--------
 1 file changed, 79 insertions(+), 38 deletions(-)

diff --git a/components/style/properties/cascade.rs b/components/style/properties/cascade.rs
index f9f17a57121..461bc0c1fce 100644
--- a/components/style/properties/cascade.rs
+++ b/components/style/properties/cascade.rs
@@ -333,27 +333,37 @@ where
     context.builder.build()
 }
 
-fn should_ignore_declaration_when_ignoring_document_colors(
-    device: &Device,
+/// How should a declaration behave when ignoring document colors?
+enum DeclarationApplication {
+    /// We should apply the declaration.
+    Apply,
+    /// We should ignore the declaration.
+    Ignore,
+    /// We should apply the following declaration, only if any other declaration
+    /// hasn't set it before.
+    ApplyUnlessOverriden(PropertyDeclaration),
+}
+
+fn application_when_ignoring_colors(
+    builder: &StyleBuilder,
     longhand_id: LonghandId,
     origin: Origin,
-    pseudo: Option<&PseudoElement>,
-    declaration: &mut Cow<PropertyDeclaration>,
-) -> bool {
+    declaration: &PropertyDeclaration,
+) -> DeclarationApplication {
     if !longhand_id.ignored_when_document_colors_disabled() {
-        return false;
+        return DeclarationApplication::Apply;
     }
 
     let is_ua_or_user_rule = matches!(origin, Origin::User | Origin::UserAgent);
     if is_ua_or_user_rule {
-        return false;
+        return DeclarationApplication::Apply;
     }
 
     // Don't override background-color on ::-moz-color-swatch. It is set as an
     // author style (via the style attribute), but it's pretty important for it
     // to show up for obvious reasons :)
-    if pseudo.map_or(false, |p| p.is_color_swatch()) && longhand_id == LonghandId::BackgroundColor {
-        return false;
+    if builder.pseudo.map_or(false, |p| p.is_color_swatch()) && longhand_id == LonghandId::BackgroundColor {
+        return DeclarationApplication::Apply;
     }
 
     // Treat background-color a bit differently.  If the specified color is
@@ -365,30 +375,41 @@ fn should_ignore_declaration_when_ignoring_document_colors(
     // a background image, if we're ignoring document colors).
     // Here we check backplate status to decide if ignoring background-image
     // is the right decision.
-    let (is_background, is_transparent) = match **declaration {
-        PropertyDeclaration::BackgroundColor(ref color) => (true, color.is_transparent()),
-        PropertyDeclaration::Color(ref color) => (false, color.0.is_transparent()),
+    match *declaration {
+        PropertyDeclaration::BackgroundColor(ref color) => {
+            if color.is_transparent() {
+                return DeclarationApplication::Apply;
+            }
+            let color = builder.device.default_background_color();
+            DeclarationApplication::ApplyUnlessOverriden(
+                PropertyDeclaration::BackgroundColor(color.into())
+            )
+        }
+        PropertyDeclaration::Color(ref color) => {
+            if color.0.is_transparent() {
+                return DeclarationApplication::Apply;
+            }
+            if builder.get_parent_inherited_text().clone_color().alpha != 0 {
+                return DeclarationApplication::Ignore;
+            }
+            let color = builder.device.default_color();
+            DeclarationApplication::ApplyUnlessOverriden(
+                PropertyDeclaration::Color(specified::ColorPropertyValue(color.into()))
+            )
+        },
         // In the future, if/when we remove the backplate pref, we can remove this
         // special case along with the 'ignored_when_colors_disabled=True' mako line
         // for the "background-image" property.
         #[cfg(feature = "gecko")]
-        PropertyDeclaration::BackgroundImage(..) => return !static_prefs::pref!("browser.display.permit_backplate"),
-        _ => return true,
-    };
-
-    if is_transparent {
-        return false;
+        PropertyDeclaration::BackgroundImage(..) => {
+            if static_prefs::pref!("browser.display.permit_backplate") {
+                DeclarationApplication::Apply
+            } else {
+                DeclarationApplication::Ignore
+            }
+        },
+        _ => DeclarationApplication::Ignore,
     }
-
-    if is_background {
-        let color = device.default_background_color();
-        *declaration.to_mut() = PropertyDeclaration::BackgroundColor(color.into());
-    } else {
-        let color = device.default_color();
-        *declaration.to_mut() = PropertyDeclaration::Color(specified::ColorPropertyValue(color.into()));
-    }
-
-    false
 }
 
 struct Cascade<'a, 'b: 'a> {
@@ -465,6 +486,8 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
         );
 
         let ignore_colors = !self.context.builder.device.use_document_colors();
+        let mut declarations_to_apply_unless_overriden =
+            SmallVec::<[PropertyDeclaration; 2]>::new();
 
         for (declaration, origin) in declarations {
             let declaration_id = declaration.id();
@@ -506,21 +529,25 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
                 continue;
             }
 
-            let mut declaration = self.substitute_variables_if_needed(declaration);
+            let declaration = self.substitute_variables_if_needed(declaration);
 
-            // When document colors are disabled, skip properties that are
-            // marked as ignored in that mode, unless they come from a UA or
-            // user style sheet.
+            // When document colors are disabled, do special handling of
+            // properties that are marked as ignored in that mode.
             if ignore_colors {
-                let should_ignore = should_ignore_declaration_when_ignoring_document_colors(
-                    self.context.builder.device,
+                let application = application_when_ignoring_colors(
+                    &self.context.builder,
                     longhand_id,
                     origin,
-                    self.context.builder.pseudo,
-                    &mut declaration,
+                    &declaration,
                 );
-                if should_ignore {
-                    continue;
+
+                match application {
+                    DeclarationApplication::Ignore => continue,
+                    DeclarationApplication::Apply => {},
+                    DeclarationApplication::ApplyUnlessOverriden(decl) => {
+                        declarations_to_apply_unless_overriden.push(decl);
+                        continue;
+                    }
                 }
             }
 
@@ -558,6 +585,20 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
             self.apply_declaration(longhand_id, &*declaration);
         }
 
+        if ignore_colors {
+            for declaration in declarations_to_apply_unless_overriden.iter() {
+                let longhand_id = match declaration.id() {
+                    PropertyDeclarationId::Longhand(id) => id,
+                    PropertyDeclarationId::Custom(..) => unreachable!(),
+                };
+                debug_assert!(!longhand_id.is_logical());
+                if self.seen.contains(longhand_id) {
+                    continue;
+                }
+                self.apply_declaration(longhand_id, declaration);
+            }
+        }
+
         if Phase::is_early() {
             self.fixup_font_stuff();
             self.compute_writing_mode();

From c447395c660053b2943eb0ed9abf13692dd51a35 Mon Sep 17 00:00:00 2001
From: Martin McNickle <mmcnickle@gmail.com>
Date: Mon, 27 Jan 2020 14:59:41 +0000
Subject: [PATCH 36/66] style: Convert mask-type #defines to an enum class.

Differential Revision: https://phabricator.services.mozilla.com/D60987
---
 components/style/properties/longhands/svg.mako.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/style/properties/longhands/svg.mako.rs b/components/style/properties/longhands/svg.mako.rs
index f25cbb8e019..724c38b2d1b 100644
--- a/components/style/properties/longhands/svg.mako.rs
+++ b/components/style/properties/longhands/svg.mako.rs
@@ -69,6 +69,7 @@ ${helpers.single_keyword(
     "mask-type",
     "luminance alpha",
     engines="gecko",
+    gecko_enum_prefix="StyleMaskType",
     animation_value_type="discrete",
     spec="https://drafts.fxtf.org/css-masking/#propdef-mask-type",
 )}

From 143184d807909362b317e544137beda44fdcb7d9 Mon Sep 17 00:00:00 2001
From: Martin McNickle <mmcnickle@gmail.com>
Date: Tue, 28 Jan 2020 09:12:29 +0000
Subject: [PATCH 37/66] style: Convert scroll-behavior #defines to an enum
 class.

Differential Revision: https://phabricator.services.mozilla.com/D61164
---
 components/style/properties/longhands/box.mako.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/style/properties/longhands/box.mako.rs b/components/style/properties/longhands/box.mako.rs
index 862a373bdfe..554699e1862 100644
--- a/components/style/properties/longhands/box.mako.rs
+++ b/components/style/properties/longhands/box.mako.rs
@@ -452,6 +452,7 @@ ${helpers.single_keyword(
     engines="gecko",
     spec="https://drafts.csswg.org/cssom-view/#propdef-scroll-behavior",
     animation_value_type="discrete",
+    gecko_enum_prefix="StyleScrollBehavior",
 )}
 
 ${helpers.predefined_type(

From 41ae92e04543ff2ab831dddcaf77a2f08369231e Mon Sep 17 00:00:00 2001
From: Thomas Dolezal <thomas.dolezal@mail.utoronto.ca>
Date: Thu, 30 Jan 2020 04:34:32 +0100
Subject: [PATCH 38/66] style: Convert image-rendering #defines to an enum
 class.

MANUAL PUSH: Contributor didn't use Phabricator and I don't want patch to rot
---
 components/style/properties/longhands/inherited_box.mako.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/style/properties/longhands/inherited_box.mako.rs b/components/style/properties/longhands/inherited_box.mako.rs
index e7715431b5e..e8f3a0a45d9 100644
--- a/components/style/properties/longhands/inherited_box.mako.rs
+++ b/components/style/properties/longhands/inherited_box.mako.rs
@@ -78,6 +78,7 @@ ${helpers.single_keyword(
     extra_servo_2013_values="pixelated",
     extra_servo_2020_values="pixelated",
     gecko_aliases="-moz-crisp-edges=crisp-edges",
+    gecko_enum_prefix="StyleImageRendering",
     animation_value_type="discrete",
     spec="https://drafts.csswg.org/css-images/#propdef-image-rendering",
 )}

From 2bdcd766bb2f0e8ac6ed756ab702e17802295a0b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Fri, 31 Jan 2020 00:56:49 +0000
Subject: [PATCH 39/66] style: Use cbindgen for css-align types.

This provides stronger typing and removes a bunch of subtle constants matching.

Differential Revision: https://phabricator.services.mozilla.com/D61058
---
 components/style/properties/gecko.mako.rs  | 38 +--------
 components/style/values/computed/align.rs  |  7 +-
 components/style/values/specified/align.rs | 94 +++++++---------------
 3 files changed, 39 insertions(+), 100 deletions(-)

diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index 874bf1a83cb..8f384296cbb 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -957,48 +957,16 @@ fn static_assert() {
 
 <% skip_position_longhands = " ".join(x.ident for x in SIDES) %>
 <%self:impl_trait style_struct_name="Position"
-                  skip_longhands="${skip_position_longhands}
-                                  align-content justify-content align-self
-                                  justify-self align-items justify-items
-                                  grid-auto-flow">
+                  skip_longhands="${skip_position_longhands} grid-auto-flow">
     % for side in SIDES:
     <% impl_split_style_coord(side.ident, "mOffset", side.index) %>
     % endfor
-
-    % for kind in ["align", "justify"]:
-    ${impl_simple_type_with_conversion(kind + "_content")}
-    ${impl_simple_type_with_conversion(kind + "_self")}
-    % endfor
-    ${impl_simple_type_with_conversion("align_items")}
-
-    pub fn set_justify_items(&mut self, v: longhands::justify_items::computed_value::T) {
-        self.gecko.mSpecifiedJustifyItems = v.specified.into();
-        self.set_computed_justify_items(v.computed);
-    }
-
+    ${impl_simple_type_with_conversion("grid_auto_flow")}
     pub fn set_computed_justify_items(&mut self, v: values::specified::JustifyItems) {
         debug_assert_ne!(v.0, crate::values::specified::align::AlignFlags::LEGACY);
-        self.gecko.mJustifyItems = v.into();
+        self.gecko.mJustifyItems.computed = v;
     }
 
-    pub fn reset_justify_items(&mut self, reset_style: &Self) {
-        self.gecko.mJustifyItems = reset_style.gecko.mJustifyItems;
-        self.gecko.mSpecifiedJustifyItems = reset_style.gecko.mSpecifiedJustifyItems;
-    }
-
-    pub fn copy_justify_items_from(&mut self, other: &Self) {
-        self.gecko.mJustifyItems = other.gecko.mJustifyItems;
-        self.gecko.mSpecifiedJustifyItems = other.gecko.mJustifyItems;
-    }
-
-    pub fn clone_justify_items(&self) -> longhands::justify_items::computed_value::T {
-        longhands::justify_items::computed_value::T {
-            computed: self.gecko.mJustifyItems.into(),
-            specified: self.gecko.mSpecifiedJustifyItems.into(),
-        }
-    }
-
-    ${impl_simple_type_with_conversion("grid_auto_flow")}
 </%self:impl_trait>
 
 <% skip_outline_longhands = " ".join("outline-style outline-width".split() +
diff --git a/components/style/values/computed/align.rs b/components/style/values/computed/align.rs
index ea6088db5d5..c76c9018ac2 100644
--- a/components/style/values/computed/align.rs
+++ b/components/style/values/computed/align.rs
@@ -9,7 +9,7 @@
 use crate::values::computed::{Context, ToComputedValue};
 use crate::values::specified;
 
-pub use super::specified::{AlignContent, AlignItems, JustifyContent, SelfAlignment};
+pub use super::specified::{AlignContent, AlignItems, ContentDistribution, JustifyContent, SelfAlignment};
 pub use super::specified::{AlignSelf, JustifySelf};
 
 /// The computed value for the `justify-items` property.
@@ -34,7 +34,8 @@ pub use super::specified::{AlignSelf, JustifySelf};
 ///
 /// See the discussion in https://bugzil.la/1384542.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, ToCss, ToResolvedValue)]
-pub struct JustifyItems {
+#[repr(C)]
+pub struct ComputedJustifyItems {
     /// The specified value for the property. Can contain the bare `legacy`
     /// keyword.
     #[css(skip)]
@@ -45,6 +46,8 @@ pub struct JustifyItems {
     pub computed: specified::JustifyItems,
 }
 
+pub use self::ComputedJustifyItems as JustifyItems;
+
 impl JustifyItems {
     /// Returns the `legacy` value.
     pub fn legacy() -> Self {
diff --git a/components/style/values/specified/align.rs b/components/style/values/specified/align.rs
index 0dc1e422515..d0160a32ae6 100644
--- a/components/style/values/specified/align.rs
+++ b/components/style/values/specified/align.rs
@@ -6,7 +6,6 @@
 //!
 //! https://drafts.csswg.org/css-align/
 
-use crate::gecko_bindings::structs;
 use crate::parser::{Parse, ParserContext};
 use cssparser::Parser;
 use std::fmt::{self, Write};
@@ -14,56 +13,55 @@ use style_traits::{CssWriter, KeywordsCollectFn, ParseError, SpecifiedValueInfo,
 
 bitflags! {
     /// Constants shared by multiple CSS Box Alignment properties
-    ///
-    /// These constants match Gecko's `NS_STYLE_ALIGN_*` constants.
     #[derive(MallocSizeOf, ToComputedValue, ToResolvedValue, ToShmem)]
+    #[repr(C)]
     pub struct AlignFlags: u8 {
         // Enumeration stored in the lower 5 bits:
-        /// 'auto'
-        const AUTO =            structs::NS_STYLE_ALIGN_AUTO as u8;
+        /// {align,justify}-{content,items,self}: 'auto'
+        const AUTO = 0;
         /// 'normal'
-        const NORMAL =          structs::NS_STYLE_ALIGN_NORMAL as u8;
+        const NORMAL = 1;
         /// 'start'
-        const START =           structs::NS_STYLE_ALIGN_START as u8;
+        const START = 2;
         /// 'end'
-        const END =             structs::NS_STYLE_ALIGN_END as u8;
+        const END = 3;
         /// 'flex-start'
-        const FLEX_START =      structs::NS_STYLE_ALIGN_FLEX_START as u8;
+        const FLEX_START = 4;
         /// 'flex-end'
-        const FLEX_END =        structs::NS_STYLE_ALIGN_FLEX_END as u8;
+        const FLEX_END = 5;
         /// 'center'
-        const CENTER =          structs::NS_STYLE_ALIGN_CENTER as u8;
+        const CENTER = 6;
         /// 'left'
-        const LEFT =            structs::NS_STYLE_ALIGN_LEFT as u8;
+        const LEFT = 7;
         /// 'right'
-        const RIGHT =           structs::NS_STYLE_ALIGN_RIGHT as u8;
+        const RIGHT = 8;
         /// 'baseline'
-        const BASELINE =        structs::NS_STYLE_ALIGN_BASELINE as u8;
+        const BASELINE = 9;
         /// 'last-baseline'
-        const LAST_BASELINE =   structs::NS_STYLE_ALIGN_LAST_BASELINE as u8;
+        const LAST_BASELINE = 10;
         /// 'stretch'
-        const STRETCH =         structs::NS_STYLE_ALIGN_STRETCH as u8;
+        const STRETCH = 11;
         /// 'self-start'
-        const SELF_START =      structs::NS_STYLE_ALIGN_SELF_START as u8;
+        const SELF_START = 12;
         /// 'self-end'
-        const SELF_END =        structs::NS_STYLE_ALIGN_SELF_END as u8;
+        const SELF_END = 13;
         /// 'space-between'
-        const SPACE_BETWEEN =   structs::NS_STYLE_ALIGN_SPACE_BETWEEN as u8;
+        const SPACE_BETWEEN = 14;
         /// 'space-around'
-        const SPACE_AROUND =    structs::NS_STYLE_ALIGN_SPACE_AROUND as u8;
+        const SPACE_AROUND = 15;
         /// 'space-evenly'
-        const SPACE_EVENLY =    structs::NS_STYLE_ALIGN_SPACE_EVENLY as u8;
+        const SPACE_EVENLY = 16;
 
         // Additional flags stored in the upper bits:
         /// 'legacy' (mutually exclusive w. SAFE & UNSAFE)
-        const LEGACY =          structs::NS_STYLE_ALIGN_LEGACY as u8;
+        const LEGACY = 1 << 5;
         /// 'safe'
-        const SAFE =            structs::NS_STYLE_ALIGN_SAFE as u8;
+        const SAFE = 1 << 6;
         /// 'unsafe' (mutually exclusive w. SAFE)
-        const UNSAFE =          structs::NS_STYLE_ALIGN_UNSAFE as u8;
+        const UNSAFE = 1 << 7;
 
         /// Mask for the additional flags above.
-        const FLAG_BITS =       structs::NS_STYLE_ALIGN_FLAG_BITS as u8;
+        const FLAG_BITS = 0b11100000;
     }
 }
 
@@ -146,6 +144,7 @@ pub enum AxisDirection {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(C)]
 #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
 pub struct ContentDistribution {
     primary: AlignFlags,
@@ -270,6 +269,7 @@ impl ContentDistribution {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(transparent)]
 pub struct AlignContent(pub ContentDistribution);
 
 impl Parse for AlignContent {
@@ -292,20 +292,6 @@ impl SpecifiedValueInfo for AlignContent {
     }
 }
 
-#[cfg(feature = "gecko")]
-impl From<u16> for AlignContent {
-    fn from(bits: u16) -> Self {
-        AlignContent(ContentDistribution::from_bits(bits))
-    }
-}
-
-#[cfg(feature = "gecko")]
-impl From<AlignContent> for u16 {
-    fn from(v: AlignContent) -> u16 {
-        v.0.as_bits()
-    }
-}
-
 /// Value for the `justify-content` property.
 ///
 /// <https://drafts.csswg.org/css-align/#propdef-justify-content>
@@ -321,6 +307,7 @@ impl From<AlignContent> for u16 {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(transparent)]
 pub struct JustifyContent(pub ContentDistribution);
 
 impl Parse for JustifyContent {
@@ -370,6 +357,7 @@ impl From<JustifyContent> for u16 {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(transparent)]
 pub struct SelfAlignment(pub AlignFlags);
 
 impl SelfAlignment {
@@ -441,6 +429,7 @@ impl SelfAlignment {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(C)]
 pub struct AlignSelf(pub SelfAlignment);
 
 impl Parse for AlignSelf {
@@ -463,18 +452,6 @@ impl SpecifiedValueInfo for AlignSelf {
     }
 }
 
-impl From<u8> for AlignSelf {
-    fn from(bits: u8) -> Self {
-        AlignSelf(SelfAlignment(AlignFlags::from_bits_truncate(bits)))
-    }
-}
-
-impl From<AlignSelf> for u8 {
-    fn from(align: AlignSelf) -> u8 {
-        (align.0).0.bits()
-    }
-}
-
 /// The specified value of the justify-self property.
 ///
 /// <https://drafts.csswg.org/css-align/#propdef-justify-self>
@@ -490,6 +467,7 @@ impl From<AlignSelf> for u8 {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(C)]
 pub struct JustifySelf(pub SelfAlignment);
 
 impl Parse for JustifySelf {
@@ -512,18 +490,6 @@ impl SpecifiedValueInfo for JustifySelf {
     }
 }
 
-impl From<u8> for JustifySelf {
-    fn from(bits: u8) -> Self {
-        JustifySelf(SelfAlignment(AlignFlags::from_bits_truncate(bits)))
-    }
-}
-
-impl From<JustifySelf> for u8 {
-    fn from(justify: JustifySelf) -> u8 {
-        (justify.0).0.bits()
-    }
-}
-
 /// Value of the `align-items` property
 ///
 /// <https://drafts.csswg.org/css-align/#propdef-align-items>
@@ -539,6 +505,7 @@ impl From<JustifySelf> for u8 {
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(C)]
 pub struct AlignItems(pub AlignFlags);
 
 impl AlignItems {
@@ -590,6 +557,7 @@ impl SpecifiedValueInfo for AlignItems {
 ///
 /// <https://drafts.csswg.org/css-align/#justify-items-property>
 #[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, ToCss, ToShmem)]
+#[repr(C)]
 pub struct JustifyItems(pub AlignFlags);
 
 impl JustifyItems {

From 6682f725cf843e177e627ee7942977c53f230cb2 Mon Sep 17 00:00:00 2001
From: Thomas Dolezal <thomas.dolezal@mail.utoronto.ca>
Date: Fri, 31 Jan 2020 01:23:23 +0000
Subject: [PATCH 40/66] style: Replacing table-layout defines with an enum.

Differential Revision: https://phabricator.services.mozilla.com/D61260
---
 components/style/properties/longhands/table.mako.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/style/properties/longhands/table.mako.rs b/components/style/properties/longhands/table.mako.rs
index 0564942fc0a..104c28b8e04 100644
--- a/components/style/properties/longhands/table.mako.rs
+++ b/components/style/properties/longhands/table.mako.rs
@@ -12,6 +12,7 @@ ${helpers.single_keyword(
     engines="gecko servo-2013",
     gecko_ffi_name="mLayoutStrategy",
     animation_value_type="discrete",
+    gecko_enum_prefix="StyleTableLayout",
     spec="https://drafts.csswg.org/css-tables/#propdef-table-layout",
     servo_restyle_damage="reflow",
 )}

From f426b644ca179e40d009ec58afa643d1c5489af0 Mon Sep 17 00:00:00 2001
From: Jonathan Kew <jkew@mozilla.com>
Date: Fri, 31 Jan 2020 10:11:19 +0000
Subject: [PATCH 41/66] style: Don't apply text-combine-upright in sideways-*
 writing modes.

Differential Revision: https://phabricator.services.mozilla.com/D61326
---
 components/style/style_adjuster.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/style/style_adjuster.rs b/components/style/style_adjuster.rs
index a66c9462c92..2a897bbe151 100644
--- a/components/style/style_adjuster.rs
+++ b/components/style/style_adjuster.rs
@@ -281,7 +281,7 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
         let writing_mode = self.style.get_inherited_box().clone_writing_mode();
         let text_combine_upright = self.style.get_inherited_text().clone_text_combine_upright();
 
-        if writing_mode != WritingMode::HorizontalTb &&
+        if matches!(writing_mode, WritingMode::VerticalRl | WritingMode::VerticalLr) &&
             text_combine_upright == TextCombineUpright::All
         {
             self.style.add_flags(ComputedValueFlags::IS_TEXT_COMBINED);

From 16fd7cad0c2d74dd3e90bb3cb59b6da7f40ec494 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Fri, 31 Jan 2020 14:51:06 +0000
Subject: [PATCH 42/66] style: Add a style flag for the root element style.

This is needed to make the root element not a containing block in presence of
filters or what not.

Differential Revision: https://phabricator.services.mozilla.com/D61167
---
 components/style/lib.rs                       |  2 ++
 components/style/matching.rs                  |  3 ++-
 components/style/properties/cascade.rs        |  6 ++++-
 .../style/properties/computed_value_flags.rs  | 23 ++++---------------
 components/style/properties/gecko.mako.rs     |  2 +-
 .../style/properties/properties.mako.rs       | 13 +++++++----
 components/style/style_adjuster.rs            | 14 +++++++----
 components/style/style_resolver.rs            |  2 +-
 components/style/stylesheets/viewport_rule.rs |  1 -
 components/style/traversal.rs                 |  2 +-
 components/style/values/computed/mod.rs       |  9 --------
 components/style/values/specified/length.rs   |  4 ++--
 components/style/values/specified/text.rs     |  2 +-
 13 files changed, 37 insertions(+), 46 deletions(-)

diff --git a/components/style/lib.rs b/components/style/lib.rs
index 33862461aa9..aa855b8b55b 100644
--- a/components/style/lib.rs
+++ b/components/style/lib.rs
@@ -120,6 +120,8 @@ pub mod attr;
 pub mod author_styles;
 pub mod bezier;
 pub mod bloom;
+#[path="properties/computed_value_flags.rs"]
+pub mod computed_value_flags;
 pub mod context;
 pub mod counter_style;
 pub mod custom_properties;
diff --git a/components/style/matching.rs b/components/style/matching.rs
index 7ec94d35346..42921f052c4 100644
--- a/components/style/matching.rs
+++ b/components/style/matching.rs
@@ -7,6 +7,7 @@
 #![allow(unsafe_code)]
 #![deny(missing_docs)]
 
+use crate::computed_value_flags::ComputedValueFlags;
 use crate::context::{ElementCascadeInputs, QuirksMode, SelectorFlagsMap};
 use crate::context::{SharedStyleContext, StyleContext};
 use crate::data::ElementData;
@@ -705,7 +706,7 @@ pub trait MatchMethods: TElement {
         let new_primary_style = data.styles.primary.as_ref().unwrap();
 
         let mut cascade_requirement = ChildCascadeRequirement::CanSkipCascade;
-        if self.is_root() && !self.is_in_native_anonymous_subtree() {
+        if new_primary_style.flags.contains(ComputedValueFlags::IS_ROOT_ELEMENT_STYLE) {
             let device = context.shared.stylist.device();
             let new_font_size = new_primary_style.get_font().clone_font_size();
 
diff --git a/components/style/properties/cascade.rs b/components/style/properties/cascade.rs
index 461bc0c1fce..50029da8479 100644
--- a/components/style/properties/cascade.rs
+++ b/components/style/properties/cascade.rs
@@ -263,8 +263,11 @@ where
         builder.build()
     };
 
+
+    let is_root_element =
+        pseudo.is_none() && element.map_or(false, |e| e.is_root());
+
     let mut context = computed::Context {
-        is_root_element: pseudo.is_none() && element.map_or(false, |e| e.is_root()),
         // We'd really like to own the rules here to avoid refcount traffic, but
         // animation's usage of `apply_declarations` make this tricky. See bug
         // 1375525.
@@ -275,6 +278,7 @@ where
             pseudo,
             Some(rules.clone()),
             custom_properties,
+            is_root_element,
         ),
         cached_system_font: None,
         in_media_query: false,
diff --git a/components/style/properties/computed_value_flags.rs b/components/style/properties/computed_value_flags.rs
index a86f8a4da3a..170c4151411 100644
--- a/components/style/properties/computed_value_flags.rs
+++ b/components/style/properties/computed_value_flags.rs
@@ -11,6 +11,7 @@ bitflags! {
     /// anonymous boxes, see StyleBuilder::for_inheritance and its callsites.
     /// If we ever want to add some flags that shouldn't inherit for them,
     /// we might want to add a function to handle this.
+    #[repr(C)]
     pub struct ComputedValueFlags: u16 {
         /// Whether the style or any of the ancestors has a text-decoration-line
         /// property that should get propagated to descendants.
@@ -63,6 +64,9 @@ bitflags! {
         ///
         /// Only used in Servo.
         const CAN_BE_FRAGMENTED = 1 << 10;
+
+        /// Whether this style is the style of the document element.
+        const IS_ROOT_ELEMENT_STYLE = 1 << 11;
     }
 }
 
@@ -97,22 +101,3 @@ impl ComputedValueFlags {
         self & Self::maybe_inherited_flags()
     }
 }
-
-/// Asserts that the relevant servo and Gecko representations match.
-#[cfg(feature = "gecko")]
-#[inline]
-pub fn assert_match() {
-    use crate::gecko_bindings::structs;
-    macro_rules! assert_bit {
-        ($rust:ident, $cpp:ident) => {
-            debug_assert_eq!(ComputedValueFlags::$rust.bits, structs::$cpp);
-        }
-    }
-
-    assert_bit!(HAS_TEXT_DECORATION_LINES, ComputedStyleBit_HasTextDecorationLines);
-    assert_bit!(IS_IN_PSEUDO_ELEMENT_SUBTREE, ComputedStyleBit_HasPseudoElementData);
-    assert_bit!(SHOULD_SUPPRESS_LINEBREAK, ComputedStyleBit_SuppressLineBreak);
-    assert_bit!(IS_TEXT_COMBINED, ComputedStyleBit_IsTextCombined);
-    assert_bit!(IS_RELEVANT_LINK_VISITED, ComputedStyleBit_RelevantLinkVisited);
-    assert_bit!(DEPENDS_ON_FONT_METRICS, ComputedStyleBit_DependsOnFontMetrics);
-}
diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index 8f384296cbb..84dc8436940 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -12,6 +12,7 @@
 
 use crate::Atom;
 use app_units::Au;
+use crate::computed_value_flags::*;
 use crate::custom_properties::CustomPropertiesMap;
 use crate::gecko_bindings::bindings;
 % for style_struct in data.style_structs:
@@ -39,7 +40,6 @@ use crate::gecko_bindings::structs::mozilla::PseudoStyleType;
 use crate::gecko::values::round_border_to_device_pixels;
 use crate::logical_geometry::WritingMode;
 use crate::media_queries::Device;
-use crate::properties::computed_value_flags::*;
 use crate::properties::longhands;
 use crate::rule_tree::StrongRuleNode;
 use crate::selector_parser::PseudoElement;
diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs
index d04d6d43d2e..ff5d5b5bf56 100644
--- a/components/style/properties/properties.mako.rs
+++ b/components/style/properties/properties.mako.rs
@@ -28,6 +28,7 @@ use crate::context::QuirksMode;
 #[cfg(feature = "servo")] use crate::computed_values;
 use crate::logical_geometry::WritingMode;
 use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
+use crate::computed_value_flags::*;
 use crate::media_queries::Device;
 use crate::parser::ParserContext;
 use crate::properties::longhands::system_font::SystemFont;
@@ -45,7 +46,6 @@ use crate::values::computed::NonNegativeLength;
 use crate::values::serialize_atom_name;
 use crate::rule_tree::StrongRuleNode;
 use crate::Zero;
-use self::computed_value_flags::*;
 use crate::str::{CssString, CssStringBorrow, CssStringWriter};
 use std::cell::Cell;
 
@@ -58,8 +58,6 @@ pub use self::cascade::*;
     import os.path
 %>
 
-#[path="${repr(os.path.join(os.path.dirname(__file__), 'computed_value_flags.rs'))[1:-1]}"]
-pub mod computed_value_flags;
 #[path="${repr(os.path.join(os.path.dirname(__file__), 'declaration_block.rs'))[1:-1]}"]
 pub mod declaration_block;
 #[path="${repr(os.path.join(os.path.dirname(__file__), 'cascade.rs'))[1:-1]}"]
@@ -3436,6 +3434,9 @@ pub struct StyleBuilder<'a> {
     /// `StyleAdjuster` did any work.
     modified_reset: bool,
 
+    /// Whether this is the style for the root element.
+    pub is_root_element: bool,
+
     /// The writing mode flags.
     ///
     /// TODO(emilio): Make private.
@@ -3462,6 +3463,7 @@ impl<'a> StyleBuilder<'a> {
         pseudo: Option<<&'a PseudoElement>,
         rules: Option<StrongRuleNode>,
         custom_properties: Option<Arc<crate::custom_properties::CustomPropertiesMap>>,
+        is_root_element: bool,
     ) -> Self {
         debug_assert_eq!(parent_style.is_some(), parent_style_ignoring_first_line.is_some());
         #[cfg(feature = "gecko")]
@@ -3483,6 +3485,7 @@ impl<'a> StyleBuilder<'a> {
             pseudo,
             rules,
             modified_reset: false,
+            is_root_element,
             custom_properties,
             writing_mode: inherited_style.writing_mode,
             flags: Cell::new(flags),
@@ -3521,6 +3524,7 @@ impl<'a> StyleBuilder<'a> {
             reset_style,
             pseudo: None,
             modified_reset: false,
+            is_root_element: false,
             rules: None,
             custom_properties: style_to_derive_from.custom_properties().cloned(),
             writing_mode: style_to_derive_from.writing_mode,
@@ -3648,6 +3652,7 @@ impl<'a> StyleBuilder<'a> {
             pseudo,
             /* rules = */ None,
             parent.and_then(|p| p.custom_properties().cloned()),
+            /* is_root_element = */ false,
         );
         ret.visited_style = visited_style;
         ret
@@ -3830,9 +3835,9 @@ pub use self::lazy_static_module::INITIAL_SERVO_VALUES;
 #[allow(missing_docs)]
 mod lazy_static_module {
     use crate::logical_geometry::WritingMode;
+    use create::computed_value_flags::ComputedValueFlags;
     use servo_arc::Arc;
     use super::{ComputedValues, ComputedValuesInner, longhands, style_structs};
-    use super::computed_value_flags::ComputedValueFlags;
 
     lazy_static! {
         /// The initial values for all style structs as defined by the specification.
diff --git a/components/style/style_adjuster.rs b/components/style/style_adjuster.rs
index 2a897bbe151..b7c1decc390 100644
--- a/components/style/style_adjuster.rs
+++ b/components/style/style_adjuster.rs
@@ -5,8 +5,8 @@
 //! A struct to encapsulate all the style fixups and flags propagations
 //! a computed style needs in order for it to adhere to the CSS spec.
 
+use crate::computed_value_flags::ComputedValueFlags;
 use crate::dom::TElement;
-use crate::properties::computed_value_flags::ComputedValueFlags;
 use crate::properties::longhands::display::computed_value::T as Display;
 use crate::properties::longhands::float::computed_value::T as Float;
 use crate::properties::longhands::overflow_x::computed_value::T as Overflow;
@@ -189,8 +189,7 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
             };
         }
 
-        let is_root = self.style.pseudo.is_none() && element.map_or(false, |e| e.is_root());
-        blockify_if!(is_root);
+        blockify_if!(self.style.is_root_element);
         if !self.skip_item_display_fixup(element) {
             let parent_display = layout_parent_style.get_box().clone_display();
             blockify_if!(parent_display.is_item_container());
@@ -213,7 +212,7 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
         }
 
         let display = self.style.get_box().clone_display();
-        let blockified_display = display.equivalent_block_display(is_root);
+        let blockified_display = display.equivalent_block_display(self.style.is_root_element);
         if display != blockified_display {
             self.style
                 .mutate_box()
@@ -222,7 +221,7 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
     }
 
     /// Compute a few common flags for both text and element's style.
-    pub fn set_bits(&mut self) {
+    fn set_bits(&mut self) {
         let display = self.style.get_box().clone_display();
 
         if !display.is_contents() &&
@@ -241,6 +240,10 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
                 .add_flags(ComputedValueFlags::IS_IN_PSEUDO_ELEMENT_SUBTREE);
         }
 
+        if self.style.is_root_element {
+            self.style.add_flags(ComputedValueFlags::IS_ROOT_ELEMENT_STYLE);
+        }
+
         #[cfg(feature = "servo-layout-2013")]
         {
             if self.style.get_parent_column().is_multicol() {
@@ -257,6 +260,7 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
     /// Note that this, for Gecko, comes through Servo_ComputedValues_Inherit.
     #[cfg(feature = "gecko")]
     pub fn adjust_for_text(&mut self) {
+        debug_assert!(!self.style.is_root_element);
         self.adjust_for_text_combine_upright();
         self.adjust_for_text_in_ruby();
         self.set_bits();
diff --git a/components/style/style_resolver.rs b/components/style/style_resolver.rs
index 180de3ff281..f3f2c6b41b7 100644
--- a/components/style/style_resolver.rs
+++ b/components/style/style_resolver.rs
@@ -110,7 +110,7 @@ fn eager_pseudo_is_definitely_not_generated(
     pseudo: &PseudoElement,
     style: &ComputedValues,
 ) -> bool {
-    use crate::properties::computed_value_flags::ComputedValueFlags;
+    use crate::computed_value_flags::ComputedValueFlags;
 
     if !pseudo.is_before_or_after() {
         return false;
diff --git a/components/style/stylesheets/viewport_rule.rs b/components/style/stylesheets/viewport_rule.rs
index 7d0881e3336..cd875eefb69 100644
--- a/components/style/stylesheets/viewport_rule.rs
+++ b/components/style/stylesheets/viewport_rule.rs
@@ -733,7 +733,6 @@ impl MaybeNew for ViewportConstraints {
 
         let mut conditions = RuleCacheConditions::default();
         let context = Context {
-            is_root_element: false,
             // Note: DEVICE-ADAPT § 5. states that relative length values are
             // resolved against initial values
             builder: StyleBuilder::for_inheritance(device, None, None),
diff --git a/components/style/traversal.rs b/components/style/traversal.rs
index f73a533b718..254d40f0393 100644
--- a/components/style/traversal.rs
+++ b/components/style/traversal.rs
@@ -775,7 +775,7 @@ fn note_children<E, D, F>(
                     child_hint |= RestyleHint::RECASCADE_SELF | RestyleHint::RECASCADE_DESCENDANTS;
                 },
                 ChildCascadeRequirement::MustCascadeChildrenIfInheritResetStyle => {
-                    use crate::properties::computed_value_flags::ComputedValueFlags;
+                    use crate::computed_value_flags::ComputedValueFlags;
                     if child_data
                         .styles
                         .primary()
diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs
index 87c430fb265..da5c84aed39 100644
--- a/components/style/values/computed/mod.rs
+++ b/components/style/values/computed/mod.rs
@@ -126,9 +126,6 @@ pub mod url;
 /// A `Context` is all the data a specified value could ever need to compute
 /// itself and be transformed to a computed value.
 pub struct Context<'a> {
-    /// Whether the current element is the root element.
-    pub is_root_element: bool,
-
     /// Values accessed through this need to be in the properties "computed
     /// early": color, text-decoration, font-size, display, position, float,
     /// border-*-style, outline-style, font-family, writing-mode...
@@ -187,7 +184,6 @@ impl<'a> Context<'a> {
         let provider = get_metrics_provider_for_product();
 
         let context = Context {
-            is_root_element: false,
             builder: StyleBuilder::for_inheritance(device, None, None),
             font_metrics_provider: &provider,
             cached_system_font: None,
@@ -201,11 +197,6 @@ impl<'a> Context<'a> {
         f(&context)
     }
 
-    /// Whether the current element is the root element.
-    pub fn is_root_element(&self) -> bool {
-        self.is_root_element
-    }
-
     /// The current device.
     pub fn device(&self) -> &Device {
         self.builder.device
diff --git a/components/style/values/specified/length.rs b/components/style/values/specified/length.rs
index 3ac1f0a9762..71153c4e015 100644
--- a/components/style/values/specified/length.rs
+++ b/components/style/values/specified/length.rs
@@ -7,9 +7,9 @@
 //! [length]: https://drafts.csswg.org/css-values/#lengths
 
 use super::{AllowQuirks, Number, Percentage, ToComputedValue};
+use crate::computed_value_flags::ComputedValueFlags;
 use crate::font_metrics::{FontMetrics, FontMetricsOrientation};
 use crate::parser::{Parse, ParserContext};
-use crate::properties::computed_value_flags::ComputedValueFlags;
 use crate::values::computed::{self, CSSPixelLength, Context};
 use crate::values::generics::length as generics;
 use crate::values::generics::length::{
@@ -206,7 +206,7 @@ impl FontRelativeLength {
                 //     element, the rem units refer to the property's initial
                 //     value.
                 //
-                let reference_size = if context.is_root_element || context.in_media_query {
+                let reference_size = if context.builder.is_root_element || context.in_media_query {
                     reference_font_size
                 } else {
                     computed::Length::new(context.device().root_font_size().to_f32_px())
diff --git a/components/style/values/specified/text.rs b/components/style/values/specified/text.rs
index b1f5e1f5c3e..16df2fa4b4e 100644
--- a/components/style/values/specified/text.rs
+++ b/components/style/values/specified/text.rs
@@ -596,7 +596,7 @@ impl ToComputedValue for TextAlign {
                 // In that case, the default behavior here will set it to left,
                 // but we want to set it to right -- instead set it to the default (`start`),
                 // which will do the right thing in this case (but not the general case)
-                if _context.is_root_element {
+                if _context.builder.is_root_element {
                     return TextAlignKeyword::Start;
                 }
                 let parent = _context

From 625170ddd47665e97486cd834f8c176657d3eaba Mon Sep 17 00:00:00 2001
From: Thomas Dolezal <thomas.dolezal@mail.utoronto.ca>
Date: Sat, 1 Feb 2020 20:23:26 +0000
Subject: [PATCH 43/66] style: Replace transform style defines to an enum
 class.

Differential Revision: https://phabricator.services.mozilla.com/D61388
---
 components/style/properties/gecko.mako.rs     | 22 +------------------
 .../style/properties/longhands/box.mako.rs    |  2 +-
 components/style/values/generics/transform.rs |  3 +--
 3 files changed, 3 insertions(+), 24 deletions(-)

diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index 84dc8436940..ba9c4975851 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -53,7 +53,6 @@ use crate::values::computed::BorderStyle;
 use crate::values::computed::font::FontSize;
 use crate::values::generics::column::ColumnCount;
 use crate::values::generics::image::ImageLayer;
-use crate::values::generics::transform::TransformStyle;
 use crate::values::generics::url::UrlOrNone;
 
 
@@ -1473,7 +1472,7 @@ fn static_assert() {
                           animation-iteration-count animation-timing-function
                           clear transition-duration transition-delay
                           transition-timing-function transition-property
-                          transform-style shape-outside -webkit-line-clamp""" %>
+                          shape-outside -webkit-line-clamp""" %>
 <%self:impl_trait style_struct_name="Box" skip_longhands="${skip_box_longhands}">
     #[inline]
     pub fn set_display(&mut self, v: longhands::display::computed_value::T) {
@@ -1630,25 +1629,6 @@ fn static_assert() {
         self.copy_transition_property_from(other)
     }
 
-    // Hand-written because the Mako helpers transform `Preserve3d` into `PRESERVE3D`.
-    pub fn set_transform_style(&mut self, v: TransformStyle) {
-        self.gecko.mTransformStyle = match v {
-            TransformStyle::Flat => structs::NS_STYLE_TRANSFORM_STYLE_FLAT as u8,
-            TransformStyle::Preserve3d => structs::NS_STYLE_TRANSFORM_STYLE_PRESERVE_3D as u8,
-        };
-    }
-
-    // Hand-written because the Mako helpers transform `Preserve3d` into `PRESERVE3D`.
-    pub fn clone_transform_style(&self) -> TransformStyle {
-        match self.gecko.mTransformStyle as u32 {
-            structs::NS_STYLE_TRANSFORM_STYLE_FLAT => TransformStyle::Flat,
-            structs::NS_STYLE_TRANSFORM_STYLE_PRESERVE_3D => TransformStyle::Preserve3d,
-            _ => panic!("illegal transform style"),
-        }
-    }
-
-    ${impl_simple_copy('transform_style', 'mTransformStyle')}
-
     ${impl_transition_count('property', 'Property')}
 
     pub fn animations_equals(&self, other: &Self) -> bool {
diff --git a/components/style/properties/longhands/box.mako.rs b/components/style/properties/longhands/box.mako.rs
index 554699e1862..18772fa0164 100644
--- a/components/style/properties/longhands/box.mako.rs
+++ b/components/style/properties/longhands/box.mako.rs
@@ -592,7 +592,7 @@ ${helpers.single_keyword(
 ${helpers.predefined_type(
     "transform-style",
     "TransformStyle",
-    "computed::TransformStyle::" + ("Flat" if engine == "gecko" else "Auto"),
+    "computed::TransformStyle::Flat",
     engines="gecko servo-2013 servo-2020",
     servo_2020_pref="layout.2020.unimplemented",
     spec="https://drafts.csswg.org/css-transforms-2/#transform-style-property",
diff --git a/components/style/values/generics/transform.rs b/components/style/values/generics/transform.rs
index 6583f9ebe10..26e54ab8df4 100644
--- a/components/style/values/generics/transform.rs
+++ b/components/style/values/generics/transform.rs
@@ -820,9 +820,8 @@ pub use self::GenericTranslate as Translate;
     ToResolvedValue,
     ToShmem,
 )]
+#[repr(u8)]
 pub enum TransformStyle {
-    #[cfg(feature = "servo")]
-    Auto,
     Flat,
     #[css(keyword = "preserve-3d")]
     Preserve3d,

From 561de2f74877fc2caea8a23e79eddc0a76e48efb Mon Sep 17 00:00:00 2001
From: Thomas Dolezal <thomas.dolezal@mail.utoronto.ca>
Date: Sat, 1 Feb 2020 21:43:31 +0000
Subject: [PATCH 44/66] style: Converting empty-cells defines into enum class.

Differential Revision: https://phabricator.services.mozilla.com/D61398
---
 components/style/properties/longhands/inherited_table.mako.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/components/style/properties/longhands/inherited_table.mako.rs b/components/style/properties/longhands/inherited_table.mako.rs
index 06b42e802b6..488fe5d2659 100644
--- a/components/style/properties/longhands/inherited_table.mako.rs
+++ b/components/style/properties/longhands/inherited_table.mako.rs
@@ -20,7 +20,7 @@ ${helpers.single_keyword(
     "empty-cells",
     "show hide",
     engines="gecko servo-2013",
-    gecko_constant_prefix="NS_STYLE_TABLE_EMPTY_CELLS",
+    gecko_enum_prefix="StyleEmptyCells",
     animation_value_type="discrete",
     spec="https://drafts.csswg.org/css-tables/#propdef-empty-cells",
     servo_restyle_damage="rebuild_and_reflow",

From 127755551d940b7ade68ec7925c727554a0ad1cf Mon Sep 17 00:00:00 2001
From: Tim Nguyen <ntim.bugs@gmail.com>
Date: Mon, 3 Feb 2020 09:55:51 +0000
Subject: [PATCH 45/66] style: Remove nsGroupBoxFrame (display: -moz-groupbox).

Differential Revision: https://phabricator.services.mozilla.com/D61422
---
 components/style/values/specified/box.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/components/style/values/specified/box.rs b/components/style/values/specified/box.rs
index 2f114b5bb0a..11fbe6afb7b 100644
--- a/components/style/values/specified/box.rs
+++ b/components/style/values/specified/box.rs
@@ -106,8 +106,6 @@ pub enum DisplayInside {
     #[cfg(feature = "gecko")]
     MozDeck,
     #[cfg(feature = "gecko")]
-    MozGroupbox,
-    #[cfg(feature = "gecko")]
     MozPopup,
 }
 
@@ -231,8 +229,6 @@ impl Display {
     #[cfg(feature = "gecko")]
     pub const MozDeck: Self = Self::new(DisplayOutside::XUL, DisplayInside::MozDeck);
     #[cfg(feature = "gecko")]
-    pub const MozGroupbox: Self = Self::new(DisplayOutside::XUL, DisplayInside::MozGroupbox);
-    #[cfg(feature = "gecko")]
     pub const MozPopup: Self = Self::new(DisplayOutside::XUL, DisplayInside::MozPopup);
 
     /// Make a raw display value from <display-outside> and <display-inside> values.
@@ -623,8 +619,6 @@ impl Parse for Display {
             #[cfg(feature = "gecko")]
             "-moz-deck" if moz_display_values_enabled(context) => Display::MozDeck,
             #[cfg(feature = "gecko")]
-            "-moz-groupbox" if moz_display_values_enabled(context) => Display::MozGroupbox,
-            #[cfg(feature = "gecko")]
             "-moz-popup" if moz_display_values_enabled(context) => Display::MozPopup,
         })
     }

From 2910ca619765484b2ff33014688569ccc9be20e5 Mon Sep 17 00:00:00 2001
From: Jonathan Kew <jkew@mozilla.com>
Date: Mon, 3 Feb 2020 14:21:32 +0000
Subject: [PATCH 46/66] style: Support percentage values for the CSS
 text-decoration-thickness and text-underline-offset properties.

Differential Revision: https://phabricator.services.mozilla.com/D59777
---
 components/style/values/computed/text.rs  | 2 +-
 components/style/values/generics/text.rs  | 4 ++--
 components/style/values/specified/text.rs | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/components/style/values/computed/text.rs b/components/style/values/computed/text.rs
index 3f9ffb2ad0f..57a142860d9 100644
--- a/components/style/values/computed/text.rs
+++ b/components/style/values/computed/text.rs
@@ -28,7 +28,7 @@ pub use crate::values::specified::{TextDecorationSkipInk, TextTransform};
 pub type InitialLetter = GenericInitialLetter<CSSFloat, CSSInteger>;
 
 /// Implements type for `text-underline-offset` and `text-decoration-thickness` properties
-pub type TextDecorationLength = GenericTextDecorationLength<Length>;
+pub type TextDecorationLength = GenericTextDecorationLength<LengthPercentage>;
 
 /// A computed value for the `letter-spacing` property.
 #[repr(transparent)]
diff --git a/components/style/values/generics/text.rs b/components/style/values/generics/text.rs
index fd434cc1273..6ad983e00f9 100644
--- a/components/style/values/generics/text.rs
+++ b/components/style/values/generics/text.rs
@@ -124,7 +124,7 @@ impl<N, L> LineHeight<N, L> {
 }
 
 /// Implements type for text-underline-offset and text-decoration-thickness
-/// which take the grammar of auto | from-font | <length>
+/// which take the grammar of auto | from-font | <length> | <percentage>
 ///
 /// https://drafts.csswg.org/css-text-decor-4/
 #[repr(C, u8)]
@@ -148,7 +148,7 @@ impl<N, L> LineHeight<N, L> {
 )]
 #[allow(missing_docs)]
 pub enum GenericTextDecorationLength<L> {
-    Length(L),
+    LengthPercentage(L),
     Auto,
     FromFont,
 }
diff --git a/components/style/values/specified/text.rs b/components/style/values/specified/text.rs
index 16df2fa4b4e..835fefa292a 100644
--- a/components/style/values/specified/text.rs
+++ b/components/style/values/specified/text.rs
@@ -1030,7 +1030,7 @@ pub enum TextDecorationSkipInk {
 }
 
 /// Implements type for `text-underline-offset` and `text-decoration-thickness` properties
-pub type TextDecorationLength = GenericTextDecorationLength<Length>;
+pub type TextDecorationLength = GenericTextDecorationLength<LengthPercentage>;
 
 impl TextDecorationLength {
     /// `Auto` value.

From df01cec675b5b0b1918e516d9842cef4e1ae4bbb Mon Sep 17 00:00:00 2001
From: Jonathan Kew <jkew@mozilla.com>
Date: Mon, 3 Feb 2020 14:38:28 +0000
Subject: [PATCH 47/66] style: Move the from-font value from
 text-underline-offset to text-underline-position, as per recent spec changes,
 and fix interaction between position and offset.

Differential Revision: https://phabricator.services.mozilla.com/D59778
---
 .../longhands/inherited_text.mako.rs          |  4 +--
 components/style/values/computed/text.rs      |  2 +-
 components/style/values/generics/text.rs      |  4 +--
 components/style/values/specified/text.rs     | 26 ++++++++++++-------
 4 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/components/style/properties/longhands/inherited_text.mako.rs b/components/style/properties/longhands/inherited_text.mako.rs
index 9784e2529e9..f01bedb177e 100644
--- a/components/style/properties/longhands/inherited_text.mako.rs
+++ b/components/style/properties/longhands/inherited_text.mako.rs
@@ -382,8 +382,8 @@ ${helpers.single_keyword(
 // text underline offset
 ${helpers.predefined_type(
     "text-underline-offset",
-    "TextDecorationLength",
-    "generics::text::GenericTextDecorationLength::Auto",
+    "LengthPercentageOrAuto",
+    "computed::LengthPercentageOrAuto::auto()",
     engines="gecko",
     animation_value_type="ComputedValue",
     gecko_pref="layout.css.text-underline-offset.enabled",
diff --git a/components/style/values/computed/text.rs b/components/style/values/computed/text.rs
index 57a142860d9..0ca2e6044ed 100644
--- a/components/style/values/computed/text.rs
+++ b/components/style/values/computed/text.rs
@@ -27,7 +27,7 @@ pub use crate::values::specified::{TextDecorationSkipInk, TextTransform};
 /// A computed value for the `initial-letter` property.
 pub type InitialLetter = GenericInitialLetter<CSSFloat, CSSInteger>;
 
-/// Implements type for `text-underline-offset` and `text-decoration-thickness` properties
+/// Implements type for `text-decoration-thickness` property.
 pub type TextDecorationLength = GenericTextDecorationLength<LengthPercentage>;
 
 /// A computed value for the `letter-spacing` property.
diff --git a/components/style/values/generics/text.rs b/components/style/values/generics/text.rs
index 6ad983e00f9..ceeb59a3d0c 100644
--- a/components/style/values/generics/text.rs
+++ b/components/style/values/generics/text.rs
@@ -123,8 +123,8 @@ impl<N, L> LineHeight<N, L> {
     }
 }
 
-/// Implements type for text-underline-offset and text-decoration-thickness
-/// which take the grammar of auto | from-font | <length> | <percentage>
+/// Implements type for text-decoration-thickness
+/// which takes the grammar of auto | from-font | <length> | <percentage>
 ///
 /// https://drafts.csswg.org/css-text-decor-4/
 #[repr(C, u8)]
diff --git a/components/style/values/specified/text.rs b/components/style/values/specified/text.rs
index 835fefa292a..438b926802f 100644
--- a/components/style/values/specified/text.rs
+++ b/components/style/values/specified/text.rs
@@ -1029,7 +1029,7 @@ pub enum TextDecorationSkipInk {
     None,
 }
 
-/// Implements type for `text-underline-offset` and `text-decoration-thickness` properties
+/// Implements type for `text-decoration-thickness` property
 pub type TextDecorationLength = GenericTextDecorationLength<LengthPercentage>;
 
 impl TextDecorationLength {
@@ -1048,21 +1048,23 @@ impl TextDecorationLength {
 
 bitflags! {
     #[derive(MallocSizeOf, SpecifiedValueInfo, ToComputedValue, ToResolvedValue, ToShmem)]
-    #[value_info(other_values = "auto,under,left,right")]
+    #[value_info(other_values = "auto,from-font,under,left,right")]
     #[repr(C)]
     /// Specified keyword values for the text-underline-position property.
-    /// (Non-exclusive, but not all combinations are allowed: only `under` may occur
-    /// together with either `left` or `right`.)
-    /// https://drafts.csswg.org/css-text-decor-3/#text-underline-position-property
+    /// (Non-exclusive, but not all combinations are allowed: the spec grammar gives
+    /// `auto | [ from-font | under ] || [ left | right ]`.)
+    /// https://drafts.csswg.org/css-text-decor-4/#text-underline-position-property
     pub struct TextUnderlinePosition: u8 {
         /// Use automatic positioning below the alphabetic baseline.
         const AUTO = 0;
+        /// Use underline position from the first available font.
+        const FROM_FONT = 1 << 0;
         /// Below the glyph box.
-        const UNDER = 1 << 0;
+        const UNDER = 1 << 1;
         /// In vertical mode, place to the left of the text.
-        const LEFT = 1 << 1;
+        const LEFT = 1 << 2;
         /// In vertical mode, place to the right of the text.
-        const RIGHT = 1 << 2;
+        const RIGHT = 1 << 3;
     }
 }
 
@@ -1085,7 +1087,12 @@ impl Parse for TextUnderlinePosition {
                 "auto" if result.is_empty() => {
                     return Ok(result);
                 },
-                "under" if !result.intersects(TextUnderlinePosition::UNDER) => {
+                "from-font" if !result.intersects(TextUnderlinePosition::FROM_FONT |
+                                                  TextUnderlinePosition::UNDER) => {
+                    result.insert(TextUnderlinePosition::FROM_FONT);
+                },
+                "under" if !result.intersects(TextUnderlinePosition::FROM_FONT |
+                                              TextUnderlinePosition::UNDER) => {
                     result.insert(TextUnderlinePosition::UNDER);
                 },
                 "left" if !result.intersects(TextUnderlinePosition::LEFT |
@@ -1131,6 +1138,7 @@ impl ToCss for TextUnderlinePosition {
             };
         }
 
+        maybe_write!(FROM_FONT => "from-font");
         maybe_write!(UNDER => "under");
         maybe_write!(LEFT => "left");
         maybe_write!(RIGHT => "right");

From b038924d44cc3d991a227e0a575da8f77a76c231 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Wed, 22 Jan 2020 00:06:35 +0000
Subject: [PATCH 48/66] style: Try to collect some more crash information so
 that we can diagnose this better.

Differential Revision: https://phabricator.services.mozilla.com/D59704
---
 components/style/rule_tree/mod.rs | 39 ++++++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs
index fa859d79f06..1dbc17eaf34 100644
--- a/components/style/rule_tree/mod.rs
+++ b/components/style/rule_tree/mod.rs
@@ -136,6 +136,27 @@ impl StyleSource {
         let _ = write!(writer, "  -> {:?}", self.read(guard).declarations());
     }
 
+    // This is totally unsafe, should be removed when we figure out the cause of
+    // bug 1607553.
+    unsafe fn dump_unchecked<W: Write>(&self, writer: &mut W) {
+        if let Some(ref rule) = self.0.as_first() {
+            let rule = rule.read_unchecked();
+            let _ = write!(writer, "{:?}", rule.selectors);
+        }
+        let _ = write!(writer, "  -> {:?}", self.read_unchecked().declarations());
+    }
+
+    // This is totally unsafe, should be removed when we figure out the cause of
+    // bug 1607553.
+    #[inline]
+    unsafe fn read_unchecked(&self) -> &PropertyDeclarationBlock {
+        let block: &Locked<PropertyDeclarationBlock> = match self.0.borrow() {
+            ArcUnionBorrow::First(ref rule) => &rule.get().read_unchecked().block,
+            ArcUnionBorrow::Second(ref block) => block.get(),
+        };
+        block.read_unchecked()
+    }
+
     /// Read the style source guard, and obtain thus read access to the
     /// underlying property declaration block.
     #[inline]
@@ -1720,7 +1741,23 @@ impl Drop for StrongRuleNode {
         }
 
         if cfg!(debug_assertions) || crate::gecko_bindings::structs::GECKO_IS_NIGHTLY {
-            assert!(node.children.read().is_empty());
+            let children = node.children.read();
+            if !children.is_empty() {
+                let mut crash_str = vec![];
+                unsafe {
+                    // Try to unsafely collect some information of this before
+                    // crashing the process.
+                    if let Some(ref s) = node.source {
+                        s.dump_unchecked(&mut crash_str);
+                        crash_str.push(b'\n');
+                    }
+                    children.each(|child| {
+                        (*child.ptr()).source.as_ref().unwrap().dump_unchecked(&mut crash_str);
+                        crash_str.push(b'\n');
+                    });
+                }
+                panic!("Children left in the rule tree on drop: {}", String::from_utf8_lossy(&crash_str).trim());
+            }
         }
 
         if node.parent.is_none() {

From 48eff19ff31702ecfb8f1bd676d9ec3bd371c098 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Fri, 7 Feb 2020 00:40:55 +0000
Subject: [PATCH 49/66] style: Don't use a binary tree representation for
 calc() sums / products.

Keep a flat list of sum members. Simpify product and division ASAP.

I want to preserve the tree for a bit longer to implement min / max / clamp.
This doesn't do anything for it that we weren't doing already, but it helps to
eventually keep this specified representation and the equivalent computed
representation for <length-percentage> values.

Enable the tests for the comparison functions too, to prevent regressions.

Differential Revision: https://phabricator.services.mozilla.com/D61514
---
 components/style/values/specified/calc.rs | 218 +++++++++++++---------
 1 file changed, 130 insertions(+), 88 deletions(-)

diff --git a/components/style/values/specified/calc.rs b/components/style/values/specified/calc.rs
index 4fb3c009e04..6120c809b12 100644
--- a/components/style/values/specified/calc.rs
+++ b/components/style/values/specified/calc.rs
@@ -13,6 +13,7 @@ use crate::values::specified::length::{AbsoluteLength, FontRelativeLength, NoCal
 use crate::values::specified::{Angle, Time};
 use crate::values::{CSSFloat, CSSInteger};
 use cssparser::{AngleOrNumber, CowRcStr, NumberOrPercentage, Parser, Token};
+use smallvec::SmallVec;
 use std::fmt::{self, Write};
 use style_traits::values::specified::AllowedNumericType;
 use style_traits::{CssWriter, ParseError, SpecifiedValueInfo, StyleParseErrorKind, ToCss};
@@ -30,6 +31,15 @@ pub enum MathFunction {
     Clamp,
 }
 
+/// Whether we're a `min` or `max` function.
+#[derive(Copy, Clone, Debug)]
+pub enum MinMaxOp {
+    /// `min()`
+    Min,
+    /// `max()`
+    Max,
+}
+
 /// A node inside a `Calc` expression's AST.
 #[derive(Clone, Debug)]
 pub enum CalcNode {
@@ -43,18 +53,11 @@ pub enum CalcNode {
     Percentage(CSSFloat),
     /// `<number>`
     Number(CSSFloat),
-    /// An expression of the form `x + y`
-    Sum(Box<CalcNode>, Box<CalcNode>),
-    /// An expression of the form `x - y`
-    Sub(Box<CalcNode>, Box<CalcNode>),
-    /// An expression of the form `x * y`
-    Mul(Box<CalcNode>, Box<CalcNode>),
-    /// An expression of the form `x / y`
-    Div(Box<CalcNode>, Box<CalcNode>),
-    /// A `min()` function.
-    Min(Box<[CalcNode]>),
-    /// A `max()` function.
-    Max(Box<[CalcNode]>),
+    /// An expression of the form `x + y + ...`. Subtraction is represented by
+    /// the negated expression of the right hand side.
+    Sum(Box<[CalcNode]>),
+    /// A `min()` / `max()` function.
+    MinMax(Box<[CalcNode]>, MinMaxOp),
     /// A `clamp()` function.
     Clamp {
         /// The minimum value.
@@ -183,26 +186,12 @@ macro_rules! impl_generic_to_type {
         }
 
         Ok(match *$self {
-            Self::Sub(ref a, ref b) => $from_float(a.$to_self()?.$to_float() - b.$to_self()?.$to_float()),
-            Self::Sum(ref a, ref b) => $from_float(a.$to_self()?.$to_float() + b.$to_self()?.$to_float()),
-            Self::Mul(ref a, ref b) => match a.$to_self() {
-                Ok(lhs) => {
-                    let rhs = b.to_number()?;
-                    $from_float(lhs.$to_float() * rhs)
-                },
-                Err(..) => {
-                    let lhs = a.to_number()?;
-                    let rhs = b.$to_self()?;
-                    $from_float(lhs * rhs.$to_float())
-                },
-            },
-            Self::Div(ref a, ref b) => {
-                let lhs = a.$to_self()?;
-                let rhs = b.to_number()?;
-                if rhs == 0. {
-                    return Err(());
+            Self::Sum(ref expressions) => {
+                let mut sum = 0.;
+                for sub in &**expressions {
+                    sum += sub.$to_self()?.$to_float();
                 }
-                $from_float(lhs.$to_float() / rhs)
+                $from_float(sum)
             },
             Self::Clamp { ref min, ref center, ref max } => {
                 let min = min.$to_self()?;
@@ -221,25 +210,21 @@ macro_rules! impl_generic_to_type {
                 }
                 result
             },
-            Self::Min(ref nodes) => {
-                let mut min = nodes[0].$to_self()?;
+            Self::MinMax(ref nodes, op) => {
+                let mut result = nodes[0].$to_self()?;
                 for node in nodes.iter().skip(1) {
                     let candidate = node.$to_self()?;
-                    if candidate.$to_float() < min.$to_float() {
-                        min = candidate;
+                    let candidate_float = candidate.$to_float();
+                    let result_float = result.$to_float();
+                    let candidate_wins = match op {
+                        MinMaxOp::Min => candidate_float < result_float,
+                        MinMaxOp::Max => candidate_float > result_float,
+                    };
+                    if candidate_wins {
+                        result = candidate;
                     }
                 }
-                min
-            },
-            Self::Max(ref nodes) => {
-                let mut max = nodes[0].$to_self()?;
-                for node in nodes.iter().skip(1) {
-                    let candidate = node.$to_self()?;
-                    if candidate.$to_float() > max.$to_float() {
-                        max = candidate;
-                    }
-                }
-                max
+                result
             },
             Self::Length(..) |
             Self::Angle(..) |
@@ -251,6 +236,62 @@ macro_rules! impl_generic_to_type {
 }
 
 impl CalcNode {
+    fn negate(&mut self) {
+        self.mul_by(-1.);
+    }
+
+    fn mul_by(&mut self, scalar: f32) {
+        match *self {
+            Self::Length(ref mut l) => {
+                // FIXME: For consistency this should probably convert absolute
+                // lengths into pixels.
+                *l = *l * scalar;
+            },
+            Self::Number(ref mut n) => {
+                *n *= scalar;
+            },
+            Self::Angle(ref mut a) => {
+                *a = Angle::from_calc(a.degrees() * scalar);
+            },
+            Self::Time(ref mut t) => {
+                *t = Time::from_calc(t.seconds() * scalar);
+            },
+            Self::Percentage(ref mut p) => {
+                *p *= scalar;
+            },
+            // Multiplication is distributive across this.
+            Self::Sum(ref mut children) => {
+                for node in &mut **children {
+                    node.mul_by(scalar);
+                }
+            },
+            // This one is a bit trickier.
+            Self::MinMax(ref mut children, ref mut op) => {
+                for node in &mut **children {
+                    node.mul_by(scalar);
+                }
+
+                // For negatives we need to invert the operation.
+                if scalar < 0. {
+                    *op = match *op {
+                        MinMaxOp::Min => MinMaxOp::Max,
+                        MinMaxOp::Max => MinMaxOp::Min,
+                    }
+                }
+            },
+            // Multiplication is distributive across these.
+            Self::Clamp { ref mut min, ref mut center, ref mut max } => {
+                min.mul_by(scalar);
+                center.mul_by(scalar);
+                max.mul_by(scalar);
+                // For negatives we need to swap min / max.
+                if scalar < 0. {
+                    std::mem::swap(min, max);
+                }
+            },
+        }
+    }
+
     /// Tries to parse a single element in the expression, that is, a
     /// `<length>`, `<angle>`, `<time>`, `<percentage>`, according to
     /// `expected_unit`.
@@ -354,11 +395,13 @@ impl CalcNode {
                         Self::parse_argument(context, input, expected_unit)
                     })?.into_boxed_slice();
 
-                    Ok(match function {
-                        MathFunction::Min => Self::Min(arguments),
-                        MathFunction::Max => Self::Max(arguments),
+                    let op = match function {
+                        MathFunction::Min => MinMaxOp::Min,
+                        MathFunction::Max => MinMaxOp::Max,
                         _ => unreachable!(),
-                    })
+                    };
+
+                    Ok(Self::MinMax(arguments, op))
                 }
             }
         })
@@ -369,7 +412,8 @@ impl CalcNode {
         input: &mut Parser<'i, 't>,
         expected_unit: CalcUnit,
     ) -> Result<Self, ParseError<'i>> {
-        let mut root = Self::parse_product(context, input, expected_unit)?;
+        let mut sum = SmallVec::<[CalcNode; 1]>::new();
+        sum.push(Self::parse_product(context, input, expected_unit)?);
 
         loop {
             let start = input.state();
@@ -380,14 +424,12 @@ impl CalcNode {
                     }
                     match *input.next()? {
                         Token::Delim('+') => {
-                            let rhs = Self::parse_product(context, input, expected_unit)?;
-                            let new_root = CalcNode::Sum(Box::new(root), Box::new(rhs));
-                            root = new_root;
+                            sum.push(Self::parse_product(context, input, expected_unit)?);
                         },
                         Token::Delim('-') => {
-                            let rhs = Self::parse_product(context, input, expected_unit)?;
-                            let new_root = CalcNode::Sub(Box::new(root), Box::new(rhs));
-                            root = new_root;
+                            let mut rhs = Self::parse_product(context, input, expected_unit)?;
+                            rhs.negate();
+                            sum.push(rhs);
                         },
                         ref t => {
                             let t = t.clone();
@@ -402,7 +444,11 @@ impl CalcNode {
             }
         }
 
-        Ok(root)
+        Ok(if sum.len() == 1 {
+            sum.drain(..).next().unwrap()
+        } else {
+            Self::Sum(sum.into_boxed_slice())
+        })
     }
 
     /// Parse a top-level `calc` expression, and all the products that may
@@ -419,20 +465,36 @@ impl CalcNode {
         input: &mut Parser<'i, 't>,
         expected_unit: CalcUnit,
     ) -> Result<Self, ParseError<'i>> {
-        let mut root = Self::parse_one(context, input, expected_unit)?;
+        let mut node = Self::parse_one(context, input, expected_unit)?;
 
         loop {
             let start = input.state();
             match input.next() {
                 Ok(&Token::Delim('*')) => {
                     let rhs = Self::parse_one(context, input, expected_unit)?;
-                    let new_root = CalcNode::Mul(Box::new(root), Box::new(rhs));
-                    root = new_root;
+                    if let Ok(rhs) = rhs.to_number() {
+                        node.mul_by(rhs);
+                    } else if let Ok(number) = node.to_number() {
+                        node = rhs;
+                        node.mul_by(number);
+                    } else {
+                        // One of the two parts of the multiplication has to be
+                        // a number, at least until we implement unit math.
+                        return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
+                    }
                 },
                 Ok(&Token::Delim('/')) => {
                     let rhs = Self::parse_one(context, input, expected_unit)?;
-                    let new_root = CalcNode::Div(Box::new(root), Box::new(rhs));
-                    root = new_root;
+                    // Dividing by units is not ok.
+                    //
+                    // TODO(emilio): Eventually it should be.
+                    let number = match rhs.to_number() {
+                        Ok(n) if n != 0. => n,
+                        _ => {
+                            return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
+                        },
+                    };
+                    node.mul_by(1. / number);
                 },
                 _ => {
                     input.reset(&start);
@@ -441,7 +503,7 @@ impl CalcNode {
             }
         }
 
-        Ok(root)
+        Ok(node)
     }
 
     /// Tries to simplify this expression into a `<length>` or `<percentage`>
@@ -510,32 +572,12 @@ impl CalcNode {
                 },
                 NoCalcLength::ServoCharacterWidth(..) => unreachable!(),
             },
-            CalcNode::Sub(ref a, ref b) => {
-                a.add_length_or_percentage_to(ret, factor)?;
-                b.add_length_or_percentage_to(ret, factor * -1.0)?;
-            },
-            CalcNode::Sum(ref a, ref b) => {
-                a.add_length_or_percentage_to(ret, factor)?;
-                b.add_length_or_percentage_to(ret, factor)?;
-            },
-            CalcNode::Mul(ref a, ref b) => match b.to_number() {
-                Ok(rhs) => {
-                    a.add_length_or_percentage_to(ret, factor * rhs)?;
-                },
-                Err(..) => {
-                    let lhs = a.to_number()?;
-                    b.add_length_or_percentage_to(ret, factor * lhs)?;
-                },
-            },
-            CalcNode::Div(ref a, ref b) => {
-                let new_factor = b.to_number()?;
-                if new_factor == 0. {
-                    return Err(());
+            CalcNode::Sum(ref children) => {
+                for child in &**children {
+                    child.add_length_or_percentage_to(ret, factor)?;
                 }
-                a.add_length_or_percentage_to(ret, factor / new_factor)?;
             },
-            CalcNode::Max(..) |
-            CalcNode::Min(..) |
+            CalcNode::MinMax(..) |
             CalcNode::Clamp { .. } => {
                 // FIXME(emilio): Implement min/max/clamp for length-percentage.
                 return Err(())

From 07027fc9239f8d4eb74e9079efd69b1cbdc519db Mon Sep 17 00:00:00 2001
From: Thomas Dolezal <thomas.dolezal@mail.utoronto.ca>
Date: Fri, 7 Feb 2020 12:35:30 +0000
Subject: [PATCH 50/66] style: style: convert ns style position defines to enum
 class.

Differential Revision: https://phabricator.services.mozilla.com/D61958
---
 components/style/properties/longhands/box.mako.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/style/properties/longhands/box.mako.rs b/components/style/properties/longhands/box.mako.rs
index 18772fa0164..90c8dc539d8 100644
--- a/components/style/properties/longhands/box.mako.rs
+++ b/components/style/properties/longhands/box.mako.rs
@@ -47,6 +47,7 @@ ${helpers.single_keyword(
     values="static absolute relative fixed ${'sticky' if engine in ['gecko', 'servo-2013'] else ''}"
     engines="gecko servo-2013 servo-2020"
     animation_value_type="discrete"
+    gecko_enum_prefix="StylePositionProperty"
     flags="CREATES_STACKING_CONTEXT ABSPOS_CB"
     spec="https://drafts.csswg.org/css-position/#position-property"
     servo_restyle_damage="rebuild_and_reflow"

From 97382a2c415c6526491a1b13cb0ad4c69d3fa0c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Fri, 7 Feb 2020 20:36:34 +0000
Subject: [PATCH 51/66] style: Remove nsStyleImageRequest.

This removes nsStyleImageRequest by moving the load state to LoadData instead
(where other lazy state like the resolved URL and load id lives).

That way we can use cbindgen for more stuff (there's no blocker for using it for
all images now), and we can undo the image tracking shenanigans that I had to do
in bug 1605803 in nsImageFrame.

This removes the mDocGroup member because well, there's no real upside of that
now that quantum DOM is not a thing.

It also removes the static clones of the image requests, and the need for each
computed value instance to have its own request. These were needed because we
needed the image loader for the particular document to observe the image
changes. But we were also tracking the request -> loader for other purposes.
Instead, Now all the images get loaded with GlobalImageObserver as a listener,
which looks in the image map and forwards the notification to all the interested
loaders instead dynamically.

The style value is only responsible to load the image, and no longer tracks /
locks it. Instead, the loader does so, via the image tracker.

Differential Revision: https://phabricator.services.mozilla.com/D58519
---
 components/style/gecko/conversions.rs     | 10 +---
 components/style/gecko/url.rs             | 54 +++++++++++++---------
 components/style/properties/gecko.mako.rs | 56 ++---------------------
 3 files changed, 38 insertions(+), 82 deletions(-)

diff --git a/components/style/gecko/conversions.rs b/components/style/gecko/conversions.rs
index 9bc9573bf91..3deaeacadc8 100644
--- a/components/style/gecko/conversions.rs
+++ b/components/style/gecko/conversions.rs
@@ -15,7 +15,6 @@ use crate::gecko_bindings::structs::{self, Matrix4x4Components};
 use crate::gecko_bindings::structs::{nsStyleImage, nsresult};
 use crate::stylesheets::RulesMutateError;
 use crate::values::computed::transform::Matrix3D;
-use crate::values::computed::url::ComputedImageUrl;
 use crate::values::computed::{Gradient, Image, TextAlign};
 use crate::values::generics::image::GenericImage;
 use crate::values::generics::rect::Rect;
@@ -63,7 +62,7 @@ impl nsStyleImage {
         match self.mType {
             nsStyleImageType::eStyleImageType_Null => None,
             nsStyleImageType::eStyleImageType_Image => {
-                let url = self.get_image_url();
+                let url = self.__bindgen_anon_1.mImage.as_ref().clone();
                 if self.mCropRect.mPtr.is_null() {
                     Some(GenericImage::Url(url))
                 } else {
@@ -88,13 +87,6 @@ impl nsStyleImage {
             },
         }
     }
-
-    unsafe fn get_image_url(&self) -> ComputedImageUrl {
-        let image_request = bindings::Gecko_GetImageRequest(self)
-            .as_ref()
-            .expect("Null image request?");
-        ComputedImageUrl::from_image_request(image_request)
-    }
 }
 
 pub mod basic_shape {
diff --git a/components/style/gecko/url.rs b/components/style/gecko/url.rs
index 3a53f639afe..27f3c60884c 100644
--- a/components/style/gecko/url.rs
+++ b/components/style/gecko/url.rs
@@ -6,8 +6,6 @@
 
 use crate::gecko_bindings::bindings;
 use crate::gecko_bindings::structs;
-use crate::gecko_bindings::structs::nsStyleImageRequest;
-use crate::gecko_bindings::sugar::refptr::RefPtr;
 use crate::parser::{Parse, ParserContext};
 use crate::stylesheets::{CorsMode, UrlExtraData};
 use crate::values::computed::{Context, ToComputedValue};
@@ -150,31 +148,52 @@ struct LoadDataKey(*const LoadDataSource);
 unsafe impl Sync for LoadDataKey {}
 unsafe impl Send for LoadDataKey {}
 
-/// The load data for a given URL. This is mutable from C++, for now at least.
+bitflags! {
+    /// Various bits of mutable state that are kept for image loads.
+    #[repr(C)]
+    pub struct LoadDataFlags: u8 {
+        /// Whether we tried to resolve the uri at least once.
+        const TRIED_TO_RESOLVE_URI = 1 << 0;
+        /// Whether we tried to resolve the image at least once.
+        const TRIED_TO_RESOLVE_IMAGE = 1 << 1;
+    }
+}
+
+/// This is usable and movable from multiple threads just fine, as long as it's
+/// not cloned (it is not clonable), and the methods that mutate it run only on
+/// the main thread (when all the other threads we care about are paused).
+unsafe impl Sync for LoadData {}
+unsafe impl Send for LoadData {}
+
+/// The load data for a given URL. This is mutable from C++, and shouldn't be
+/// accessed from rust for anything.
 #[repr(C)]
 #[derive(Debug)]
 pub struct LoadData {
-    resolved: RefPtr<structs::nsIURI>,
-    load_id: u64,
-    tried_to_resolve: bool,
+    /// A strong reference to the imgRequestProxy, if any, that should be
+    /// released on drop.
+    ///
+    /// These are raw pointers because they are not safe to reference-count off
+    /// the main thread.
+    resolved_image: *mut structs::imgRequestProxy,
+    /// A strong reference to the resolved URI of this image.
+    resolved_uri: *mut structs::nsIURI,
+    /// A few flags that are set when resolving the image or such.
+    flags: LoadDataFlags,
 }
 
 impl Drop for LoadData {
     fn drop(&mut self) {
-        if self.load_id != 0 {
-            unsafe {
-                bindings::Gecko_LoadData_DeregisterLoad(self);
-            }
-        }
+        unsafe { bindings::Gecko_LoadData_Drop(self) }
     }
 }
 
 impl Default for LoadData {
     fn default() -> Self {
         Self {
-            resolved: RefPtr::null(),
-            load_id: 0,
-            tried_to_resolve: false,
+            resolved_image: std::ptr::null_mut(),
+            resolved_uri: std::ptr::null_mut(),
+            flags: LoadDataFlags::empty(),
         }
     }
 }
@@ -342,13 +361,6 @@ impl ToCss for ComputedUrl {
 #[repr(transparent)]
 pub struct ComputedImageUrl(pub ComputedUrl);
 
-impl ComputedImageUrl {
-    /// Convert from nsStyleImageRequest to ComputedImageUrl.
-    pub unsafe fn from_image_request(image_request: &nsStyleImageRequest) -> Self {
-        image_request.mImageURL.clone()
-    }
-}
-
 impl ToCss for ComputedImageUrl {
     fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
     where
diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index ba9c4975851..6cfb4c859b4 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -25,14 +25,9 @@ use crate::gecko_bindings::bindings::Gecko_CopyCounterStyle;
 use crate::gecko_bindings::bindings::Gecko_CopyCursorArrayFrom;
 use crate::gecko_bindings::bindings::Gecko_CopyFontFamilyFrom;
 use crate::gecko_bindings::bindings::Gecko_CopyImageValueFrom;
-use crate::gecko_bindings::bindings::Gecko_CopyListStyleImageFrom;
 use crate::gecko_bindings::bindings::Gecko_EnsureImageLayersLength;
-use crate::gecko_bindings::bindings::Gecko_SetCursorArrayLength;
-use crate::gecko_bindings::bindings::Gecko_SetCursorImageValue;
 use crate::gecko_bindings::bindings::Gecko_nsStyleFont_SetLang;
 use crate::gecko_bindings::bindings::Gecko_nsStyleFont_CopyLangFrom;
-use crate::gecko_bindings::bindings::Gecko_SetListStyleImageNone;
-use crate::gecko_bindings::bindings::Gecko_SetListStyleImageImageValue;
 use crate::gecko_bindings::bindings::Gecko_SetNullImageValue;
 use crate::gecko_bindings::structs;
 use crate::gecko_bindings::structs::nsCSSPropertyID;
@@ -53,7 +48,6 @@ use crate::values::computed::BorderStyle;
 use crate::values::computed::font::FontSize;
 use crate::values::generics::column::ColumnCount;
 use crate::values::generics::image::ImageLayer;
-use crate::values::generics::url::UrlOrNone;
 
 
 pub mod style_structs {
@@ -2108,43 +2102,7 @@ fn static_assert() {
     <% impl_simple_image_array_property("blend_mode", "background", "mImage", "mBlendMode", "Background") %>
 </%self:impl_trait>
 
-<%self:impl_trait style_struct_name="List"
-                  skip_longhands="list-style-image list-style-type">
-
-    pub fn set_list_style_image(&mut self, image: longhands::list_style_image::computed_value::T) {
-        match image {
-            UrlOrNone::None => {
-                unsafe {
-                    Gecko_SetListStyleImageNone(&mut *self.gecko);
-                }
-            }
-            UrlOrNone::Url(ref url) => {
-                unsafe {
-                    Gecko_SetListStyleImageImageValue(&mut *self.gecko, url);
-                }
-            }
-        }
-    }
-
-    pub fn copy_list_style_image_from(&mut self, other: &Self) {
-        unsafe { Gecko_CopyListStyleImageFrom(&mut *self.gecko, &*other.gecko); }
-    }
-
-    pub fn reset_list_style_image(&mut self, other: &Self) {
-        self.copy_list_style_image_from(other)
-    }
-
-    pub fn clone_list_style_image(&self) -> longhands::list_style_image::computed_value::T {
-        if self.gecko.mListStyleImage.mRawPtr.is_null() {
-            return UrlOrNone::None;
-        }
-
-        unsafe {
-            let ref gecko_image_request = *self.gecko.mListStyleImage.mRawPtr;
-            UrlOrNone::Url(ComputedImageUrl::from_image_request(gecko_image_request))
-        }
-    }
-
+<%self:impl_trait style_struct_name="List" skip_longhands="list-style-type">
     pub fn set_list_style_type(&mut self, v: longhands::list_style_type::computed_value::T) {
         use nsstring::{nsACString, nsCStr};
         use self::longhands::list_style_type::computed_value::T;
@@ -2433,14 +2391,11 @@ clip-path
     pub fn set_cursor(&mut self, v: longhands::cursor::computed_value::T) {
         self.gecko.mCursor = v.keyword;
         unsafe {
-            Gecko_SetCursorArrayLength(&mut *self.gecko, v.images.len());
+            bindings::Gecko_SetCursorArrayCapacity(&mut *self.gecko, v.images.len());
         }
         for i in 0..v.images.len() {
             unsafe {
-                Gecko_SetCursorImageValue(
-                    &mut self.gecko.mCursorImages[i],
-                    &v.images[i].url
-                );
+                bindings::Gecko_AppendCursorImage(&mut *self.gecko, &v.images[i].url);
             }
 
             match v.images[i].hotspot {
@@ -2473,10 +2428,7 @@ clip-path
         let keyword = self.gecko.mCursor;
 
         let images = self.gecko.mCursorImages.iter().map(|gecko_cursor_image| {
-            let url = unsafe {
-                let gecko_image_request = gecko_cursor_image.mImage.mRawPtr.as_ref().unwrap();
-                ComputedImageUrl::from_image_request(&gecko_image_request)
-            };
+            let url = gecko_cursor_image.mImage.clone();
 
             let hotspot =
                 if gecko_cursor_image.mHaveHotspot {

From 5ed8fe8ee2145702f2a9d7288caca95b03aed99a Mon Sep 17 00:00:00 2001
From: Tim Nguyen <ntim.bugs@gmail.com>
Date: Sun, 9 Feb 2020 15:11:43 +0000
Subject: [PATCH 52/66] style: Add AngleOrPercentage to style system.

Differential Revision: https://phabricator.services.mozilla.com/D62158
---
 components/style/values/computed/mod.rs    | 48 ++++++++++++++++++++++
 components/style/values/specified/angle.rs |  5 ++-
 components/style/values/specified/mod.rs   | 43 ++++++++++++++++++-
 3 files changed, 93 insertions(+), 3 deletions(-)

diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs
index da5c84aed39..aaa2677777b 100644
--- a/components/style/values/computed/mod.rs
+++ b/components/style/values/computed/mod.rs
@@ -465,6 +465,54 @@ trivial_to_computed_value!(String);
 trivial_to_computed_value!(Box<str>);
 trivial_to_computed_value!(crate::OwnedStr);
 
+#[allow(missing_docs)]
+#[derive(
+    Animate,
+    Clone,
+    ComputeSquaredDistance,
+    Copy,
+    Debug,
+    MallocSizeOf,
+    PartialEq,
+    ToAnimatedZero,
+    ToCss,
+    ToResolvedValue,
+)]
+#[repr(C, u8)]
+pub enum AngleOrPercentage {
+    Percentage(Percentage),
+    Angle(Angle),
+}
+
+impl ToComputedValue for specified::AngleOrPercentage {
+    type ComputedValue = AngleOrPercentage;
+
+    #[inline]
+    fn to_computed_value(&self, context: &Context) -> AngleOrPercentage {
+        match *self {
+            specified::AngleOrPercentage::Percentage(percentage) => {
+                AngleOrPercentage::Percentage(percentage.to_computed_value(context))
+            },
+            specified::AngleOrPercentage::Angle(angle) => {
+                AngleOrPercentage::Angle(angle.to_computed_value(context))
+            },
+        }
+    }
+    #[inline]
+    fn from_computed_value(computed: &AngleOrPercentage) -> Self {
+        match *computed {
+            AngleOrPercentage::Percentage(percentage) => {
+                specified::AngleOrPercentage::Percentage(ToComputedValue::from_computed_value(
+                    &percentage,
+                ))
+            },
+            AngleOrPercentage::Angle(angle) => {
+                specified::AngleOrPercentage::Angle(ToComputedValue::from_computed_value(&angle))
+            },
+        }
+    }
+}
+
 /// A `<number>` value.
 pub type Number = CSSFloat;
 
diff --git a/components/style/values/specified/angle.rs b/components/style/values/specified/angle.rs
index 6485bca6f8f..b42d5d5038f 100644
--- a/components/style/values/specified/angle.rs
+++ b/components/style/values/specified/angle.rs
@@ -163,7 +163,8 @@ impl Angle {
 ///   https://github.com/w3c/fxtf-drafts/issues/228
 ///
 /// See also: https://github.com/w3c/csswg-drafts/issues/1162.
-enum AllowUnitlessZeroAngle {
+#[allow(missing_docs)]
+pub enum AllowUnitlessZeroAngle {
     Yes,
     No,
 }
@@ -203,7 +204,7 @@ impl Angle {
         Self::parse_internal(context, input, AllowUnitlessZeroAngle::Yes)
     }
 
-    fn parse_internal<'i, 't>(
+    pub(super) fn parse_internal<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
         allow_unitless_zero: AllowUnitlessZeroAngle,
diff --git a/components/style/values/specified/mod.rs b/components/style/values/specified/mod.rs
index 8399456a491..2d8160b17b9 100644
--- a/components/style/values/specified/mod.rs
+++ b/components/style/values/specified/mod.rs
@@ -31,7 +31,7 @@ use style_traits::{CssWriter, ParseError, SpecifiedValueInfo, StyleParseErrorKin
 pub use self::align::{AlignContent, AlignItems, AlignSelf, ContentDistribution};
 #[cfg(feature = "gecko")]
 pub use self::align::{JustifyContent, JustifyItems, JustifySelf, SelfAlignment};
-pub use self::angle::Angle;
+pub use self::angle::{Angle, AllowUnitlessZeroAngle};
 pub use self::background::{BackgroundRepeat, BackgroundSize};
 pub use self::basic_shape::FillRule;
 pub use self::border::{BorderCornerRadius, BorderImageSlice, BorderImageWidth};
@@ -130,6 +130,47 @@ pub mod transform;
 pub mod ui;
 pub mod url;
 
+/// <angle> | <percentage>
+/// https://drafts.csswg.org/css-values/#typedef-angle-percentage
+#[allow(missing_docs)]
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss, ToShmem)]
+pub enum AngleOrPercentage {
+    Percentage(Percentage),
+    Angle(Angle),
+}
+
+impl AngleOrPercentage {
+    fn parse_internal<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+        allow_unitless_zero: AllowUnitlessZeroAngle,
+    ) -> Result<Self, ParseError<'i>> {
+        if let Ok(per) = input.try(|i| Percentage::parse(context, i)) {
+            return Ok(AngleOrPercentage::Percentage(per));
+        }
+
+        Angle::parse_internal(context, input, allow_unitless_zero).map(AngleOrPercentage::Angle)
+    }
+
+    /// Allow unitless angles, used for conic-gradients as specified by the spec.
+    /// https://drafts.csswg.org/css-images-4/#valdef-conic-gradient-angle
+    pub fn parse_with_unitless<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self, ParseError<'i>> {
+        AngleOrPercentage::parse_internal(context, input, AllowUnitlessZeroAngle::Yes)
+    }
+}
+
+impl Parse for AngleOrPercentage {
+    fn parse<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<Self, ParseError<'i>> {
+        AngleOrPercentage::parse_internal(context, input, AllowUnitlessZeroAngle::No)
+    }
+}
+
 /// Parse a `<number>` value, with a given clamping mode.
 fn parse_number_with_clamping_mode<'i, 't>(
     context: &ParserContext,

From 6876fed6e0238d3da2cfd4a022fcf75aa2225698 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 00:37:36 +0000
Subject: [PATCH 53/66] style: Fix two issues with themed widgets in high
 contrast mode.

There were two issues with the existing code that we use to determine whether a
widget is styled or not.

First, it was using `color == Color::transparent()` instead of
`color.is_transparent()` to check for transparent backgrounds. That is not sound
as `Color::transparent()` is the literal value `rgba(0, 0, 0, 0)`, not the
`transparent` keyword, so the equality check would fail.

The other issue is that this function was early-returning false if that check
was returning false. It is a bug for this function to early-return false, as it
makes the result of the function dependent of the order of the declarations.

Differential Revision: https://phabricator.services.mozilla.com/D62060
---
 components/style/rule_tree/mod.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs
index 1dbc17eaf34..8a36e2f20d2 100644
--- a/components/style/rule_tree/mod.rs
+++ b/components/style/rule_tree/mod.rs
@@ -1458,7 +1458,6 @@ impl StrongRuleNode {
         use crate::gecko_bindings::structs::NS_AUTHOR_SPECIFIED_PADDING;
         use crate::properties::{CSSWideKeyword, LonghandId};
         use crate::properties::{PropertyDeclaration, PropertyDeclarationId};
-        use crate::values::specified::Color;
         use std::borrow::Cow;
 
         // Reset properties:
@@ -1581,11 +1580,11 @@ impl StrongRuleNode {
 
                     if is_author {
                         if !author_colors_allowed {
-                            // FIXME(emilio): this looks wrong, this should
-                            // do: if color is not transparent, then return
-                            // true, or something.
                             if let PropertyDeclaration::BackgroundColor(ref color) = *declaration {
-                                return *color == Color::transparent();
+                                if color.is_transparent() {
+                                    return true;
+                                }
+                                continue;
                             }
                         }
                         return true;

From 71b414f9dc91c7631674ee8b996ea01c92bb4bb4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 13:51:49 +0000
Subject: [PATCH 54/66] style: Make rust generate better code for
 derive(Animate) and derive(ComputeSquaredDistance).

See https://github.com/rust-lang/rust/issues/68867.

This technically changes the semantics of #[animate(fallback)] and such when
combined with #[animate(error)]. But no such combination exists and the new
semantics are perfectly reasonable as well, IMHO.

Differential Revision: https://phabricator.services.mozilla.com/D61761
---
 components/style/values/animated/mod.rs       |   2 +-
 components/style/values/distance.rs           |   2 +-
 components/style_derive/animate.rs            |  55 +++----
 .../style_derive/compute_squared_distance.rs  | 135 ++++++++++--------
 4 files changed, 105 insertions(+), 89 deletions(-)

diff --git a/components/style/values/animated/mod.rs b/components/style/values/animated/mod.rs
index 7cac407adcb..7e699542fd4 100644
--- a/components/style/values/animated/mod.rs
+++ b/components/style/values/animated/mod.rs
@@ -107,7 +107,7 @@ pub fn animate_multiplicative_factor(
 /// be equal or an error is returned.
 ///
 /// If a variant is annotated with `#[animation(error)]`, the corresponding
-/// `match` arm is not generated.
+/// `match` arm returns an error.
 ///
 /// If the two values are not similar, an error is returned unless a fallback
 /// function has been specified through `#[animate(fallback)]`.
diff --git a/components/style/values/distance.rs b/components/style/values/distance.rs
index a1872366c2a..67c735676b5 100644
--- a/components/style/values/distance.rs
+++ b/components/style/values/distance.rs
@@ -17,7 +17,7 @@ use std::ops::Add;
 /// on each fields of the values.
 ///
 /// If a variant is annotated with `#[animation(error)]`, the corresponding
-/// `match` arm is not generated.
+/// `match` arm returns an error.
 ///
 /// If the two values are not similar, an error is returned unless a fallback
 /// function has been specified through `#[distance(fallback)]`.
diff --git a/components/style_derive/animate.rs b/components/style_derive/animate.rs
index 4d8581a8f2b..190568514fc 100644
--- a/components/style_derive/animate.rs
+++ b/components/style_derive/animate.rs
@@ -11,6 +11,8 @@ use synstructure::{Structure, VariantInfo};
 
 pub fn derive(mut input: DeriveInput) -> TokenStream {
     let animation_input_attrs = cg::parse_input_attrs::<AnimationInputAttrs>(&input);
+    let input_attrs = cg::parse_input_attrs::<AnimateInputAttrs>(&input);
+
     let no_bound = animation_input_attrs.no_bound.unwrap_or_default();
     let mut where_clause = input.generics.where_clause.take();
     for param in input.generics.type_params() {
@@ -21,39 +23,32 @@ pub fn derive(mut input: DeriveInput) -> TokenStream {
             );
         }
     }
-    let (mut match_body, append_error_clause) = {
+    let (mut match_body, needs_catchall_branch) = {
         let s = Structure::new(&input);
-        let mut append_error_clause = s.variants().len() > 1;
-
+        let needs_catchall_branch = s.variants().len() > 1;
         let match_body = s.variants().iter().fold(quote!(), |body, variant| {
-            let arm = match derive_variant_arm(variant, &mut where_clause) {
-                Ok(arm) => arm,
-                Err(()) => {
-                    append_error_clause = true;
-                    return body;
-                },
-            };
+            let arm = derive_variant_arm(variant, &mut where_clause);
             quote! { #body #arm }
         });
-        (match_body, append_error_clause)
+        (match_body, needs_catchall_branch)
     };
 
     input.generics.where_clause = where_clause;
 
-    if append_error_clause {
-        let input_attrs = cg::parse_input_attrs::<AnimateInputAttrs>(&input);
-        if let Some(fallback) = input_attrs.fallback {
-            match_body.append_all(quote! {
-                (this, other) => #fallback(this, other, procedure)
-            });
-        } else {
-            match_body.append_all(quote! { _ => Err(()) });
-        }
+    if needs_catchall_branch {
+        // This ideally shouldn't be needed, but see
+        // https://github.com/rust-lang/rust/issues/68867
+        match_body.append_all(quote! { _ => unsafe { debug_unreachable!() } });
     }
 
     let name = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
 
+    let fallback = match input_attrs.fallback {
+        Some(fallback) => quote! { #fallback(self, other, procedure) },
+        None => quote! { Err(()) },
+    };
+
     quote! {
         impl #impl_generics crate::values::animated::Animate for #name #ty_generics #where_clause {
             #[allow(unused_variables, unused_imports)]
@@ -63,6 +58,9 @@ pub fn derive(mut input: DeriveInput) -> TokenStream {
                 other: &Self,
                 procedure: crate::values::animated::Procedure,
             ) -> Result<Self, ()> {
+                if std::mem::discriminant(self) != std::mem::discriminant(other) {
+                    return #fallback;
+                }
                 match (self, other) {
                     #match_body
                 }
@@ -74,13 +72,17 @@ pub fn derive(mut input: DeriveInput) -> TokenStream {
 fn derive_variant_arm(
     variant: &VariantInfo,
     where_clause: &mut Option<WhereClause>,
-) -> Result<TokenStream, ()> {
+) -> TokenStream {
     let variant_attrs = cg::parse_variant_attrs_from_ast::<AnimationVariantAttrs>(&variant.ast());
-    if variant_attrs.error {
-        return Err(());
-    }
     let (this_pattern, this_info) = cg::ref_pattern(&variant, "this");
     let (other_pattern, other_info) = cg::ref_pattern(&variant, "other");
+
+    if variant_attrs.error {
+        return quote! {
+            (&#this_pattern, &#other_pattern) => Err(()),
+        };
+    }
+
     let (result_value, result_info) = cg::value(&variant, "result");
     let mut computations = quote!();
     let iter = result_info.iter().zip(this_info.iter().zip(&other_info));
@@ -107,12 +109,13 @@ fn derive_variant_arm(
             }
         }
     }));
-    Ok(quote! {
+
+    quote! {
         (&#this_pattern, &#other_pattern) => {
             #computations
             Ok(#result_value)
         }
-    })
+    }
 }
 
 #[darling(attributes(animate), default)]
diff --git a/components/style_derive/compute_squared_distance.rs b/components/style_derive/compute_squared_distance.rs
index 9c5f7ec80d1..5e130e75b06 100644
--- a/components/style_derive/compute_squared_distance.rs
+++ b/components/style_derive/compute_squared_distance.rs
@@ -6,11 +6,12 @@ use crate::animate::{AnimationFieldAttrs, AnimationInputAttrs, AnimationVariantA
 use derive_common::cg;
 use proc_macro2::TokenStream;
 use quote::TokenStreamExt;
-use syn::{DeriveInput, Path};
+use syn::{DeriveInput, Path, WhereClause};
 use synstructure;
 
 pub fn derive(mut input: DeriveInput) -> TokenStream {
     let animation_input_attrs = cg::parse_input_attrs::<AnimationInputAttrs>(&input);
+    let input_attrs = cg::parse_input_attrs::<DistanceInputAttrs>(&input);
     let no_bound = animation_input_attrs.no_bound.unwrap_or_default();
     let mut where_clause = input.generics.where_clause.take();
     for param in input.generics.type_params() {
@@ -22,76 +23,31 @@ pub fn derive(mut input: DeriveInput) -> TokenStream {
         }
     }
 
-    let (mut match_body, append_error_clause) = {
+    let (mut match_body, needs_catchall_branch) = {
         let s = synstructure::Structure::new(&input);
-        let mut append_error_clause = s.variants().len() > 1;
+        let needs_catchall_branch = s.variants().len() > 1;
 
         let match_body = s.variants().iter().fold(quote!(), |body, variant| {
-            let attrs = cg::parse_variant_attrs_from_ast::<AnimationVariantAttrs>(&variant.ast());
-            if attrs.error {
-                append_error_clause = true;
-                return body;
-            }
-
-            let (this_pattern, this_info) = cg::ref_pattern(&variant, "this");
-            let (other_pattern, other_info) = cg::ref_pattern(&variant, "other");
-            let sum = if this_info.is_empty() {
-                quote! { crate::values::distance::SquaredDistance::from_sqrt(0.) }
-            } else {
-                let mut sum = quote!();
-                sum.append_separated(this_info.iter().zip(&other_info).map(|(this, other)| {
-                    let field_attrs = cg::parse_field_attrs::<DistanceFieldAttrs>(&this.ast());
-                    if field_attrs.field_bound {
-                        let ty = &this.ast().ty;
-                        cg::add_predicate(
-                            &mut where_clause,
-                            parse_quote!(#ty: crate::values::distance::ComputeSquaredDistance),
-                        );
-                    }
-
-                    let animation_field_attrs =
-                        cg::parse_field_attrs::<AnimationFieldAttrs>(&this.ast());
-
-                    if animation_field_attrs.constant {
-                        quote! {
-                            {
-                                if #this != #other {
-                                    return Err(());
-                                }
-                                crate::values::distance::SquaredDistance::from_sqrt(0.)
-                            }
-                        }
-                    } else {
-                        quote! {
-                            crate::values::distance::ComputeSquaredDistance::compute_squared_distance(#this, #other)?
-                        }
-                    }
-                }), quote!(+));
-                sum
-            };
-            quote! {
-                #body
-                (&#this_pattern, &#other_pattern) => {
-                    Ok(#sum)
-                }
-            }
+            let arm = derive_variant_arm(variant, &mut where_clause);
+            quote! { #body #arm }
         });
 
-        (match_body, append_error_clause)
+        (match_body, needs_catchall_branch)
     };
+
     input.generics.where_clause = where_clause;
 
-    if append_error_clause {
-        let input_attrs = cg::parse_input_attrs::<DistanceInputAttrs>(&input);
-        if let Some(fallback) = input_attrs.fallback {
-            match_body.append_all(quote! {
-                (this, other) => #fallback(this, other)
-            });
-        } else {
-            match_body.append_all(quote! { _ => Err(()) });
-        }
+    if needs_catchall_branch {
+        // This ideally shouldn't be needed, but see:
+        // https://github.com/rust-lang/rust/issues/68867
+        match_body.append_all(quote! { _ => unsafe { debug_unreachable!() } });
     }
 
+    let fallback = match input_attrs.fallback {
+        Some(fallback) => quote! { #fallback(self, other) },
+        None => quote! { Err(()) },
+    };
+
     let name = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
 
@@ -103,6 +59,9 @@ pub fn derive(mut input: DeriveInput) -> TokenStream {
                 &self,
                 other: &Self,
             ) -> Result<crate::values::distance::SquaredDistance, ()> {
+                if std::mem::discriminant(self) != std::mem::discriminant(other) {
+                    return #fallback;
+                }
                 match (self, other) {
                     #match_body
                 }
@@ -111,6 +70,60 @@ pub fn derive(mut input: DeriveInput) -> TokenStream {
     }
 }
 
+fn derive_variant_arm(
+    variant: &synstructure::VariantInfo,
+    mut where_clause: &mut Option<WhereClause>,
+) -> TokenStream {
+    let variant_attrs = cg::parse_variant_attrs_from_ast::<AnimationVariantAttrs>(&variant.ast());
+    let (this_pattern, this_info) = cg::ref_pattern(&variant, "this");
+    let (other_pattern, other_info) = cg::ref_pattern(&variant, "other");
+
+    if variant_attrs.error {
+        return quote! {
+            (&#this_pattern, &#other_pattern) => Err(()),
+        };
+    }
+
+    let sum = if this_info.is_empty() {
+        quote! { crate::values::distance::SquaredDistance::from_sqrt(0.) }
+    } else {
+        let mut sum = quote!();
+        sum.append_separated(this_info.iter().zip(&other_info).map(|(this, other)| {
+            let field_attrs = cg::parse_field_attrs::<DistanceFieldAttrs>(&this.ast());
+            if field_attrs.field_bound {
+                let ty = &this.ast().ty;
+                cg::add_predicate(
+                    &mut where_clause,
+                    parse_quote!(#ty: crate::values::distance::ComputeSquaredDistance),
+                );
+            }
+
+            let animation_field_attrs =
+                cg::parse_field_attrs::<AnimationFieldAttrs>(&this.ast());
+
+            if animation_field_attrs.constant {
+                quote! {
+                    {
+                        if #this != #other {
+                            return Err(());
+                        }
+                        crate::values::distance::SquaredDistance::from_sqrt(0.)
+                    }
+                }
+            } else {
+                quote! {
+                    crate::values::distance::ComputeSquaredDistance::compute_squared_distance(#this, #other)?
+                }
+            }
+        }), quote!(+));
+        sum
+    };
+
+    return quote! {
+        (&#this_pattern, &#other_pattern) => Ok(#sum),
+    };
+}
+
 #[darling(attributes(distance), default)]
 #[derive(Default, FromDeriveInput)]
 struct DistanceInputAttrs {

From 3e14422788d67796b4956e9fcdedc50ba11918c6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 14:09:27 +0000
Subject: [PATCH 55/66] style: Add some calc infrastructure to deal with
 simplification / sorting / etc.

For now, we still bail out at the stage of getting the calc node into a
CalcLengthPercentage if we couldn't simplify the min() / max() / clamps()
involved.

After this plan is to use just CalcNode everywhere instead of
specified::CalcLengthPercentage, and then modify the computed
CalcLengthPercentage, which would look slightly different as we know all the sum
terms for those are a struct like { Length, Percentage, bool has_percentage } or
such, so all the simplification code for that becomes much simpler, ideally.

Or we could turn CalcNode generic otherwise, if it's too much code... We'll see.

Differential Revision: https://phabricator.services.mozilla.com/D61739
---
 components/style/values/specified/calc.rs   | 281 +++++++++++++++++++-
 components/style/values/specified/length.rs |  95 +++++++
 2 files changed, 366 insertions(+), 10 deletions(-)

diff --git a/components/style/values/specified/calc.rs b/components/style/values/specified/calc.rs
index 6120c809b12..18c2af379b7 100644
--- a/components/style/values/specified/calc.rs
+++ b/components/style/values/specified/calc.rs
@@ -10,11 +10,12 @@ use crate::parser::ParserContext;
 use crate::values::computed;
 use crate::values::specified::length::ViewportPercentageLength;
 use crate::values::specified::length::{AbsoluteLength, FontRelativeLength, NoCalcLength};
-use crate::values::specified::{Angle, Time};
+use crate::values::specified::{self, Angle, Time};
 use crate::values::{CSSFloat, CSSInteger};
 use cssparser::{AngleOrNumber, CowRcStr, NumberOrPercentage, Parser, Token};
 use smallvec::SmallVec;
 use std::fmt::{self, Write};
+use std::{cmp, mem};
 use style_traits::values::specified::AllowedNumericType;
 use style_traits::{CssWriter, ParseError, SpecifiedValueInfo, StyleParseErrorKind, ToCss};
 
@@ -31,8 +32,30 @@ pub enum MathFunction {
     Clamp,
 }
 
+/// This determines the order in which we serialize members of a calc()
+/// sum.
+///
+/// See https://drafts.csswg.org/css-values-4/#sort-a-calculations-children
+#[derive(Debug, Copy, Clone, Eq, Ord, PartialEq, PartialOrd)]
+enum SortKey {
+    Number,
+    Percentage,
+    Ch,
+    Deg,
+    Em,
+    Ex,
+    Px,
+    Rem,
+    Sec,
+    Vh,
+    Vmax,
+    Vmin,
+    Vw,
+    Other,
+}
+
 /// Whether we're a `min` or `max` function.
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum MinMaxOp {
     /// `min()`
     Min,
@@ -41,7 +64,7 @@ pub enum MinMaxOp {
 }
 
 /// A node inside a `Calc` expression's AST.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum CalcNode {
     /// `<length>`
     Length(NoCalcLength),
@@ -201,27 +224,37 @@ macro_rules! impl_generic_to_type {
                 // Equivalent to cmp::max(min, cmp::min(center, max))
                 //
                 // But preserving units when appropriate.
+                let center_float = center.$to_float();
+                let min_float = min.$to_float();
+                let max_float = max.$to_float();
+
                 let mut result = center;
-                if result.$to_float() > max.$to_float() {
+                let mut result_float = center_float;
+
+                if result_float > max_float {
                     result = max;
+                    result_float = max_float;
                 }
-                if result.$to_float() < min.$to_float() {
-                    result = min;
+
+                if result_float < min_float {
+                    min
+                } else {
+                    result
                 }
-                result
             },
             Self::MinMax(ref nodes, op) => {
                 let mut result = nodes[0].$to_self()?;
+                let mut result_float = result.$to_float();
                 for node in nodes.iter().skip(1) {
                     let candidate = node.$to_self()?;
                     let candidate_float = candidate.$to_float();
-                    let result_float = result.$to_float();
                     let candidate_wins = match op {
                         MinMaxOp::Min => candidate_float < result_float,
                         MinMaxOp::Max => candidate_float > result_float,
                     };
                     if candidate_wins {
                         result = candidate;
+                        result_float = candidate_float;
                     }
                 }
                 result
@@ -235,6 +268,20 @@ macro_rules! impl_generic_to_type {
     }}
 }
 
+impl PartialOrd for CalcNode {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        use self::CalcNode::*;
+        match (self, other) {
+            (&Length(ref one), &Length(ref other)) => one.partial_cmp(other),
+            (&Percentage(ref one), &Percentage(ref other)) => one.partial_cmp(other),
+            (&Angle(ref one), &Angle(ref other)) => one.degrees().partial_cmp(&other.degrees()),
+            (&Time(ref one), &Time(ref other)) => one.seconds().partial_cmp(&other.seconds()),
+            (&Number(ref one), &Number(ref other)) => one.partial_cmp(other),
+            _ => None,
+        }
+    }
+}
+
 impl CalcNode {
     fn negate(&mut self) {
         self.mul_by(-1.);
@@ -286,12 +333,225 @@ impl CalcNode {
                 max.mul_by(scalar);
                 // For negatives we need to swap min / max.
                 if scalar < 0. {
-                    std::mem::swap(min, max);
+                    mem::swap(min, max);
                 }
             },
         }
     }
 
+    fn calc_node_sort_key(&self) -> SortKey {
+        match *self {
+            Self::Number(..) => SortKey::Number,
+            Self::Percentage(..) => SortKey::Percentage,
+            Self::Time(..) => SortKey::Sec,
+            Self::Angle(..) => SortKey::Deg,
+            Self::Length(ref l) => {
+                match *l {
+                    NoCalcLength::Absolute(..) => SortKey::Px,
+                    NoCalcLength::FontRelative(ref relative) => {
+                        match *relative {
+                            FontRelativeLength::Ch(..) => SortKey::Ch,
+                            FontRelativeLength::Em(..) => SortKey::Em,
+                            FontRelativeLength::Ex(..) => SortKey::Ex,
+                            FontRelativeLength::Rem(..) => SortKey::Rem,
+                        }
+                    },
+                    NoCalcLength::ViewportPercentage(ref vp) => {
+                        match *vp {
+                            ViewportPercentageLength::Vh(..) => SortKey::Vh,
+                            ViewportPercentageLength::Vw(..) => SortKey::Vw,
+                            ViewportPercentageLength::Vmax(..) => SortKey::Vmax,
+                            ViewportPercentageLength::Vmin(..) => SortKey::Vmin,
+                        }
+                    },
+                    NoCalcLength::ServoCharacterWidth(..) => unreachable!(),
+                }
+            },
+            Self::Sum(..) | Self::MinMax(..) | Self::Clamp { .. } => SortKey::Other,
+        }
+    }
+
+    /// Tries to merge one sum to another, that is, perform `x` + `y`.
+    ///
+    /// Only handles leaf nodes, it's the caller's responsibility to simplify
+    /// them before calling this if needed.
+    fn try_sum_in_place(&mut self, other: &Self) -> Result<(), ()> { use
+        self::CalcNode::*;
+
+        match (self, other) { (&mut Number(ref mut one), &Number(ref other)) |
+            (&mut Percentage(ref mut one), &Percentage(ref other)) => { *one +=
+                *other; } (&mut Angle(ref mut one), &Angle(ref other)) => { *one
+                    = specified::Angle::from_calc(one.degrees() +
+                        other.degrees()); } (&mut Time(ref mut one), &Time(ref
+                            other)) => { *one =
+                            specified::Time::from_calc(one.seconds() +
+                                other.seconds()); } (&mut Length(ref mut one),
+                                &Length(ref other)) => { *one =
+                                    one.try_sum(other)?; } _ => return Err(()),
+        }
+
+        Ok(()) }
+
+    /// Simplifies and sorts the calculation. This is only needed if it's going
+    /// to be preserved after parsing (so, for `<length-percentage>`). Otherwise
+    /// we can just evaluate it and we'll come up with a simplified value
+    /// anyways.
+    fn simplify_and_sort_children(&mut self) {
+        macro_rules! replace_self_with {
+            ($slot:expr) => {{
+                let result = mem::replace($slot, Self::Number(0.));
+                mem::replace(self, result);
+            }}
+        }
+        match *self {
+            Self::Clamp { ref mut min, ref mut center, ref mut max } => {
+                min.simplify_and_sort_children();
+                center.simplify_and_sort_children();
+                max.simplify_and_sort_children();
+
+                // NOTE: clamp() is max(min, min(center, max))
+                let min_cmp_center = match min.partial_cmp(&center) {
+                    Some(o) => o,
+                    None => return,
+                };
+
+                // So if we can prove that min is more than center, then we won,
+                // as that's what we should always return.
+                if matches!(min_cmp_center, cmp::Ordering::Greater) {
+                    return replace_self_with!(&mut **min);
+                }
+
+                // Otherwise try with max.
+                let max_cmp_center = match max.partial_cmp(&center) {
+                    Some(o) => o,
+                    None => return,
+                };
+
+                if matches!(max_cmp_center, cmp::Ordering::Less) {
+                    // max is less than center, so we need to return effectively
+                    // `max(min, max)`.
+                    let max_cmp_min = match max.partial_cmp(&min) {
+                        Some(o) => o,
+                        None => {
+                            debug_assert!(
+                                false,
+                                "We compared center with min and max, how are \
+                                 min / max not comparable with each other?"
+                            );
+                            return;
+                        },
+                    };
+
+                    if matches!(max_cmp_min, cmp::Ordering::Less) {
+                        return replace_self_with!(&mut **min);
+                    }
+
+                    return replace_self_with!(&mut **max);
+                }
+
+                // Otherwise we're the center node.
+                return replace_self_with!(&mut **center);
+            },
+            Self::MinMax(ref mut children, op) => {
+                for child in &mut **children {
+                    child.simplify_and_sort_children();
+                }
+
+                let winning_order = match op {
+                    MinMaxOp::Min => cmp::Ordering::Less,
+                    MinMaxOp::Max => cmp::Ordering::Greater,
+                };
+
+                let mut result = 0;
+                for i in 1..children.len() {
+                    let o = match children[i].partial_cmp(&children[result]) {
+                        // We can't compare all the children, so we can't
+                        // know which one will actually win. Bail out and
+                        // keep ourselves as a min / max function.
+                        //
+                        // TODO: Maybe we could simplify compatible children,
+                        // see https://github.com/w3c/csswg-drafts/issues/4756
+                        None => return,
+                        Some(o) => o,
+                    };
+
+                    if o == winning_order {
+                        result = i;
+                    }
+                }
+
+                replace_self_with!(&mut children[result]);
+            },
+            Self::Sum(ref mut children_slot) => {
+                let mut sums_to_merge = SmallVec::<[_; 3]>::new();
+                let mut extra_kids = 0;
+                for (i, child) in children_slot.iter_mut().enumerate() {
+                    child.simplify_and_sort_children();
+                    if let Self::Sum(ref mut children) = *child {
+                        extra_kids += children.len();
+                        sums_to_merge.push(i);
+                    }
+                }
+
+                // If we only have one kid, we've already simplified it, and it
+                // doesn't really matter whether it's a sum already or not, so
+                // lift it up and continue.
+                if children_slot.len() == 1 {
+                    return replace_self_with!(&mut children_slot[0]);
+                }
+
+                let mut children = mem::replace(children_slot, Box::new([])).into_vec();
+
+                if !sums_to_merge.is_empty() {
+                    children.reserve(extra_kids - sums_to_merge.len());
+                    // Merge all our nested sums, in reverse order so that the
+                    // list indices are not invalidated.
+                    for i in sums_to_merge.drain(..).rev() {
+                        let kid_children = match children.swap_remove(i) {
+                            Self::Sum(c) => c,
+                            _ => unreachable!(),
+                        };
+
+                        // This would be nicer with
+                        // https://github.com/rust-lang/rust/issues/59878 fixed.
+                        children.extend(kid_children.into_vec());
+                    }
+                }
+
+                debug_assert!(
+                    children.len() >= 2,
+                    "Should still have multiple kids!"
+                );
+
+                // Sort by spec order.
+                children.sort_unstable_by_key(|c| c.calc_node_sort_key());
+
+                // NOTE: if the function returns true, by the docs of dedup_by,
+                // a is removed.
+                children.dedup_by(|a, b| b.try_sum_in_place(a).is_ok());
+
+                if children.len() == 1 {
+                    // If only one children remains, lift it up, and carry on.
+                    replace_self_with!(&mut children[0]);
+                } else {
+                    // Else put our simplified children back.
+                    mem::replace(children_slot, children.into_boxed_slice());
+                }
+            },
+            Self::Length(ref mut len) => {
+                if let NoCalcLength::Absolute(ref mut absolute_length) = *len {
+                    *absolute_length = AbsoluteLength::Px(absolute_length.to_px());
+                }
+            }
+            Self::Percentage(..) |
+            Self::Angle(..) |
+            Self::Time(..) |
+            Self::Number(..) => {
+                // These are leaves already, nothing to do.
+            },
+        }
+    }
+
     /// Tries to parse a single element in the expression, that is, a
     /// `<length>`, `<angle>`, `<time>`, `<percentage>`, according to
     /// `expected_unit`.
@@ -509,13 +769,14 @@ impl CalcNode {
     /// Tries to simplify this expression into a `<length>` or `<percentage`>
     /// value.
     fn to_length_or_percentage(
-        &self,
+        &mut self,
         clamping_mode: AllowedNumericType,
     ) -> Result<CalcLengthPercentage, ()> {
         let mut ret = CalcLengthPercentage {
             clamping_mode,
             ..Default::default()
         };
+        self.simplify_and_sort_children();
         self.add_length_or_percentage_to(&mut ret, 1.0)?;
         Ok(ret)
     }
diff --git a/components/style/values/specified/length.rs b/components/style/values/specified/length.rs
index 71153c4e015..3580d1105c6 100644
--- a/components/style/values/specified/length.rs
+++ b/components/style/values/specified/length.rs
@@ -96,6 +96,17 @@ impl FontRelativeLength {
         }
     }
 
+    fn try_sum(&self, other: &Self) -> Result<Self, ()> {
+        use self::FontRelativeLength::*;
+        Ok(match (self, other) {
+            (&Em(one), &Em(other)) => Em(one + other),
+            (&Ex(one), &Ex(other)) => Ex(one + other),
+            (&Ch(one), &Ch(other)) => Ch(one + other),
+            (&Rem(one), &Rem(other)) => Rem(one + other),
+            _ => return Err(()),
+        })
+    }
+
     /// Computes the font-relative length.
     pub fn to_computed_value(
         &self,
@@ -247,6 +258,17 @@ impl ViewportPercentageLength {
         }
     }
 
+    fn try_sum(&self, other: &Self) -> Result<Self, ()> {
+        use self::ViewportPercentageLength::*;
+        Ok(match (self, other) {
+            (&Vw(one), &Vw(other)) => Vw(one + other),
+            (&Vh(one), &Vh(other)) => Vh(one + other),
+            (&Vmin(one), &Vmin(other)) => Vmin(one + other),
+            (&Vmax(one), &Vmax(other)) => Vmax(one + other),
+            _ => return Err(()),
+        })
+    }
+
     /// Computes the given viewport-relative length for the given viewport size.
     pub fn to_computed_value(&self, viewport_size: Size2D<Au>) -> CSSPixelLength {
         let (factor, length) = match *self {
@@ -354,6 +376,12 @@ impl ToComputedValue for AbsoluteLength {
     }
 }
 
+impl PartialOrd for AbsoluteLength {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        self.to_px().partial_cmp(&other.to_px())
+    }
+}
+
 impl Mul<CSSFloat> for AbsoluteLength {
     type Output = AbsoluteLength;
 
@@ -468,6 +496,21 @@ impl NoCalcLength {
         })
     }
 
+    /// Try to sume two lengths if compatible into the left hand side.
+    pub(crate) fn try_sum(&self, other: &Self) -> Result<Self, ()> {
+        use self::NoCalcLength::*;
+
+        Ok(match (self, other) {
+            (&Absolute(ref one), &Absolute(ref other)) => Absolute(*one + *other),
+            (&FontRelative(ref one), &FontRelative(ref other)) => FontRelative(one.try_sum(other)?),
+            (&ViewportPercentage(ref one), &ViewportPercentage(ref other)) => ViewportPercentage(one.try_sum(other)?),
+            (&ServoCharacterWidth(ref one), &ServoCharacterWidth(ref other)) => {
+                ServoCharacterWidth(CharacterWidth(one.0 + other.0))
+            },
+            _ => return Err(()),
+        })
+    }
+
     /// Get a px value without context.
     #[inline]
     pub fn to_computed_pixel_length_without_context(&self) -> Result<CSSFloat, ()> {
@@ -486,6 +529,24 @@ impl NoCalcLength {
 
 impl SpecifiedValueInfo for NoCalcLength {}
 
+impl PartialOrd for NoCalcLength {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        use self::NoCalcLength::*;
+        match (self, other) {
+            (&Absolute(ref one), &Absolute(ref other)) => one.to_px().partial_cmp(&other.to_px()),
+            (&FontRelative(ref one), &FontRelative(ref other)) => one.partial_cmp(other),
+            (&ViewportPercentage(ref one), &ViewportPercentage(ref other)) => one.partial_cmp(other),
+            (&ServoCharacterWidth(ref one), &ServoCharacterWidth(ref other)) => one.0.partial_cmp(&other.0),
+            _ => {
+                // This will at least catch issues some of the time... Maybe
+                // could be worth a derive thing?
+                debug_assert_ne!(self, other, "Forgot a match arm?");
+                None
+            }
+        }
+    }
+}
+
 impl Zero for NoCalcLength {
     fn zero() -> Self {
         NoCalcLength::Absolute(AbsoluteLength::Px(0.))
@@ -534,6 +595,23 @@ impl Mul<CSSFloat> for Length {
     }
 }
 
+impl PartialOrd for FontRelativeLength {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        use self::FontRelativeLength::*;
+        match (self, other) {
+            (&Em(ref one), &Em(ref other)) => one.partial_cmp(other),
+            (&Ex(ref one), &Ex(ref other)) => one.partial_cmp(other),
+            (&Ch(ref one), &Ch(ref other)) => one.partial_cmp(other),
+            (&Rem(ref one), &Rem(ref other)) => one.partial_cmp(other),
+            _ => {
+                // This will at least catch issues some of the time.
+                debug_assert_ne!(self, other, "Forgot a match arm?");
+                None
+            }
+        }
+    }
+}
+
 impl Mul<CSSFloat> for FontRelativeLength {
     type Output = FontRelativeLength;
 
@@ -562,6 +640,23 @@ impl Mul<CSSFloat> for ViewportPercentageLength {
     }
 }
 
+impl PartialOrd for ViewportPercentageLength {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        use self::ViewportPercentageLength::*;
+        match (self, other) {
+            (&Vw(ref one), &Vw(ref other)) => one.partial_cmp(other),
+            (&Vh(ref one), &Vh(ref other)) => one.partial_cmp(other),
+            (&Vmin(ref one), &Vmin(ref other)) => one.partial_cmp(other),
+            (&Vmax(ref one), &Vmax(ref other)) => one.partial_cmp(other),
+            _ => {
+                // This will at least catch issues some of the time.
+                debug_assert_ne!(self, other, "Forgot a match arm?");
+                None
+            }
+        }
+    }
+}
+
 impl Length {
     #[inline]
     fn parse_internal<'i, 't>(

From 1a22fa7b1dd4be36a3c09186e243653783609bc7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 14:09:38 +0000
Subject: [PATCH 56/66] style: Make rust generate better code for some of the
 functions introduced here.

See https://github.com/rust-lang/rust/issues/68867.

Differential Revision: https://phabricator.services.mozilla.com/D61760
---
 components/style/values/specified/length.rs | 84 ++++++++++++++++-----
 1 file changed, 65 insertions(+), 19 deletions(-)

diff --git a/components/style/values/specified/length.rs b/components/style/values/specified/length.rs
index 3580d1105c6..3b971b422c2 100644
--- a/components/style/values/specified/length.rs
+++ b/components/style/values/specified/length.rs
@@ -98,12 +98,22 @@ impl FontRelativeLength {
 
     fn try_sum(&self, other: &Self) -> Result<Self, ()> {
         use self::FontRelativeLength::*;
+
+        if std::mem::discriminant(self) != std::mem::discriminant(other) {
+            return Err(());
+        }
+
         Ok(match (self, other) {
             (&Em(one), &Em(other)) => Em(one + other),
             (&Ex(one), &Ex(other)) => Ex(one + other),
             (&Ch(one), &Ch(other)) => Ch(one + other),
             (&Rem(one), &Rem(other)) => Rem(one + other),
-            _ => return Err(()),
+            // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
+            // able to figure it own on its own so we help.
+            _ => unsafe {
+                match *self { Em(..) | Ex(..) | Ch(..) | Rem(..) => {} }
+                debug_unreachable!("Forgot to handle unit in try_sum()")
+            },
         })
     }
 
@@ -260,12 +270,22 @@ impl ViewportPercentageLength {
 
     fn try_sum(&self, other: &Self) -> Result<Self, ()> {
         use self::ViewportPercentageLength::*;
+
+        if std::mem::discriminant(self) != std::mem::discriminant(other) {
+            return Err(());
+        }
+
         Ok(match (self, other) {
             (&Vw(one), &Vw(other)) => Vw(one + other),
             (&Vh(one), &Vh(other)) => Vh(one + other),
             (&Vmin(one), &Vmin(other)) => Vmin(one + other),
             (&Vmax(one), &Vmax(other)) => Vmax(one + other),
-            _ => return Err(()),
+            // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
+            // able to figure it own on its own so we help.
+            _ => unsafe {
+                match *self { Vw(..) | Vh(..) | Vmin(..) | Vmax(..) => {} }
+                debug_unreachable!("Forgot to handle unit in try_sum()")
+            },
         })
     }
 
@@ -500,6 +520,10 @@ impl NoCalcLength {
     pub(crate) fn try_sum(&self, other: &Self) -> Result<Self, ()> {
         use self::NoCalcLength::*;
 
+        if std::mem::discriminant(self) != std::mem::discriminant(other) {
+            return Err(());
+        }
+
         Ok(match (self, other) {
             (&Absolute(ref one), &Absolute(ref other)) => Absolute(*one + *other),
             (&FontRelative(ref one), &FontRelative(ref other)) => FontRelative(one.try_sum(other)?),
@@ -507,7 +531,12 @@ impl NoCalcLength {
             (&ServoCharacterWidth(ref one), &ServoCharacterWidth(ref other)) => {
                 ServoCharacterWidth(CharacterWidth(one.0 + other.0))
             },
-            _ => return Err(()),
+            // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
+            // able to figure it own on its own so we help.
+            _ => unsafe {
+                match *self { Absolute(..) | FontRelative(..) | ViewportPercentage(..) | ServoCharacterWidth(..) => {} }
+                debug_unreachable!("Forgot to handle unit in try_sum()")
+            },
         })
     }
 
@@ -532,17 +561,22 @@ impl SpecifiedValueInfo for NoCalcLength {}
 impl PartialOrd for NoCalcLength {
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         use self::NoCalcLength::*;
+
+        if std::mem::discriminant(self) != std::mem::discriminant(other) {
+            return None;
+        }
+
         match (self, other) {
             (&Absolute(ref one), &Absolute(ref other)) => one.to_px().partial_cmp(&other.to_px()),
             (&FontRelative(ref one), &FontRelative(ref other)) => one.partial_cmp(other),
             (&ViewportPercentage(ref one), &ViewportPercentage(ref other)) => one.partial_cmp(other),
             (&ServoCharacterWidth(ref one), &ServoCharacterWidth(ref other)) => one.0.partial_cmp(&other.0),
-            _ => {
-                // This will at least catch issues some of the time... Maybe
-                // could be worth a derive thing?
-                debug_assert_ne!(self, other, "Forgot a match arm?");
-                None
-            }
+            // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
+            // able to figure it own on its own so we help.
+            _ => unsafe {
+                match *self { Absolute(..) | FontRelative(..) | ViewportPercentage(..) | ServoCharacterWidth(..) => {} }
+                debug_unreachable!("Forgot an arm in partial_cmp?")
+            },
         }
     }
 }
@@ -598,16 +632,22 @@ impl Mul<CSSFloat> for Length {
 impl PartialOrd for FontRelativeLength {
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         use self::FontRelativeLength::*;
+
+        if std::mem::discriminant(self) != std::mem::discriminant(other) {
+            return None;
+        }
+
         match (self, other) {
             (&Em(ref one), &Em(ref other)) => one.partial_cmp(other),
             (&Ex(ref one), &Ex(ref other)) => one.partial_cmp(other),
             (&Ch(ref one), &Ch(ref other)) => one.partial_cmp(other),
             (&Rem(ref one), &Rem(ref other)) => one.partial_cmp(other),
-            _ => {
-                // This will at least catch issues some of the time.
-                debug_assert_ne!(self, other, "Forgot a match arm?");
-                None
-            }
+            // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
+            // able to figure it own on its own so we help.
+            _ => unsafe {
+                match *self { Em(..) | Ex(..) | Ch(..) | Rem(..) => {} }
+                debug_unreachable!("Forgot an arm in partial_cmp?")
+            },
         }
     }
 }
@@ -643,16 +683,22 @@ impl Mul<CSSFloat> for ViewportPercentageLength {
 impl PartialOrd for ViewportPercentageLength {
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         use self::ViewportPercentageLength::*;
+
+        if std::mem::discriminant(self) != std::mem::discriminant(other) {
+            return None;
+        }
+
         match (self, other) {
             (&Vw(ref one), &Vw(ref other)) => one.partial_cmp(other),
             (&Vh(ref one), &Vh(ref other)) => one.partial_cmp(other),
             (&Vmin(ref one), &Vmin(ref other)) => one.partial_cmp(other),
             (&Vmax(ref one), &Vmax(ref other)) => one.partial_cmp(other),
-            _ => {
-                // This will at least catch issues some of the time.
-                debug_assert_ne!(self, other, "Forgot a match arm?");
-                None
-            }
+            // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
+            // able to figure it own on its own so we help.
+            _ => unsafe {
+                match *self { Vw(..) | Vh(..) | Vmin(..) | Vmax(..) => {} }
+                debug_unreachable!("Forgot an arm in partial_cmp?")
+            },
         }
     }
 }

From cccac2cedd2786fdf6204f140dba8bd65873e13d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 15:30:01 +0100
Subject: [PATCH 57/66] malloc_size_of: Add a missing cfg guard.

---
 components/malloc_size_of/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/components/malloc_size_of/lib.rs b/components/malloc_size_of/lib.rs
index 62673268ad9..68935869aa3 100644
--- a/components/malloc_size_of/lib.rs
+++ b/components/malloc_size_of/lib.rs
@@ -46,6 +46,7 @@
 //!   Note: WebRender has a reduced fork of this crate, so that we can avoid
 //!   publishing this crate on crates.io.
 
+#[cfg(feature = "servo")]
 extern crate accountable_refcell;
 extern crate app_units;
 #[cfg(feature = "servo")]

From 8c6fe09dce9ad399d3e188a252f88a5647bd2080 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 16:09:18 +0100
Subject: [PATCH 58/66] style: Fix Servo build.

---
 components/style/properties/properties.mako.rs | 18 ++++++++++++++----
 components/style/rule_tree/mod.rs              | 18 +++++++++++++++++-
 components/style/servo/media_queries.rs        |  5 +++++
 .../style/values/computed/length_percentage.rs |  8 ++++++++
 components/style/values/specified/calc.rs      | 12 +++++++++++-
 5 files changed, 55 insertions(+), 6 deletions(-)

diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs
index ff5d5b5bf56..1962bba3a53 100644
--- a/components/style/properties/properties.mako.rs
+++ b/components/style/properties/properties.mako.rs
@@ -2895,9 +2895,17 @@ pub struct ComputedValues {
     /// We maintain this distinction in servo to reduce the amount of special
     /// casing.
     inner: ComputedValuesInner,
+
+    /// The pseudo-element that we're using.
+    pseudo: Option<PseudoElement>,
 }
 
 impl ComputedValues {
+    /// Returns the pseudo-element that this style represents.
+    pub fn pseudo(&self) -> Option<<&PseudoElement> {
+        self.pseudo.as_ref()
+    }
+
     /// Returns whether this style's display value is equal to contents.
     pub fn is_display_contents(&self) -> bool {
         self.get_box().clone_display().is_contents()
@@ -3000,7 +3008,7 @@ impl ComputedValues {
 impl ComputedValues {
     /// Create a new refcounted `ComputedValues`
     pub fn new(
-        _: Option<<&PseudoElement>,
+        pseudo: Option<<&PseudoElement>,
         custom_properties: Option<Arc<crate::custom_properties::CustomPropertiesMap>>,
         writing_mode: WritingMode,
         flags: ComputedValueFlags,
@@ -3020,7 +3028,8 @@ impl ComputedValues {
             % for style_struct in data.active_style_structs():
                 ${style_struct.ident},
             % endfor
-            }
+            },
+            pseudo: pseudo.cloned(),
         })
     }
 
@@ -3835,7 +3844,7 @@ pub use self::lazy_static_module::INITIAL_SERVO_VALUES;
 #[allow(missing_docs)]
 mod lazy_static_module {
     use crate::logical_geometry::WritingMode;
-    use create::computed_value_flags::ComputedValueFlags;
+    use crate::computed_value_flags::ComputedValueFlags;
     use servo_arc::Arc;
     use super::{ComputedValues, ComputedValuesInner, longhands, style_structs};
 
@@ -3867,7 +3876,8 @@ mod lazy_static_module {
                 rules: None,
                 visited_style: None,
                 flags: ComputedValueFlags::empty(),
-            }
+            },
+            pseudo: None,
         };
     }
 }
diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs
index 8a36e2f20d2..c726e6fbff7 100644
--- a/components/style/rule_tree/mod.rs
+++ b/components/style/rule_tree/mod.rs
@@ -138,6 +138,7 @@ impl StyleSource {
 
     // This is totally unsafe, should be removed when we figure out the cause of
     // bug 1607553.
+    #[cfg(feature = "gecko")]
     unsafe fn dump_unchecked<W: Write>(&self, writer: &mut W) {
         if let Some(ref rule) = self.0.as_first() {
             let rule = rule.read_unchecked();
@@ -149,6 +150,7 @@ impl StyleSource {
     // This is totally unsafe, should be removed when we figure out the cause of
     // bug 1607553.
     #[inline]
+    #[cfg(feature = "gecko")]
     unsafe fn read_unchecked(&self) -> &PropertyDeclarationBlock {
         let block: &Locked<PropertyDeclarationBlock> = match self.0.borrow() {
             ArcUnionBorrow::First(ref rule) => &rule.get().read_unchecked().block,
@@ -1739,10 +1741,23 @@ impl Drop for StrongRuleNode {
             return;
         }
 
-        if cfg!(debug_assertions) || crate::gecko_bindings::structs::GECKO_IS_NIGHTLY {
+        #[cfg(feature = "gecko")]
+        #[inline(always)]
+        fn assert_on_release() -> bool {
+            crate::gecko_bindings::structs::GECKO_IS_NIGHTLY
+        }
+
+        #[cfg(feature = "servo")]
+        fn assert_on_release() -> bool {
+            false
+        }
+
+        if cfg!(debug_assertions) || assert_on_release() {
             let children = node.children.read();
             if !children.is_empty() {
                 let mut crash_str = vec![];
+
+                #[cfg(feature = "gecko")]
                 unsafe {
                     // Try to unsafely collect some information of this before
                     // crashing the process.
@@ -1755,6 +1770,7 @@ impl Drop for StrongRuleNode {
                         crash_str.push(b'\n');
                     });
                 }
+
                 panic!("Children left in the rule tree on drop: {}", String::from_utf8_lossy(&crash_str).trim());
             }
         }
diff --git a/components/style/servo/media_queries.rs b/components/style/servo/media_queries.rs
index b1e752234e5..fa288a92729 100644
--- a/components/style/servo/media_queries.rs
+++ b/components/style/servo/media_queries.rs
@@ -165,6 +165,11 @@ impl Device {
         RGBA::new(255, 255, 255, 255)
     }
 
+    /// Returns the default color color.
+    pub fn default_color(&self) -> RGBA {
+        RGBA::new(0, 0, 0, 255)
+    }
+
     /// Returns safe area insets
     pub fn safe_area_insets(&self) -> SideOffsets2D<f32, CSSPixel> {
         SideOffsets2D::zero()
diff --git a/components/style/values/computed/length_percentage.rs b/components/style/values/computed/length_percentage.rs
index f6537c3ecef..6851bc0c674 100644
--- a/components/style/values/computed/length_percentage.rs
+++ b/components/style/values/computed/length_percentage.rs
@@ -73,6 +73,10 @@ pub struct CalcVariant {
     ptr: *mut CalcLengthPercentage,
 }
 
+// `CalcLengthPercentage` is `Send + Sync` as asserted below.
+unsafe impl Send for CalcVariant {}
+unsafe impl Sync for CalcVariant {}
+
 #[doc(hidden)]
 #[derive(Copy, Clone)]
 #[repr(C)]
@@ -130,10 +134,14 @@ enum Tag {
 // All the members should be 64 bits, even in 32-bit builds.
 #[allow(unused)]
 unsafe fn static_assert() {
+    fn assert_send_and_sync<T: Send + Sync>() {}
     std::mem::transmute::<u64, LengthVariant>(0u64);
     std::mem::transmute::<u64, PercentageVariant>(0u64);
     std::mem::transmute::<u64, CalcVariant>(0u64);
     std::mem::transmute::<u64, LengthPercentage>(0u64);
+    assert_send_and_sync::<LengthVariant>();
+    assert_send_and_sync::<PercentageVariant>();
+    assert_send_and_sync::<CalcLengthPercentage>();
 }
 
 impl Drop for LengthPercentage {
diff --git a/components/style/values/specified/calc.rs b/components/style/values/specified/calc.rs
index 18c2af379b7..d008792eee5 100644
--- a/components/style/values/specified/calc.rs
+++ b/components/style/values/specified/calc.rs
@@ -881,7 +881,17 @@ impl CalcNode {
             return Ok(MathFunction::Calc);
         }
 
-        if !static_prefs::pref!("layout.css.comparison-functions.enabled") {
+        #[cfg(feature = "gecko")]
+        fn comparison_functions_enabled() -> bool {
+            static_prefs::pref!("layout.css.comparison-functions.enabled")
+        }
+
+        #[cfg(feature = "servo")]
+        fn comparison_functions_enabled() -> bool {
+            false
+        }
+
+        if !comparison_functions_enabled() {
             return Err(location.new_unexpected_token_error(Token::Function(name.clone())));
         }
 

From 18cda1567a6d725b9caba776b1c49c272a93e391 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 16:09:46 +0100
Subject: [PATCH 59/66] Update smallvec.

Newer style system code uses it.
---
 Cargo.lock | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4c49f2fdf0a..670ba02c850 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1532,7 +1532,7 @@ name = "fallible"
 version = "0.0.1"
 dependencies = [
  "hashglobe",
- "smallvec 1.0.0",
+ "smallvec 1.2.0",
 ]
 
 [[package]]
@@ -3313,7 +3313,7 @@ dependencies = [
  "serde_bytes",
  "servo_arc",
  "smallbitvec",
- "smallvec 1.0.0",
+ "smallvec 1.2.0",
  "string_cache",
  "thin-slice",
  "time",
@@ -4912,7 +4912,7 @@ dependencies = [
  "phf_codegen",
  "precomputed-hash",
  "servo_arc",
- "smallvec 1.0.0",
+ "smallvec 1.2.0",
  "thin-slice",
  "to_shmem",
  "to_shmem_derive",
@@ -5507,9 +5507,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.0.0"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ecf3b85f68e8abaa7555aa5abdb1153079387e60b718283d732f03897fcfc86"
+checksum = "5c2fb2ec9bcd216a5b0d0ccf31ab17b5ed1d627960edff65bbe95d3ce221cefc"
 
 [[package]]
 name = "smithay-client-toolkit"
@@ -5672,7 +5672,7 @@ dependencies = [
  "servo_config",
  "servo_url",
  "smallbitvec",
- "smallvec 1.0.0",
+ "smallvec 1.2.0",
  "string_cache",
  "style_derive",
  "style_traits",
@@ -6017,7 +6017,7 @@ dependencies = [
  "cssparser",
  "servo_arc",
  "smallbitvec",
- "smallvec 1.0.0",
+ "smallvec 1.2.0",
  "string_cache",
  "thin-slice",
 ]
@@ -6784,7 +6784,7 @@ dependencies = [
  "rendy-descriptor",
  "rendy-memory",
  "serde",
- "smallvec 1.0.0",
+ "smallvec 1.2.0",
  "vec_map",
 ]
 

From e227715aee48603755ae19f656ff0f85b1eb62bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 16:50:40 +0100
Subject: [PATCH 60/66] style: Miscellaneous Servo build fixes.

---
 components/layout/construct.rs                |  8 ++++--
 components/layout/display_list/conversions.rs |  2 +-
 components/layout/table.rs                    |  2 +-
 components/layout/table_row.rs                |  2 +-
 components/layout_2020/sizing.rs              |  4 +--
 components/layout_2020/style_ext.rs           |  2 +-
 .../style/properties/properties.mako.rs       |  1 +
 components/style/rule_tree/mod.rs             |  1 +
 .../values/computed/length_percentage.rs      | 15 +++++++++-
 components/style/values/generics/counters.rs  |  3 +-
 components/style/values/specified/counters.rs |  1 +
 components/style_traits/owned_str.rs          | 28 +++++++++++++++++++
 12 files changed, 59 insertions(+), 10 deletions(-)

diff --git a/components/layout/construct.rs b/components/layout/construct.rs
index 5c9ff1256dd..aabb2e69b67 100644
--- a/components/layout/construct.rs
+++ b/components/layout/construct.rs
@@ -840,7 +840,10 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode>
 
         match text_content {
             TextContent::Text(string) => {
-                let info = Box::new(UnscannedTextFragmentInfo::new(string, node.selection()));
+                let info = Box::new(UnscannedTextFragmentInfo::new(
+                    string.into(),
+                    node.selection(),
+                ));
                 let specific_fragment_info = SpecificFragmentInfo::UnscannedText(info);
                 fragments
                     .fragments
@@ -857,7 +860,8 @@ impl<'a, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode>
                 for content_item in content_items.into_iter() {
                     let specific_fragment_info = match content_item {
                         ContentItem::String(string) => {
-                            let info = Box::new(UnscannedTextFragmentInfo::new(string, None));
+                            let info =
+                                Box::new(UnscannedTextFragmentInfo::new(string.into(), None));
                             SpecificFragmentInfo::UnscannedText(info)
                         },
                         content_item => {
diff --git a/components/layout/display_list/conversions.rs b/components/layout/display_list/conversions.rs
index 2759c5f65ac..ecf20be3869 100644
--- a/components/layout/display_list/conversions.rs
+++ b/components/layout/display_list/conversions.rs
@@ -95,7 +95,7 @@ impl ToLayout for TransformStyle {
     type Type = wr::TransformStyle;
     fn to_layout(&self) -> Self::Type {
         match *self {
-            TransformStyle::Auto | TransformStyle::Flat => wr::TransformStyle::Flat,
+            TransformStyle::Flat => wr::TransformStyle::Flat,
             TransformStyle::Preserve3d => wr::TransformStyle::Preserve3D,
         }
     }
diff --git a/components/layout/table.rs b/components/layout/table.rs
index 190f6693256..80f5ac43032 100644
--- a/components/layout/table.rs
+++ b/components/layout/table.rs
@@ -309,7 +309,7 @@ impl Flow for TableFlow {
                         percentage: match *specified_inline_size {
                             Size::Auto => 0.0,
                             Size::LengthPercentage(ref lp) => {
-                                lp.0.as_percentage().map_or(0.0, |p| p.0)
+                                lp.0.to_percentage().map_or(0.0, |p| p.0)
                             },
                         },
                         preferred: Au(0),
diff --git a/components/layout/table_row.rs b/components/layout/table_row.rs
index 58fb40bde3a..0d959b7456c 100644
--- a/components/layout/table_row.rs
+++ b/components/layout/table_row.rs
@@ -437,7 +437,7 @@ impl Flow for TableRowFlow {
                     .unwrap_or(child_base.intrinsic_inline_sizes.minimum_inline_size),
                     percentage: match child_specified_inline_size {
                         Size::Auto => 0.0,
-                        Size::LengthPercentage(ref lp) => lp.0.as_percentage().map_or(0.0, |p| p.0),
+                        Size::LengthPercentage(ref lp) => lp.0.to_percentage().map_or(0.0, |p| p.0),
                     },
                     preferred: child_base.intrinsic_inline_sizes.preferred_inline_size,
                     constrained: match child_specified_inline_size {
diff --git a/components/layout_2020/sizing.rs b/components/layout_2020/sizing.rs
index dc7513a7859..676c7eb347a 100644
--- a/components/layout_2020/sizing.rs
+++ b/components/layout_2020/sizing.rs
@@ -117,12 +117,12 @@ impl BoxContentSizes {
             .auto_is(Length::zero);
         let max_inline_size = match style.max_box_size().inline {
             MaxSize::None => None,
-            MaxSize::LengthPercentage(ref lp) => lp.as_length(),
+            MaxSize::LengthPercentage(ref lp) => lp.to_length(),
         };
         let clamp = |l: Length| l.clamp_between_extremums(min_inline_size, max_inline_size);
 
         // Percentages for 'width' are treated as 'auto'
-        let inline_size = inline_size.map(|lp| lp.as_length());
+        let inline_size = inline_size.map(|lp| lp.to_length());
         // The (inner) min/max-content are only used for 'auto'
         let mut outer = match inline_size.non_auto().flatten() {
             None => {
diff --git a/components/layout_2020/style_ext.rs b/components/layout_2020/style_ext.rs
index f6fb8d4000a..30b384f3884 100644
--- a/components/layout_2020/style_ext.rs
+++ b/components/layout_2020/style_ext.rs
@@ -59,7 +59,7 @@ impl ComputedValuesExt for ComputedValues {
         } else {
             &position.height
         };
-        matches!(size, Size::LengthPercentage(lp) if lp.0.as_length().is_some())
+        matches!(size, Size::LengthPercentage(lp) if lp.0.to_length().is_some())
     }
 
     fn inline_box_offsets_are_both_non_auto(&self) -> bool {
diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs
index 1962bba3a53..d3e61867518 100644
--- a/components/style/properties/properties.mako.rs
+++ b/components/style/properties/properties.mako.rs
@@ -2902,6 +2902,7 @@ pub struct ComputedValues {
 
 impl ComputedValues {
     /// Returns the pseudo-element that this style represents.
+    #[cfg(feature = "servo")]
     pub fn pseudo(&self) -> Option<<&PseudoElement> {
         self.pseudo.as_ref()
     }
diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs
index c726e6fbff7..9def9108046 100644
--- a/components/style/rule_tree/mod.rs
+++ b/components/style/rule_tree/mod.rs
@@ -1718,6 +1718,7 @@ impl Clone for StrongRuleNode {
 }
 
 impl Drop for StrongRuleNode {
+    #[cfg_attr(feature = "servo", allow(unused_mut))]
     fn drop(&mut self) {
         let node = unsafe { &*self.ptr() };
 
diff --git a/components/style/values/computed/length_percentage.rs b/components/style/values/computed/length_percentage.rs
index 6851bc0c674..7c1e831f7df 100644
--- a/components/style/values/computed/length_percentage.rs
+++ b/components/style/values/computed/length_percentage.rs
@@ -378,6 +378,19 @@ impl LengthPercentage {
         }
     }
 
+    /// Converts to a `<percentage>` if possible.
+    #[inline]
+    pub fn to_percentage(&self) -> Option<Percentage> {
+        match self.unpack() {
+            Unpacked::Length(..) => None,
+            Unpacked::Percentage(p) => Some(p),
+            Unpacked::Calc(ref c) => {
+                debug_assert!(!c.length.is_zero());
+                None
+            }
+        }
+    }
+
     /// Return the specified percentage if any.
     #[inline]
     pub fn specified_percentage(&self) -> Option<Percentage> {
@@ -405,7 +418,7 @@ impl LengthPercentage {
 
     /// Convert the computed value into used value.
     #[inline]
-    fn maybe_to_used_value(&self, container_len: Option<Length>) -> Option<Au> {
+    pub fn maybe_to_used_value(&self, container_len: Option<Length>) -> Option<Au> {
         self.maybe_percentage_relative_to(container_len).map(Au::from)
     }
 
diff --git a/components/style/values/generics/counters.rs b/components/style/values/generics/counters.rs
index 9ed8cdba68b..88c83f87357 100644
--- a/components/style/values/generics/counters.rs
+++ b/components/style/values/generics/counters.rs
@@ -168,8 +168,9 @@ pub enum GenericContent<ImageUrl> {
 pub use self::GenericContent as Content;
 
 impl<ImageUrl> Content<ImageUrl> {
+    /// Whether `self` represents list of items.
     #[inline]
-    pub(crate) fn is_items(&self) -> bool {
+    pub fn is_items(&self) -> bool {
         matches!(*self, Self::Items(..))
     }
 
diff --git a/components/style/values/specified/counters.rs b/components/style/values/specified/counters.rs
index 15898b58f47..0849cc19116 100644
--- a/components/style/values/specified/counters.rs
+++ b/components/style/values/specified/counters.rs
@@ -113,6 +113,7 @@ impl Parse for Content {
     // normal | none | [ <string> | <counter> | open-quote | close-quote | no-open-quote |
     // no-close-quote ]+
     // TODO: <uri>, attr(<identifier>)
+    #[cfg_attr(feature = "servo", allow(unused_mut))]
     fn parse<'i, 't>(
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
diff --git a/components/style_traits/owned_str.rs b/components/style_traits/owned_str.rs
index 42a83a07713..ebfdcd5e066 100644
--- a/components/style_traits/owned_str.rs
+++ b/components/style_traits/owned_str.rs
@@ -38,6 +38,34 @@ impl DerefMut for OwnedStr {
     }
 }
 
+impl OwnedStr {
+    /// Convert the OwnedStr into a boxed str.
+    #[inline]
+    pub fn into_box(self) -> Box<str> {
+        self.into_string().into_boxed_str()
+    }
+
+    /// Convert the OwnedStr into a `String`.
+    #[inline]
+    pub fn into_string(self) -> String {
+        unsafe { String::from_utf8_unchecked(self.0.into_vec()) }
+    }
+}
+
+impl From<OwnedStr> for String {
+    #[inline]
+    fn from(b: OwnedStr) -> Self {
+        b.into_string()
+    }
+}
+
+impl From<OwnedStr> for Box<str> {
+    #[inline]
+    fn from(b: OwnedStr) -> Self {
+        b.into_box()
+    }
+}
+
 impl From<Box<str>> for OwnedStr {
     #[inline]
     fn from(b: Box<str>) -> Self {

From f03026b869a4e8699deb766943926799ca4f9fdf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 16:50:57 +0100
Subject: [PATCH 61/66] layout: Resolve word_spacing ahead of time.

It's not possible anymore, in the presence of min() / max(), to split a
<length-percentage> value into a <length> and a <percentage> component.

Tweak word_spacing to do what Gecko does (resolving it in advance).
---
 Cargo.lock                              |  2 --
 components/gfx/Cargo.toml               |  1 -
 components/gfx/font.rs                  | 13 ++++++-------
 components/gfx/text/shaping/harfbuzz.rs |  4 +---
 components/layout/text.rs               | 21 ++++++++++++++++++--
 components/layout_2020/flow/inline.rs   | 26 ++++++++++++++++++-------
 components/style/Cargo.toml             |  1 -
 components/style/lib.rs                 |  1 -
 8 files changed, 45 insertions(+), 24 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 670ba02c850..8d7bea14ee6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1751,7 +1751,6 @@ dependencies = [
  "log",
  "malloc_size_of",
  "net_traits",
- "ordered-float",
  "range",
  "serde",
  "servo-fontconfig",
@@ -5659,7 +5658,6 @@ dependencies = [
  "num-integer",
  "num-traits",
  "num_cpus",
- "ordered-float",
  "owning_ref",
  "parking_lot",
  "precomputed-hash",
diff --git a/components/gfx/Cargo.toml b/components/gfx/Cargo.toml
index bb47f664446..08e0e4d6cc7 100644
--- a/components/gfx/Cargo.toml
+++ b/components/gfx/Cargo.toml
@@ -27,7 +27,6 @@ libc = "0.2"
 log = "0.4"
 malloc_size_of = { path = "../malloc_size_of" }
 net_traits = {path = "../net_traits"}
-ordered-float = "1.0"
 range = {path = "../range"}
 serde = "1.0"
 servo_arc = {path = "../servo_arc"}
diff --git a/components/gfx/font.rs b/components/gfx/font.rs
index 439784ba680..2de1a598cda 100644
--- a/components/gfx/font.rs
+++ b/components/gfx/font.rs
@@ -13,7 +13,6 @@ use crate::text::shaping::ShaperMethods;
 use crate::text::Shaper;
 use app_units::Au;
 use euclid::default::{Point2D, Rect, Size2D};
-use ordered_float::NotNan;
 use servo_atoms::Atom;
 use smallvec::SmallVec;
 use std::borrow::ToOwned;
@@ -38,6 +37,7 @@ macro_rules! ot_tag {
 pub const GPOS: u32 = ot_tag!('G', 'P', 'O', 'S');
 pub const GSUB: u32 = ot_tag!('G', 'S', 'U', 'B');
 pub const KERN: u32 = ot_tag!('k', 'e', 'r', 'n');
+pub const LAST_RESORT_GLYPH_ADVANCE: FractionalPixel = 10.0;
 
 static TEXT_SHAPING_PERFORMANCE_COUNTER: AtomicUsize = AtomicUsize::new(0);
 
@@ -197,7 +197,7 @@ pub struct ShapingOptions {
     /// NB: You will probably want to set the `IGNORE_LIGATURES_SHAPING_FLAG` if this is non-null.
     pub letter_spacing: Option<Au>,
     /// Spacing to add between each word. Corresponds to the CSS 2.1 `word-spacing` property.
-    pub word_spacing: (Au, NotNan<f32>),
+    pub word_spacing: Au,
     /// The Unicode script property of the characters in this run.
     pub script: Script,
     /// Various flags.
@@ -278,8 +278,7 @@ impl Font {
             let mut advance = Au::from_f64_px(self.glyph_h_advance(glyph_id));
             if character == ' ' {
                 // https://drafts.csswg.org/css-text-3/#word-spacing-property
-                let (length, percent) = options.word_spacing;
-                advance = (advance + length) + Au((advance.0 as f32 * percent.into_inner()) as i32);
+                advance += options.word_spacing;
             }
             if let Some(letter_spacing) = options.letter_spacing {
                 advance += letter_spacing;
@@ -343,7 +342,7 @@ impl Font {
             .or_insert_with(|| {
                 match self.handle.glyph_h_advance(glyph) {
                     Some(adv) => adv,
-                    None => 10f64 as FractionalPixel, // FIXME: Need fallback strategy
+                    None => LAST_RESORT_GLYPH_ADVANCE as FractionalPixel, // FIXME: Need fallback strategy
                 }
             })
     }
@@ -516,8 +515,8 @@ impl RunMetrics {
         RunMetrics {
             advance_width: advance,
             bounding_box: bounds,
-            ascent: ascent,
-            descent: descent,
+            ascent,
+            descent,
         }
     }
 }
diff --git a/components/gfx/text/shaping/harfbuzz.rs b/components/gfx/text/shaping/harfbuzz.rs
index 9599dd61a12..47cf337011b 100644
--- a/components/gfx/text/shaping/harfbuzz.rs
+++ b/components/gfx/text/shaping/harfbuzz.rs
@@ -434,9 +434,7 @@ impl Shaper {
         // We elect to only space the two required code points.
         if character == ' ' || character == '\u{a0}' {
             // https://drafts.csswg.org/css-text-3/#word-spacing-property
-            let (length, percent) = options.word_spacing;
-            advance =
-                (advance + length) + Au::new((advance.0 as f32 * percent.into_inner()) as i32);
+            advance += options.word_spacing;
         }
 
         advance
diff --git a/components/layout/text.rs b/components/layout/text.rs
index ef9515b0726..1d9fae80297 100644
--- a/components/layout/text.rs
+++ b/components/layout/text.rs
@@ -10,7 +10,7 @@ use crate::fragment::{ScannedTextFragmentInfo, SpecificFragmentInfo, UnscannedTe
 use crate::inline::{InlineFragmentNodeFlags, InlineFragments};
 use crate::linked_list::split_off_head;
 use app_units::Au;
-use gfx::font::{FontMetrics, FontRef, RunMetrics, ShapingFlags, ShapingOptions};
+use gfx::font::{self, FontMetrics, FontRef, RunMetrics, ShapingFlags, ShapingOptions};
 use gfx::text::glyph::ByteIndex;
 use gfx::text::text_run::TextRun;
 use gfx::text::util::{self, CompressionMode};
@@ -195,7 +195,24 @@ impl TextRunScanner {
                 };
                 text_transform = inherited_text_style.text_transform;
                 letter_spacing = inherited_text_style.letter_spacing;
-                word_spacing = inherited_text_style.word_spacing.to_hash_key();
+                word_spacing = inherited_text_style
+                    .word_spacing
+                    .to_length()
+                    .map(|l| l.into())
+                    .unwrap_or_else(|| {
+                        let space_width = font_group
+                            .borrow_mut()
+                            .find_by_codepoint(&mut font_context, ' ')
+                            .and_then(|font| {
+                                let font = font.borrow();
+                                font.glyph_index(' ')
+                                    .map(|glyph_id| font.glyph_h_advance(glyph_id))
+                            })
+                            .unwrap_or(font::LAST_RESORT_GLYPH_ADVANCE);
+                        inherited_text_style
+                            .word_spacing
+                            .to_used_value(Au::from_f64_px(space_width))
+                    });
                 text_rendering = inherited_text_style.text_rendering;
                 word_break = inherited_text_style.word_break;
             }
diff --git a/components/layout_2020/flow/inline.rs b/components/layout_2020/flow/inline.rs
index ba9453a5b80..5d362fc34a7 100644
--- a/components/layout_2020/flow/inline.rs
+++ b/components/layout_2020/flow/inline.rs
@@ -601,13 +601,6 @@ impl TextRun {
             flags.insert(ShapingFlags::KEEP_ALL_FLAG);
         }
 
-        let shaping_options = gfx::font::ShapingOptions {
-            letter_spacing,
-            word_spacing: inherited_text_style.word_spacing.to_hash_key(),
-            script: unicode_script::Script::Common,
-            flags,
-        };
-
         crate::context::with_thread_local_font_context(layout_context, |font_context| {
             let font_group = font_context.font_group(font_style);
             let font = font_group
@@ -616,6 +609,25 @@ impl TextRun {
                 .expect("could not find font");
             let mut font = font.borrow_mut();
 
+            let word_spacing = &inherited_text_style.word_spacing;
+            let word_spacing = word_spacing
+                .to_length()
+                .map(|l| l.into())
+                .unwrap_or_else(|| {
+                    let space_width = font
+                        .glyph_index(' ')
+                        .map(|glyph_id| font.glyph_h_advance(glyph_id))
+                        .unwrap_or(gfx::font::LAST_RESORT_GLYPH_ADVANCE);
+                    word_spacing.to_used_value(Au::from_f64_px(space_width))
+                });
+
+            let shaping_options = gfx::font::ShapingOptions {
+                letter_spacing,
+                word_spacing,
+                script: unicode_script::Script::Common,
+                flags,
+            };
+
             let (runs, break_at_start) = gfx::text::text_run::TextRun::break_and_shape(
                 &mut font,
                 &self.text,
diff --git a/components/style/Cargo.toml b/components/style/Cargo.toml
index 6adb71e89d7..c3fcb196527 100644
--- a/components/style/Cargo.toml
+++ b/components/style/Cargo.toml
@@ -55,7 +55,6 @@ num_cpus = {version = "1.1.0"}
 num-integer = "0.1"
 num-traits = "0.2"
 num-derive = "0.2"
-ordered-float = "1.0"
 owning_ref = "0.4"
 parking_lot = "0.9"
 precomputed-hash = "0.1.1"
diff --git a/components/style/lib.rs b/components/style/lib.rs
index aa855b8b55b..506c309c300 100644
--- a/components/style/lib.rs
+++ b/components/style/lib.rs
@@ -72,7 +72,6 @@ extern crate num_cpus;
 extern crate num_derive;
 extern crate num_integer;
 extern crate num_traits;
-extern crate ordered_float;
 extern crate owning_ref;
 extern crate parking_lot;
 extern crate precomputed_hash;

From 1754c832d8ef7e96559cb3e1941b8cfdd48e4953 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 17:36:49 +0100
Subject: [PATCH 62/66] layout_2020: Avoid decomposing mixed length /
 percentages in intrinsic sizing.

As that makes no sense in presence of min / max.
---
 components/layout_2020/flow/inline.rs | 8 ++++++--
 components/layout_2020/sizing.rs      | 8 ++++++--
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/components/layout_2020/flow/inline.rs b/components/layout_2020/flow/inline.rs
index 5d362fc34a7..58dfb6581db 100644
--- a/components/layout_2020/flow/inline.rs
+++ b/components/layout_2020/flow/inline.rs
@@ -159,8 +159,12 @@ impl InlineFormattingContext {
             }
 
             fn add_lengthpercentage(&mut self, lp: LengthPercentage) {
-                self.add_length(lp.length_component());
-                self.current_line_percentages += lp.percentage_component();
+                if let Some(l) = lp.to_length() {
+                    self.add_length(l);
+                }
+                if let Some(p) = lp.to_percentage() {
+                    self.current_line_percentages += p;
+                }
             }
 
             fn add_length(&mut self, l: Length) {
diff --git a/components/layout_2020/sizing.rs b/components/layout_2020/sizing.rs
index 676c7eb347a..f5dac929b84 100644
--- a/components/layout_2020/sizing.rs
+++ b/components/layout_2020/sizing.rs
@@ -148,8 +148,12 @@ impl BoxContentSizes {
         let margin = style.margin();
         pbm_lengths += border.inline_sum();
         let mut add = |x: LengthPercentage| {
-            pbm_lengths += x.length_component();
-            pbm_percentages += x.percentage_component();
+            if let Some(l) = x.to_length() {
+                pbm_lengths += l;
+            }
+            if let Some(p) = x.to_percentage() {
+                pbm_percentages += p;
+            }
         };
         add(padding.inline_start);
         add(padding.inline_end);

From 071ce6f345556e4cdce79b8b30816316c04c8c96 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Mon, 10 Feb 2020 16:50:57 +0100
Subject: [PATCH 63/66] style: Rustfmt recent changes.

---
 components/style/custom_properties.rs         |  12 +-
 components/style/gecko/media_queries.rs       |   3 +-
 components/style/lib.rs                       |   2 +-
 components/style/matching.rs                  |   5 +-
 .../style/properties/computed_value_flags.rs  |   6 +-
 components/style/rule_tree/mod.rs             |  11 +-
 components/style/servo/media_queries.rs       |   2 +-
 components/style/sharing/mod.rs               |   2 +-
 components/style/style_adjuster.rs            |  14 +-
 components/style/values/animated/length.rs    |   6 +-
 components/style/values/computed/align.rs     |   4 +-
 components/style/values/computed/length.rs    |   6 +-
 .../values/computed/length_percentage.rs      |  81 +++++-----
 components/style/values/computed/mod.rs       |   8 +-
 components/style/values/generics/counters.rs  |  10 +-
 components/style/values/resolved/counters.rs  |   7 +-
 components/style/values/specified/angle.rs    |   4 +-
 components/style/values/specified/box.rs      |   3 +-
 components/style/values/specified/calc.rs     | 138 +++++++++---------
 components/style/values/specified/length.rs   |  45 ++++--
 components/style/values/specified/mod.rs      |   2 +-
 components/style/values/specified/position.rs |   2 +-
 22 files changed, 210 insertions(+), 163 deletions(-)

diff --git a/components/style/custom_properties.rs b/components/style/custom_properties.rs
index b7ef6cf21d0..76a72276a44 100644
--- a/components/style/custom_properties.rs
+++ b/components/style/custom_properties.rs
@@ -12,7 +12,9 @@ use crate::properties::{CSSWideKeyword, CustomDeclaration, CustomDeclarationValu
 use crate::selector_map::{PrecomputedHashMap, PrecomputedHashSet, PrecomputedHasher};
 use crate::stylesheets::{Origin, PerOrigin};
 use crate::Atom;
-use cssparser::{CowRcStr, Delimiter, Parser, ParserInput, SourcePosition, Token, TokenSerializationType};
+use cssparser::{
+    CowRcStr, Delimiter, Parser, ParserInput, SourcePosition, Token, TokenSerializationType,
+};
 use indexmap::IndexMap;
 use selectors::parser::SelectorParseErrorKind;
 use servo_arc::Arc;
@@ -525,10 +527,7 @@ pub struct CustomPropertiesBuilder<'a> {
 
 impl<'a> CustomPropertiesBuilder<'a> {
     /// Create a new builder, inheriting from a given custom properties map.
-    pub fn new(
-        inherited: Option<&'a Arc<CustomPropertiesMap>>,
-        device: &'a Device,
-    ) -> Self {
+    pub fn new(inherited: Option<&'a Arc<CustomPropertiesMap>>, device: &'a Device) -> Self {
         Self {
             seen: PrecomputedHashSet::default(),
             reverted: Default::default(),
@@ -576,8 +575,7 @@ impl<'a> CustomPropertiesBuilder<'a> {
                 // environment variable here, perform substitution here instead
                 // of forcing a full traversal in `substitute_all` afterwards.
                 let value = if !has_references && unparsed_value.references_environment {
-                    let result =
-                        substitute_references_in_value(unparsed_value, &map, &self.device);
+                    let result = substitute_references_in_value(unparsed_value, &map, &self.device);
                     match result {
                         Ok(new_value) => Arc::new(new_value),
                         Err(..) => {
diff --git a/components/style/gecko/media_queries.rs b/components/style/gecko/media_queries.rs
index ae4bad7a25a..25ce9f5b3a1 100644
--- a/components/style/gecko/media_queries.rs
+++ b/components/style/gecko/media_queries.rs
@@ -138,7 +138,8 @@ impl Device {
 
     /// Set the font size of the root element (for rem)
     pub fn set_root_font_size(&self, size: Au) {
-        self.root_font_size.store(size.0 as isize, Ordering::Relaxed)
+        self.root_font_size
+            .store(size.0 as isize, Ordering::Relaxed)
     }
 
     /// Sets the body text color for the "inherit color from body" quirk.
diff --git a/components/style/lib.rs b/components/style/lib.rs
index 506c309c300..6c4b1d5a2a9 100644
--- a/components/style/lib.rs
+++ b/components/style/lib.rs
@@ -119,7 +119,7 @@ pub mod attr;
 pub mod author_styles;
 pub mod bezier;
 pub mod bloom;
-#[path="properties/computed_value_flags.rs"]
+#[path = "properties/computed_value_flags.rs"]
 pub mod computed_value_flags;
 pub mod context;
 pub mod counter_style;
diff --git a/components/style/matching.rs b/components/style/matching.rs
index 42921f052c4..06e74810cfd 100644
--- a/components/style/matching.rs
+++ b/components/style/matching.rs
@@ -706,7 +706,10 @@ pub trait MatchMethods: TElement {
         let new_primary_style = data.styles.primary.as_ref().unwrap();
 
         let mut cascade_requirement = ChildCascadeRequirement::CanSkipCascade;
-        if new_primary_style.flags.contains(ComputedValueFlags::IS_ROOT_ELEMENT_STYLE) {
+        if new_primary_style
+            .flags
+            .contains(ComputedValueFlags::IS_ROOT_ELEMENT_STYLE)
+        {
             let device = context.shared.stylist.device();
             let new_font_size = new_primary_style.get_font().clone_font_size();
 
diff --git a/components/style/properties/computed_value_flags.rs b/components/style/properties/computed_value_flags.rs
index 170c4151411..4363f3f36e9 100644
--- a/components/style/properties/computed_value_flags.rs
+++ b/components/style/properties/computed_value_flags.rs
@@ -75,9 +75,9 @@ impl ComputedValueFlags {
     #[inline]
     fn inherited_flags() -> Self {
         ComputedValueFlags::IS_RELEVANT_LINK_VISITED |
-        ComputedValueFlags::CAN_BE_FRAGMENTED |
-        ComputedValueFlags::IS_IN_PSEUDO_ELEMENT_SUBTREE |
-        ComputedValueFlags::HAS_TEXT_DECORATION_LINES
+            ComputedValueFlags::CAN_BE_FRAGMENTED |
+            ComputedValueFlags::IS_IN_PSEUDO_ELEMENT_SUBTREE |
+            ComputedValueFlags::HAS_TEXT_DECORATION_LINES
     }
 
     /// Flags that may be propagated to descendants.
diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs
index 9def9108046..113fa9cb9bb 100644
--- a/components/style/rule_tree/mod.rs
+++ b/components/style/rule_tree/mod.rs
@@ -1767,12 +1767,19 @@ impl Drop for StrongRuleNode {
                         crash_str.push(b'\n');
                     }
                     children.each(|child| {
-                        (*child.ptr()).source.as_ref().unwrap().dump_unchecked(&mut crash_str);
+                        (*child.ptr())
+                            .source
+                            .as_ref()
+                            .unwrap()
+                            .dump_unchecked(&mut crash_str);
                         crash_str.push(b'\n');
                     });
                 }
 
-                panic!("Children left in the rule tree on drop: {}", String::from_utf8_lossy(&crash_str).trim());
+                panic!(
+                    "Children left in the rule tree on drop: {}",
+                    String::from_utf8_lossy(&crash_str).trim()
+                );
             }
         }
 
diff --git a/components/style/servo/media_queries.rs b/components/style/servo/media_queries.rs
index fa288a92729..8c0ac014437 100644
--- a/components/style/servo/media_queries.rs
+++ b/components/style/servo/media_queries.rs
@@ -16,7 +16,7 @@ use crate::values::KeyframesName;
 use app_units::Au;
 use cssparser::RGBA;
 use euclid::default::Size2D as UntypedSize2D;
-use euclid::{Scale, Size2D, SideOffsets2D};
+use euclid::{Scale, SideOffsets2D, Size2D};
 use std::sync::atomic::{AtomicBool, AtomicIsize, Ordering};
 use style_traits::viewport::ViewportConstraints;
 use style_traits::{CSSPixel, DevicePixel};
diff --git a/components/style/sharing/mod.rs b/components/style/sharing/mod.rs
index 2d36aeea7ff..7f85104cb7c 100644
--- a/components/style/sharing/mod.rs
+++ b/components/style/sharing/mod.rs
@@ -173,7 +173,7 @@ impl ValidationData {
         E: TElement,
     {
         if !element.has_part_attr() {
-            return &[]
+            return &[];
         }
         self.part_list.get_or_insert_with(|| {
             let mut list = SmallVec::<[Atom; 5]>::new();
diff --git a/components/style/style_adjuster.rs b/components/style/style_adjuster.rs
index b7c1decc390..a2c6e5a2928 100644
--- a/components/style/style_adjuster.rs
+++ b/components/style/style_adjuster.rs
@@ -204,7 +204,10 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
             self.style.pseudo.map_or(false, |p| p.is_marker()) &&
                 self.style.get_parent_list().clone_list_style_position() ==
                     ListStylePosition::Outside &&
-                !layout_parent_style.get_box().clone_display().is_inline_flow()
+                !layout_parent_style
+                    .get_box()
+                    .clone_display()
+                    .is_inline_flow()
         );
 
         if !blockify {
@@ -241,7 +244,8 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
         }
 
         if self.style.is_root_element {
-            self.style.add_flags(ComputedValueFlags::IS_ROOT_ELEMENT_STYLE);
+            self.style
+                .add_flags(ComputedValueFlags::IS_ROOT_ELEMENT_STYLE);
         }
 
         #[cfg(feature = "servo-layout-2013")]
@@ -285,8 +289,10 @@ impl<'a, 'b: 'a> StyleAdjuster<'a, 'b> {
         let writing_mode = self.style.get_inherited_box().clone_writing_mode();
         let text_combine_upright = self.style.get_inherited_text().clone_text_combine_upright();
 
-        if matches!(writing_mode, WritingMode::VerticalRl | WritingMode::VerticalLr) &&
-            text_combine_upright == TextCombineUpright::All
+        if matches!(
+            writing_mode,
+            WritingMode::VerticalRl | WritingMode::VerticalLr
+        ) && text_combine_upright == TextCombineUpright::All
         {
             self.style.add_flags(ComputedValueFlags::IS_TEXT_COMBINED);
             self.style
diff --git a/components/style/values/animated/length.rs b/components/style/values/animated/length.rs
index 09724362441..04690446e64 100644
--- a/components/style/values/animated/length.rs
+++ b/components/style/values/animated/length.rs
@@ -30,6 +30,10 @@ impl Animate for LengthPercentage {
 
         // Gets clamped as needed after the animation if needed, so no need to
         // specify any particular AllowedNumericType.
-        Ok(LengthPercentage::new_calc(length, percentage, AllowedNumericType::All))
+        Ok(LengthPercentage::new_calc(
+            length,
+            percentage,
+            AllowedNumericType::All,
+        ))
     }
 }
diff --git a/components/style/values/computed/align.rs b/components/style/values/computed/align.rs
index c76c9018ac2..45d6cfac323 100644
--- a/components/style/values/computed/align.rs
+++ b/components/style/values/computed/align.rs
@@ -9,7 +9,9 @@
 use crate::values::computed::{Context, ToComputedValue};
 use crate::values::specified;
 
-pub use super::specified::{AlignContent, AlignItems, ContentDistribution, JustifyContent, SelfAlignment};
+pub use super::specified::{
+    AlignContent, AlignItems, ContentDistribution, JustifyContent, SelfAlignment,
+};
 pub use super::specified::{AlignSelf, JustifySelf};
 
 /// The computed value for the `justify-items` property.
diff --git a/components/style/values/computed/length.rs b/components/style/values/computed/length.rs
index 0c59b640558..eedd05d1f15 100644
--- a/components/style/values/computed/length.rs
+++ b/components/style/values/computed/length.rs
@@ -21,9 +21,9 @@ use std::ops::{Add, AddAssign, Div, Mul, Neg, Sub};
 use style_traits::{CSSPixel, CssWriter, ToCss};
 
 pub use super::image::Image;
+pub use super::length_percentage::{LengthPercentage, NonNegativeLengthPercentage};
 pub use crate::values::specified::url::UrlOrNone;
 pub use crate::values::specified::{Angle, BorderStyle, Time};
-pub use super::length_percentage::{LengthPercentage, NonNegativeLengthPercentage};
 
 impl ToComputedValue for specified::NoCalcLength {
     type ComputedValue = Length;
@@ -57,7 +57,9 @@ impl ToComputedValue for specified::Length {
     fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
         match *self {
             specified::Length::NoCalc(l) => l.to_computed_value(context),
-            specified::Length::Calc(ref calc) => calc.to_computed_value(context).to_length().unwrap(),
+            specified::Length::Calc(ref calc) => {
+                calc.to_computed_value(context).to_length().unwrap()
+            },
         }
     }
 
diff --git a/components/style/values/computed/length_percentage.rs b/components/style/values/computed/length_percentage.rs
index 7c1e831f7df..14b894e1da4 100644
--- a/components/style/values/computed/length_percentage.rs
+++ b/components/style/values/computed/length_percentage.rs
@@ -33,13 +33,13 @@ use crate::values::{specified, CSSFloat};
 use crate::Zero;
 use app_units::Au;
 use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 use std::fmt::{self, Write};
 use style_traits::values::specified::AllowedNumericType;
 use style_traits::{CssWriter, ToCss};
 
 #[doc(hidden)]
-#[derive(Copy, Clone)]
+#[derive(Clone, Copy)]
 #[repr(C)]
 pub struct LengthVariant {
     tag: u32,
@@ -47,7 +47,7 @@ pub struct LengthVariant {
 }
 
 #[doc(hidden)]
-#[derive(Copy, Clone)]
+#[derive(Clone, Copy)]
 #[repr(C)]
 pub struct PercentageVariant {
     tag: u32,
@@ -57,7 +57,7 @@ pub struct PercentageVariant {
 // NOTE(emilio): cbindgen only understands the #[cfg] on the top level
 // definition.
 #[doc(hidden)]
-#[derive(Copy, Clone)]
+#[derive(Clone, Copy)]
 #[repr(C)]
 #[cfg(target_pointer_width = "32")]
 pub struct CalcVariant {
@@ -66,7 +66,7 @@ pub struct CalcVariant {
 }
 
 #[doc(hidden)]
-#[derive(Copy, Clone)]
+#[derive(Clone, Copy)]
 #[repr(C)]
 #[cfg(target_pointer_width = "64")]
 pub struct CalcVariant {
@@ -78,7 +78,7 @@ unsafe impl Send for CalcVariant {}
 unsafe impl Sync for CalcVariant {}
 
 #[doc(hidden)]
-#[derive(Copy, Clone)]
+#[derive(Clone, Copy)]
 #[repr(C)]
 pub struct TagVariant {
     tag: u32,
@@ -123,7 +123,7 @@ impl LengthPercentageUnion {
     pub const TAG_MASK: u32 = 0b11;
 }
 
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 #[repr(u32)]
 enum Tag {
     Calc = LengthPercentageUnion::TAG_CALC,
@@ -171,7 +171,7 @@ enum Unpacked<'a> {
 
 /// An unpacked `<length-percentage>` that owns the `calc()` variant, for
 /// serialization purposes.
-#[derive(Deserialize, Serialize, PartialEq)]
+#[derive(Deserialize, PartialEq, Serialize)]
 enum Serializable {
     Calc(CalcLengthPercentage),
     Length(Length),
@@ -192,7 +192,7 @@ impl LengthPercentage {
             length: LengthVariant {
                 tag: LengthPercentageUnion::TAG_LENGTH,
                 length,
-            }
+            },
         });
         debug_assert_eq!(length.tag(), Tag::Length);
         length
@@ -205,7 +205,7 @@ impl LengthPercentage {
             percentage: PercentageVariant {
                 tag: LengthPercentageUnion::TAG_PERCENTAGE,
                 percentage,
-            }
+            },
         });
         debug_assert_eq!(percent.tag(), Tag::Percentage);
         percent
@@ -223,7 +223,7 @@ impl LengthPercentage {
             None => return Self::new_length(Length::new(clamping_mode.clamp(length.px()))),
         };
         if length.is_zero() {
-            return Self::new_percent(Percentage(clamping_mode.clamp(percentage.0)))
+            return Self::new_percent(Percentage(clamping_mode.clamp(percentage.0)));
         }
         Self::new_calc_unchecked(Box::new(CalcLengthPercentage {
             length,
@@ -241,7 +241,7 @@ impl LengthPercentage {
                 #[cfg(target_pointer_width = "32")]
                 tag: LengthPercentageUnion::TAG_CALC,
                 ptr,
-            }
+            },
         });
         debug_assert_eq!(calc.tag(), Tag::Calc);
         calc
@@ -293,7 +293,11 @@ impl LengthPercentage {
             Unpacked::Length(l) => l.px() == 0.0,
             Unpacked::Percentage(p) => p.0 == 0.0,
             Unpacked::Calc(ref c) => {
-                debug_assert_ne!(c.length.px(), 0.0, "Should've been simplified to a percentage");
+                debug_assert_ne!(
+                    c.length.px(),
+                    0.0,
+                    "Should've been simplified to a percentage"
+                );
                 false
             },
         }
@@ -374,7 +378,7 @@ impl LengthPercentage {
             Unpacked::Percentage(..) | Unpacked::Calc(..) => {
                 debug_assert!(self.has_percentage());
                 return None;
-            }
+            },
         }
     }
 
@@ -387,7 +391,7 @@ impl LengthPercentage {
             Unpacked::Calc(ref c) => {
                 debug_assert!(!c.length.is_zero());
                 None
-            }
+            },
         }
     }
 
@@ -400,7 +404,7 @@ impl LengthPercentage {
             Unpacked::Calc(ref c) => {
                 debug_assert!(self.has_percentage());
                 Some(c.percentage)
-            }
+            },
         }
     }
 
@@ -419,7 +423,8 @@ impl LengthPercentage {
     /// Convert the computed value into used value.
     #[inline]
     pub fn maybe_to_used_value(&self, container_len: Option<Length>) -> Option<Au> {
-        self.maybe_percentage_relative_to(container_len).map(Au::from)
+        self.maybe_percentage_relative_to(container_len)
+            .map(Au::from)
     }
 
     /// If there are special rules for computing percentages in a value (e.g.
@@ -470,7 +475,7 @@ impl Clone for LengthPercentage {
         match self.unpack() {
             Unpacked::Length(l) => Self::new_length(l),
             Unpacked::Percentage(p) => Self::new_percent(p),
-            Unpacked::Calc(c) => Self::new_calc_unchecked(Box::new(c.clone()))
+            Unpacked::Calc(c) => Self::new_calc_unchecked(Box::new(c.clone())),
         }
     }
 }
@@ -483,12 +488,8 @@ impl ToComputedValue for specified::LengthPercentage {
             specified::LengthPercentage::Length(ref value) => {
                 LengthPercentage::new_length(value.to_computed_value(context))
             },
-            specified::LengthPercentage::Percentage(value) => {
-                LengthPercentage::new_percent(value)
-            },
-            specified::LengthPercentage::Calc(ref calc) => {
-                (**calc).to_computed_value(context)
-            },
+            specified::LengthPercentage::Percentage(value) => LengthPercentage::new_percent(value),
+            specified::LengthPercentage::Calc(ref calc) => (**calc).to_computed_value(context),
         }
     }
 
@@ -496,15 +497,15 @@ impl ToComputedValue for specified::LengthPercentage {
         match computed.unpack() {
             Unpacked::Length(ref l) => {
                 specified::LengthPercentage::Length(ToComputedValue::from_computed_value(l))
-            }
-            Unpacked::Percentage(p) => {
-                specified::LengthPercentage::Percentage(p)
-            }
+            },
+            Unpacked::Percentage(p) => specified::LengthPercentage::Percentage(p),
             Unpacked::Calc(c) => {
                 // We simplify before constructing the LengthPercentage if
                 // needed, so this is always fine.
-                specified::LengthPercentage::Calc(Box::new(specified::CalcLengthPercentage::from_computed_value(c)))
-            }
+                specified::LengthPercentage::Calc(Box::new(
+                    specified::CalcLengthPercentage::from_computed_value(c),
+                ))
+            },
         }
     }
 }
@@ -517,7 +518,8 @@ impl ComputeSquaredDistance for LengthPercentage {
         // ensures that the distance between length-only and percentage-only
         // lengths makes sense.
         let basis = Length::new(100.);
-        self.resolve(basis).compute_squared_distance(&other.resolve(basis))
+        self.resolve(basis)
+            .compute_squared_distance(&other.resolve(basis))
     }
 }
 
@@ -555,14 +557,14 @@ impl<'de> Deserialize<'de> for LengthPercentage {
     where
         D: serde::Deserializer<'de>,
     {
-        Ok(Self::from_serializable(Serializable::deserialize(deserializer)?))
+        Ok(Self::from_serializable(Serializable::deserialize(
+            deserializer,
+        )?))
     }
 }
 
 /// The representation of a calc() function with mixed lengths and percentages.
-#[derive(
-    Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue,
-)]
+#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue)]
 #[repr(C)]
 pub struct CalcLengthPercentage {
     length: Length,
@@ -596,7 +598,11 @@ impl CalcLengthPercentage {
     /// Returns the clamped non-negative values.
     #[inline]
     fn clamp_to_non_negative(&self) -> LengthPercentage {
-        LengthPercentage::new_calc(self.length, Some(self.percentage), AllowedNumericType::NonNegative)
+        LengthPercentage::new_calc(
+            self.length,
+            Some(self.percentage),
+            AllowedNumericType::NonNegative,
+        )
     }
 }
 
@@ -629,8 +635,8 @@ impl specified::CalcLengthPercentage {
     where
         F: Fn(Length) -> Length,
     {
+        use crate::values::specified::length::{FontRelativeLength, ViewportPercentageLength};
         use std::f32;
-        use crate::values::specified::length::{ViewportPercentageLength, FontRelativeLength};
 
         let mut length = 0.;
 
@@ -764,4 +770,3 @@ impl NonNegativeLengthPercentage {
         Some(std::cmp::max(resolved, Au(0)))
     }
 }
-
diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs
index aaa2677777b..7cfd1e20abe 100644
--- a/components/style/values/computed/mod.rs
+++ b/components/style/values/computed/mod.rs
@@ -501,11 +501,9 @@ impl ToComputedValue for specified::AngleOrPercentage {
     #[inline]
     fn from_computed_value(computed: &AngleOrPercentage) -> Self {
         match *computed {
-            AngleOrPercentage::Percentage(percentage) => {
-                specified::AngleOrPercentage::Percentage(ToComputedValue::from_computed_value(
-                    &percentage,
-                ))
-            },
+            AngleOrPercentage::Percentage(percentage) => specified::AngleOrPercentage::Percentage(
+                ToComputedValue::from_computed_value(&percentage),
+            ),
             AngleOrPercentage::Angle(angle) => {
                 specified::AngleOrPercentage::Angle(ToComputedValue::from_computed_value(&angle))
             },
diff --git a/components/style/values/generics/counters.rs b/components/style/values/generics/counters.rs
index 88c83f87357..05e34703911 100644
--- a/components/style/values/generics/counters.rs
+++ b/components/style/values/generics/counters.rs
@@ -145,15 +145,7 @@ fn is_decimal(counter_type: &CounterStyleType) -> bool {
 ///
 /// https://drafts.csswg.org/css-content/#propdef-content
 #[derive(
-    Clone,
-    Debug,
-    Eq,
-    MallocSizeOf,
-    PartialEq,
-    SpecifiedValueInfo,
-    ToComputedValue,
-    ToCss,
-    ToShmem,
+    Clone, Debug, Eq, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToComputedValue, ToCss, ToShmem,
 )]
 #[repr(u8)]
 pub enum GenericContent<ImageUrl> {
diff --git a/components/style/values/resolved/counters.rs b/components/style/values/resolved/counters.rs
index daf70359061..bf6490f7401 100644
--- a/components/style/values/resolved/counters.rs
+++ b/components/style/values/resolved/counters.rs
@@ -23,8 +23,10 @@ impl ToResolvedValue for computed::Content {
 
     #[inline]
     fn to_resolved_value(self, context: &Context) -> Self {
-        let is_before_or_after =
-            context.style.pseudo().map_or(false, |p| p.is_before_or_after());
+        let is_before_or_after = context
+            .style
+            .pseudo()
+            .map_or(false, |p| p.is_before_or_after());
 
         match self {
             Self::Normal if is_before_or_after => Self::None,
@@ -43,4 +45,3 @@ impl ToResolvedValue for computed::Content {
         resolved
     }
 }
-
diff --git a/components/style/values/specified/angle.rs b/components/style/values/specified/angle.rs
index b42d5d5038f..fa60f66507d 100644
--- a/components/style/values/specified/angle.rs
+++ b/components/style/values/specified/angle.rs
@@ -228,9 +228,7 @@ impl Angle {
                 let function = CalcNode::math_function(name, location)?;
                 CalcNode::parse_angle(context, input, function)
             },
-            Token::Number { value, .. } if value == 0. && allow_unitless_zero => {
-                Ok(Angle::zero())
-            },
+            Token::Number { value, .. } if value == 0. && allow_unitless_zero => Ok(Angle::zero()),
             ref t => {
                 let t = t.clone();
                 Err(input.new_unexpected_token_error(t))
diff --git a/components/style/values/specified/box.rs b/components/style/values/specified/box.rs
index 11fbe6afb7b..fa5d5a2d43a 100644
--- a/components/style/values/specified/box.rs
+++ b/components/style/values/specified/box.rs
@@ -267,8 +267,7 @@ impl Display {
     /// Whether this is `display: inline` (or `inline list-item`).
     #[inline]
     pub fn is_inline_flow(&self) -> bool {
-        self.outside() == DisplayOutside::Inline &&
-            self.inside() == DisplayInside::Flow
+        self.outside() == DisplayOutside::Inline && self.inside() == DisplayInside::Flow
     }
 
     /// Returns whether this `display` value is some kind of list-item.
diff --git a/components/style/values/specified/calc.rs b/components/style/values/specified/calc.rs
index d008792eee5..9736491adce 100644
--- a/components/style/values/specified/calc.rs
+++ b/components/style/values/specified/calc.rs
@@ -20,7 +20,7 @@ use style_traits::values::specified::AllowedNumericType;
 use style_traits::{CssWriter, ParseError, SpecifiedValueInfo, StyleParseErrorKind, ToCss};
 
 /// The name of the mathematical function that we're parsing.
-#[derive(Debug, Copy, Clone)]
+#[derive(Clone, Copy, Debug)]
 pub enum MathFunction {
     /// `calc()`: https://drafts.csswg.org/css-values-4/#funcdef-calc
     Calc,
@@ -36,7 +36,7 @@ pub enum MathFunction {
 /// sum.
 ///
 /// See https://drafts.csswg.org/css-values-4/#sort-a-calculations-children
-#[derive(Debug, Copy, Clone, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
 enum SortKey {
     Number,
     Percentage,
@@ -55,7 +55,7 @@ enum SortKey {
 }
 
 /// Whether we're a `min` or `max` function.
-#[derive(Copy, Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub enum MinMaxOp {
     /// `min()`
     Min,
@@ -216,7 +216,11 @@ macro_rules! impl_generic_to_type {
                 }
                 $from_float(sum)
             },
-            Self::Clamp { ref min, ref center, ref max } => {
+            Self::Clamp {
+                ref min,
+                ref center,
+                ref max,
+            } => {
                 let min = min.$to_self()?;
                 let center = center.$to_self()?;
                 let max = max.$to_self()?;
@@ -265,7 +269,7 @@ macro_rules! impl_generic_to_type {
             Self::Percentage(..) |
             Self::Number(..) => return Err(()),
         })
-    }}
+    }};
 }
 
 impl PartialOrd for CalcNode {
@@ -327,7 +331,11 @@ impl CalcNode {
                 }
             },
             // Multiplication is distributive across these.
-            Self::Clamp { ref mut min, ref mut center, ref mut max } => {
+            Self::Clamp {
+                ref mut min,
+                ref mut center,
+                ref mut max,
+            } => {
                 min.mul_by(scalar);
                 center.mul_by(scalar);
                 max.mul_by(scalar);
@@ -345,27 +353,21 @@ impl CalcNode {
             Self::Percentage(..) => SortKey::Percentage,
             Self::Time(..) => SortKey::Sec,
             Self::Angle(..) => SortKey::Deg,
-            Self::Length(ref l) => {
-                match *l {
-                    NoCalcLength::Absolute(..) => SortKey::Px,
-                    NoCalcLength::FontRelative(ref relative) => {
-                        match *relative {
-                            FontRelativeLength::Ch(..) => SortKey::Ch,
-                            FontRelativeLength::Em(..) => SortKey::Em,
-                            FontRelativeLength::Ex(..) => SortKey::Ex,
-                            FontRelativeLength::Rem(..) => SortKey::Rem,
-                        }
-                    },
-                    NoCalcLength::ViewportPercentage(ref vp) => {
-                        match *vp {
-                            ViewportPercentageLength::Vh(..) => SortKey::Vh,
-                            ViewportPercentageLength::Vw(..) => SortKey::Vw,
-                            ViewportPercentageLength::Vmax(..) => SortKey::Vmax,
-                            ViewportPercentageLength::Vmin(..) => SortKey::Vmin,
-                        }
-                    },
-                    NoCalcLength::ServoCharacterWidth(..) => unreachable!(),
-                }
+            Self::Length(ref l) => match *l {
+                NoCalcLength::Absolute(..) => SortKey::Px,
+                NoCalcLength::FontRelative(ref relative) => match *relative {
+                    FontRelativeLength::Ch(..) => SortKey::Ch,
+                    FontRelativeLength::Em(..) => SortKey::Em,
+                    FontRelativeLength::Ex(..) => SortKey::Ex,
+                    FontRelativeLength::Rem(..) => SortKey::Rem,
+                },
+                NoCalcLength::ViewportPercentage(ref vp) => match *vp {
+                    ViewportPercentageLength::Vh(..) => SortKey::Vh,
+                    ViewportPercentageLength::Vw(..) => SortKey::Vw,
+                    ViewportPercentageLength::Vmax(..) => SortKey::Vmax,
+                    ViewportPercentageLength::Vmin(..) => SortKey::Vmin,
+                },
+                NoCalcLength::ServoCharacterWidth(..) => unreachable!(),
             },
             Self::Sum(..) | Self::MinMax(..) | Self::Clamp { .. } => SortKey::Other,
         }
@@ -375,22 +377,28 @@ impl CalcNode {
     ///
     /// Only handles leaf nodes, it's the caller's responsibility to simplify
     /// them before calling this if needed.
-    fn try_sum_in_place(&mut self, other: &Self) -> Result<(), ()> { use
-        self::CalcNode::*;
+    fn try_sum_in_place(&mut self, other: &Self) -> Result<(), ()> {
+        use self::CalcNode::*;
 
-        match (self, other) { (&mut Number(ref mut one), &Number(ref other)) |
-            (&mut Percentage(ref mut one), &Percentage(ref other)) => { *one +=
-                *other; } (&mut Angle(ref mut one), &Angle(ref other)) => { *one
-                    = specified::Angle::from_calc(one.degrees() +
-                        other.degrees()); } (&mut Time(ref mut one), &Time(ref
-                            other)) => { *one =
-                            specified::Time::from_calc(one.seconds() +
-                                other.seconds()); } (&mut Length(ref mut one),
-                                &Length(ref other)) => { *one =
-                                    one.try_sum(other)?; } _ => return Err(()),
+        match (self, other) {
+            (&mut Number(ref mut one), &Number(ref other)) |
+            (&mut Percentage(ref mut one), &Percentage(ref other)) => {
+                *one += *other;
+            },
+            (&mut Angle(ref mut one), &Angle(ref other)) => {
+                *one = specified::Angle::from_calc(one.degrees() + other.degrees());
+            },
+            (&mut Time(ref mut one), &Time(ref other)) => {
+                *one = specified::Time::from_calc(one.seconds() + other.seconds());
+            },
+            (&mut Length(ref mut one), &Length(ref other)) => {
+                *one = one.try_sum(other)?;
+            },
+            _ => return Err(()),
         }
 
-        Ok(()) }
+        Ok(())
+    }
 
     /// Simplifies and sorts the calculation. This is only needed if it's going
     /// to be preserved after parsing (so, for `<length-percentage>`). Otherwise
@@ -401,10 +409,14 @@ impl CalcNode {
             ($slot:expr) => {{
                 let result = mem::replace($slot, Self::Number(0.));
                 mem::replace(self, result);
-            }}
+            }};
         }
         match *self {
-            Self::Clamp { ref mut min, ref mut center, ref mut max } => {
+            Self::Clamp {
+                ref mut min,
+                ref mut center,
+                ref mut max,
+            } => {
                 min.simplify_and_sort_children();
                 center.simplify_and_sort_children();
                 max.simplify_and_sort_children();
@@ -518,10 +530,7 @@ impl CalcNode {
                     }
                 }
 
-                debug_assert!(
-                    children.len() >= 2,
-                    "Should still have multiple kids!"
-                );
+                debug_assert!(children.len() >= 2, "Should still have multiple kids!");
 
                 // Sort by spec order.
                 children.sort_unstable_by_key(|c| c.calc_node_sort_key());
@@ -542,11 +551,8 @@ impl CalcNode {
                 if let NoCalcLength::Absolute(ref mut absolute_length) = *len {
                     *absolute_length = AbsoluteLength::Px(absolute_length.to_px());
                 }
-            }
-            Self::Percentage(..) |
-            Self::Angle(..) |
-            Self::Time(..) |
-            Self::Number(..) => {
+            },
+            Self::Percentage(..) | Self::Angle(..) | Self::Time(..) | Self::Number(..) => {
                 // These are leaves already, nothing to do.
             },
         }
@@ -604,11 +610,9 @@ impl CalcNode {
             (&Token::Percentage { unit_value, .. }, CalcUnit::Percentage) => {
                 Ok(CalcNode::Percentage(unit_value))
             },
-            (&Token::ParenthesisBlock, _) => {
-                input.parse_nested_block(|input| {
-                    CalcNode::parse_argument(context, input, expected_unit)
-                })
-            },
+            (&Token::ParenthesisBlock, _) => input.parse_nested_block(|input| {
+                CalcNode::parse_argument(context, input, expected_unit)
+            }),
             (&Token::Function(ref name), _) => {
                 let function = CalcNode::math_function(name, location)?;
                 CalcNode::parse(context, input, function, expected_unit)
@@ -644,16 +648,17 @@ impl CalcNode {
                         max: Box::new(max),
                     })
                 },
-                MathFunction::Min |
-                MathFunction::Max => {
+                MathFunction::Min | MathFunction::Max => {
                     // TODO(emilio): The common case for parse_comma_separated
                     // is just one element, but for min / max is two, really...
                     //
                     // Consider adding an API to cssparser to specify the
                     // initial vector capacity?
-                    let arguments = input.parse_comma_separated(|input| {
-                        Self::parse_argument(context, input, expected_unit)
-                    })?.into_boxed_slice();
+                    let arguments = input
+                        .parse_comma_separated(|input| {
+                            Self::parse_argument(context, input, expected_unit)
+                        })?
+                        .into_boxed_slice();
 
                     let op = match function {
                         MathFunction::Min => MinMaxOp::Min,
@@ -662,7 +667,7 @@ impl CalcNode {
                     };
 
                     Ok(Self::MinMax(arguments, op))
-                }
+                },
             }
         })
     }
@@ -751,7 +756,9 @@ impl CalcNode {
                     let number = match rhs.to_number() {
                         Ok(n) if n != 0. => n,
                         _ => {
-                            return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError));
+                            return Err(
+                                input.new_custom_error(StyleParseErrorKind::UnspecifiedError)
+                            );
                         },
                     };
                     node.mul_by(1. / number);
@@ -838,10 +845,9 @@ impl CalcNode {
                     child.add_length_or_percentage_to(ret, factor)?;
                 }
             },
-            CalcNode::MinMax(..) |
-            CalcNode::Clamp { .. } => {
+            CalcNode::MinMax(..) | CalcNode::Clamp { .. } => {
                 // FIXME(emilio): Implement min/max/clamp for length-percentage.
-                return Err(())
+                return Err(());
             },
             CalcNode::Angle(..) | CalcNode::Time(..) | CalcNode::Number(..) => return Err(()),
         }
diff --git a/components/style/values/specified/length.rs b/components/style/values/specified/length.rs
index 3b971b422c2..ff24404c09a 100644
--- a/components/style/values/specified/length.rs
+++ b/components/style/values/specified/length.rs
@@ -111,7 +111,9 @@ impl FontRelativeLength {
             // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
             // able to figure it own on its own so we help.
             _ => unsafe {
-                match *self { Em(..) | Ex(..) | Ch(..) | Rem(..) => {} }
+                match *self {
+                    Em(..) | Ex(..) | Ch(..) | Rem(..) => {},
+                }
                 debug_unreachable!("Forgot to handle unit in try_sum()")
             },
         })
@@ -283,7 +285,9 @@ impl ViewportPercentageLength {
             // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
             // able to figure it own on its own so we help.
             _ => unsafe {
-                match *self { Vw(..) | Vh(..) | Vmin(..) | Vmax(..) => {} }
+                match *self {
+                    Vw(..) | Vh(..) | Vmin(..) | Vmax(..) => {},
+                }
                 debug_unreachable!("Forgot to handle unit in try_sum()")
             },
         })
@@ -527,14 +531,21 @@ impl NoCalcLength {
         Ok(match (self, other) {
             (&Absolute(ref one), &Absolute(ref other)) => Absolute(*one + *other),
             (&FontRelative(ref one), &FontRelative(ref other)) => FontRelative(one.try_sum(other)?),
-            (&ViewportPercentage(ref one), &ViewportPercentage(ref other)) => ViewportPercentage(one.try_sum(other)?),
+            (&ViewportPercentage(ref one), &ViewportPercentage(ref other)) => {
+                ViewportPercentage(one.try_sum(other)?)
+            },
             (&ServoCharacterWidth(ref one), &ServoCharacterWidth(ref other)) => {
                 ServoCharacterWidth(CharacterWidth(one.0 + other.0))
             },
             // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
             // able to figure it own on its own so we help.
             _ => unsafe {
-                match *self { Absolute(..) | FontRelative(..) | ViewportPercentage(..) | ServoCharacterWidth(..) => {} }
+                match *self {
+                    Absolute(..) |
+                    FontRelative(..) |
+                    ViewportPercentage(..) |
+                    ServoCharacterWidth(..) => {},
+                }
                 debug_unreachable!("Forgot to handle unit in try_sum()")
             },
         })
@@ -569,12 +580,21 @@ impl PartialOrd for NoCalcLength {
         match (self, other) {
             (&Absolute(ref one), &Absolute(ref other)) => one.to_px().partial_cmp(&other.to_px()),
             (&FontRelative(ref one), &FontRelative(ref other)) => one.partial_cmp(other),
-            (&ViewportPercentage(ref one), &ViewportPercentage(ref other)) => one.partial_cmp(other),
-            (&ServoCharacterWidth(ref one), &ServoCharacterWidth(ref other)) => one.0.partial_cmp(&other.0),
+            (&ViewportPercentage(ref one), &ViewportPercentage(ref other)) => {
+                one.partial_cmp(other)
+            },
+            (&ServoCharacterWidth(ref one), &ServoCharacterWidth(ref other)) => {
+                one.0.partial_cmp(&other.0)
+            },
             // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
             // able to figure it own on its own so we help.
             _ => unsafe {
-                match *self { Absolute(..) | FontRelative(..) | ViewportPercentage(..) | ServoCharacterWidth(..) => {} }
+                match *self {
+                    Absolute(..) |
+                    FontRelative(..) |
+                    ViewportPercentage(..) |
+                    ServoCharacterWidth(..) => {},
+                }
                 debug_unreachable!("Forgot an arm in partial_cmp?")
             },
         }
@@ -645,7 +665,9 @@ impl PartialOrd for FontRelativeLength {
             // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
             // able to figure it own on its own so we help.
             _ => unsafe {
-                match *self { Em(..) | Ex(..) | Ch(..) | Rem(..) => {} }
+                match *self {
+                    Em(..) | Ex(..) | Ch(..) | Rem(..) => {},
+                }
                 debug_unreachable!("Forgot an arm in partial_cmp?")
             },
         }
@@ -696,7 +718,9 @@ impl PartialOrd for ViewportPercentageLength {
             // See https://github.com/rust-lang/rust/issues/68867. rustc isn't
             // able to figure it own on its own so we help.
             _ => unsafe {
-                match *self { Vw(..) | Vh(..) | Vmin(..) | Vmax(..) => {} }
+                match *self {
+                    Vw(..) | Vh(..) | Vmin(..) | Vmax(..) => {},
+                }
                 debug_unreachable!("Forgot an arm in partial_cmp?")
             },
         }
@@ -957,7 +981,8 @@ impl LengthPercentage {
             },
             Token::Function(ref name) => {
                 let function = CalcNode::math_function(name, location)?;
-                let calc = CalcNode::parse_length_or_percentage(context, input, num_context, function)?;
+                let calc =
+                    CalcNode::parse_length_or_percentage(context, input, num_context, function)?;
                 Ok(LengthPercentage::Calc(Box::new(calc)))
             },
             _ => return Err(location.new_unexpected_token_error(token.clone())),
diff --git a/components/style/values/specified/mod.rs b/components/style/values/specified/mod.rs
index 2d8160b17b9..54401045809 100644
--- a/components/style/values/specified/mod.rs
+++ b/components/style/values/specified/mod.rs
@@ -31,7 +31,7 @@ use style_traits::{CssWriter, ParseError, SpecifiedValueInfo, StyleParseErrorKin
 pub use self::align::{AlignContent, AlignItems, AlignSelf, ContentDistribution};
 #[cfg(feature = "gecko")]
 pub use self::align::{JustifyContent, JustifyItems, JustifySelf, SelfAlignment};
-pub use self::angle::{Angle, AllowUnitlessZeroAngle};
+pub use self::angle::{AllowUnitlessZeroAngle, Angle};
 pub use self::background::{BackgroundRepeat, BackgroundSize};
 pub use self::basic_shape::FillRule;
 pub use self::border::{BorderCornerRadius, BorderImageSlice, BorderImageWidth};
diff --git a/components/style/values/specified/position.rs b/components/style/values/specified/position.rs
index d599d6a85d9..3f01988e49d 100644
--- a/components/style/values/specified/position.rs
+++ b/components/style/values/specified/position.rs
@@ -22,8 +22,8 @@ use cssparser::Parser;
 use selectors::parser::SelectorParseErrorKind;
 use servo_arc::Arc;
 use std::fmt::{self, Write};
-use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
 use style_traits::values::specified::AllowedNumericType;
+use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss};
 
 /// The specified value of a CSS `<position>`
 pub type Position = GenericPosition<HorizontalPosition, VerticalPosition>;

From d5b49f14da9da7982bf1568f215cbca64df2613d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Sat, 1 Feb 2020 00:32:51 +0100
Subject: [PATCH 64/66] style: Fix LengthPercentage on big-endian machines.

Always store the pointer in little-endian order so that the tag trick works.

Differential Revision: https://phabricator.services.mozilla.com/D61386
---
 .../values/computed/length_percentage.rs      | 59 +++++++++++++------
 1 file changed, 40 insertions(+), 19 deletions(-)

diff --git a/components/style/values/computed/length_percentage.rs b/components/style/values/computed/length_percentage.rs
index 14b894e1da4..96bf76c98d4 100644
--- a/components/style/values/computed/length_percentage.rs
+++ b/components/style/values/computed/length_percentage.rs
@@ -42,7 +42,7 @@ use style_traits::{CssWriter, ToCss};
 #[derive(Clone, Copy)]
 #[repr(C)]
 pub struct LengthVariant {
-    tag: u32,
+    tag: u8,
     length: Length,
 }
 
@@ -50,7 +50,7 @@ pub struct LengthVariant {
 #[derive(Clone, Copy)]
 #[repr(C)]
 pub struct PercentageVariant {
-    tag: u32,
+    tag: u8,
     percentage: Percentage,
 }
 
@@ -61,7 +61,7 @@ pub struct PercentageVariant {
 #[repr(C)]
 #[cfg(target_pointer_width = "32")]
 pub struct CalcVariant {
-    tag: u32,
+    tag: u8,
     ptr: *mut CalcLengthPercentage,
 }
 
@@ -70,7 +70,7 @@ pub struct CalcVariant {
 #[repr(C)]
 #[cfg(target_pointer_width = "64")]
 pub struct CalcVariant {
-    ptr: *mut CalcLengthPercentage,
+    ptr: usize, // In little-endian byte order
 }
 
 // `CalcLengthPercentage` is `Send + Sync` as asserted below.
@@ -81,7 +81,7 @@ unsafe impl Sync for CalcVariant {}
 #[derive(Clone, Copy)]
 #[repr(C)]
 pub struct TagVariant {
-    tag: u32,
+    tag: u8,
 }
 
 /// A `<length-percentage>` value. This can be either a `<length>`, a
@@ -114,17 +114,17 @@ pub union LengthPercentageUnion {
 
 impl LengthPercentageUnion {
     #[doc(hidden)] // Need to be public so that cbindgen generates it.
-    pub const TAG_CALC: u32 = 0;
+    pub const TAG_CALC: u8 = 0;
     #[doc(hidden)]
-    pub const TAG_LENGTH: u32 = 1;
+    pub const TAG_LENGTH: u8 = 1;
     #[doc(hidden)]
-    pub const TAG_PERCENTAGE: u32 = 2;
+    pub const TAG_PERCENTAGE: u8 = 2;
     #[doc(hidden)]
-    pub const TAG_MASK: u32 = 0b11;
+    pub const TAG_MASK: u8 = 0b11;
 }
 
 #[derive(Clone, Copy, Debug, PartialEq)]
-#[repr(u32)]
+#[repr(u8)]
 enum Tag {
     Calc = LengthPercentageUnion::TAG_CALC,
     Length = LengthPercentageUnion::TAG_LENGTH,
@@ -147,7 +147,7 @@ unsafe fn static_assert() {
 impl Drop for LengthPercentage {
     fn drop(&mut self) {
         if self.tag() == Tag::Calc {
-            let _ = unsafe { Box::from_raw(self.0.calc.ptr) };
+            let _ = unsafe { Box::from_raw(self.calc_ptr()) };
         }
     }
 }
@@ -236,13 +236,22 @@ impl LengthPercentage {
     /// checking.
     fn new_calc_unchecked(calc: Box<CalcLengthPercentage>) -> Self {
         let ptr = Box::into_raw(calc);
-        let calc = Self(LengthPercentageUnion {
-            calc: CalcVariant {
-                #[cfg(target_pointer_width = "32")]
-                tag: LengthPercentageUnion::TAG_CALC,
-                ptr,
-            },
-        });
+
+        #[cfg(target_pointer_width = "32")]
+        let calc = CalcVariant {
+            tag: LengthPercentageUnion::TAG_CALC,
+            ptr,
+        };
+
+        #[cfg(target_pointer_width = "64")]
+        let calc = CalcVariant {
+            #[cfg(target_endian = "little")]
+            ptr: ptr as usize,
+            #[cfg(target_endian = "big")]
+            ptr: (ptr as usize).swap_bytes(),
+        };
+
+        let calc = Self(LengthPercentageUnion { calc });
         debug_assert_eq!(calc.tag(), Tag::Calc);
         calc
     }
@@ -261,13 +270,25 @@ impl LengthPercentage {
     fn unpack<'a>(&'a self) -> Unpacked<'a> {
         unsafe {
             match self.tag() {
-                Tag::Calc => Unpacked::Calc(&*self.0.calc.ptr),
+                Tag::Calc => Unpacked::Calc(&*self.calc_ptr()),
                 Tag::Length => Unpacked::Length(self.0.length.length),
                 Tag::Percentage => Unpacked::Percentage(self.0.percentage.percentage),
             }
         }
     }
 
+    #[inline]
+    unsafe fn calc_ptr(&self) -> *mut CalcLengthPercentage {
+        #[cfg(not(all(target_endian = "big", target_pointer_width = "64")))]
+        {
+            self.0.calc.ptr as *mut _
+        }
+        #[cfg(all(target_endian = "big", target_pointer_width = "64"))]
+        {
+            self.0.calc.ptr.swap_bytes() as *mut _
+        }
+    }
+
     #[inline]
     fn to_serializable(&self) -> Serializable {
         match self.unpack() {

From e6a1e484c2cc2969e36f0a0abb47d42aae804c2d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Tue, 11 Feb 2020 14:03:02 +0100
Subject: [PATCH 65/66] Fix benchmark that was no longer building.

---
 tests/unit/style/custom_properties.rs | 12 +++++++++---
 tests/unit/style/viewport.rs          |  3 +--
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/tests/unit/style/custom_properties.rs b/tests/unit/style/custom_properties.rs
index 5b5741d2690..5bb0a800812 100644
--- a/tests/unit/style/custom_properties.rs
+++ b/tests/unit/style/custom_properties.rs
@@ -3,10 +3,12 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use cssparser::{Parser, ParserInput};
+use euclid::{Scale, Size2D};
 use servo_arc::Arc;
 use style::custom_properties::{
-    CssEnvironment, CustomPropertiesBuilder, CustomPropertiesMap, Name, SpecifiedValue,
+    CustomPropertiesBuilder, CustomPropertiesMap, Name, SpecifiedValue,
 };
+use style::media_queries::{Device, MediaType};
 use style::properties::{CustomDeclaration, CustomDeclarationValue};
 use style::stylesheets::Origin;
 use test::{self, Bencher};
@@ -26,8 +28,12 @@ fn cascade(
         })
         .collect::<Vec<_>>();
 
-    let env = CssEnvironment;
-    let mut builder = CustomPropertiesBuilder::new(inherited, &env);
+    let device = Device::new(
+        MediaType::screen(),
+        Size2D::new(800., 600.),
+        Scale::new(1.0),
+    );
+    let mut builder = CustomPropertiesBuilder::new(inherited, &device);
 
     for declaration in &declarations {
         builder.cascade(declaration, Origin::Author);
diff --git a/tests/unit/style/viewport.rs b/tests/unit/style/viewport.rs
index 636a6321d89..eeedc653fc8 100644
--- a/tests/unit/style/viewport.rs
+++ b/tests/unit/style/viewport.rs
@@ -3,8 +3,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use cssparser::{Parser, ParserInput};
-use euclid::Scale;
-use euclid::Size2D;
+use euclid::{Scale, Size2D};
 use servo_arc::Arc;
 use servo_config::set_pref;
 use servo_url::ServoUrl;

From d1f8d576f83714fe674a36c5b718341c236312e6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Wed, 12 Feb 2020 02:42:56 +0100
Subject: [PATCH 66/66] Update test expectations.

---
 tests/wpt/metadata/css/css-transforms/inheritance.html.ini | 3 +++
 .../css/css-values/calc-serialization-002.html.ini         | 7 -------
 2 files changed, 3 insertions(+), 7 deletions(-)
 delete mode 100644 tests/wpt/metadata/css/css-values/calc-serialization-002.html.ini

diff --git a/tests/wpt/metadata/css/css-transforms/inheritance.html.ini b/tests/wpt/metadata/css/css-transforms/inheritance.html.ini
index f28c3adf97c..b7b8208532b 100644
--- a/tests/wpt/metadata/css/css-transforms/inheritance.html.ini
+++ b/tests/wpt/metadata/css/css-transforms/inheritance.html.ini
@@ -14,3 +14,6 @@
   [Property transform-box does not inherit]
     expected: FAIL
 
+  [Property transform-style has initial value auto]
+    expected: FAIL
+
diff --git a/tests/wpt/metadata/css/css-values/calc-serialization-002.html.ini b/tests/wpt/metadata/css/css-values/calc-serialization-002.html.ini
deleted file mode 100644
index 30e9a093c56..00000000000
--- a/tests/wpt/metadata/css/css-values/calc-serialization-002.html.ini
+++ /dev/null
@@ -1,7 +0,0 @@
-[calc-serialization-002.html]
-  [testing calc(1em + 1.27cm + 13% + 3em)]
-    expected: FAIL
-
-  [testing calc(25.4q + 1vh + 12%)]
-    expected: FAIL
-