Auto merge of #25299 - emilio:gecko-sync, r=emilio,nox

style: Sync changes from mozilla-central.

See individual commits for details.

80 files changed, 770 insertions, 450 deletions

diff --git a/Cargo.lock b/Cargo.lock
index f8bcf052113..ac076d7dca6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -887,7 +887,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f0ed1a4de2235cabda8558ff5840bffb97fcb64c97827f354a451307df5f72b"
 dependencies = [
  "crossbeam-utils",
- "smallvec",
+ "smallvec 0.6.10",
 ]
 
 [[package]]
@@ -947,7 +947,7 @@ dependencies = [
  "proc-macro2 1.0.1",
  "quote 1.0.2",
  "serde",
- "smallvec",
+ "smallvec 0.6.10",
  "syn 1.0.3",
 ]
 
@@ -1103,6 +1103,17 @@ dependencies = [
 ]
 
 [[package]]
+name = "derive_more"
+version = "0.99.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2159be042979966de68315bce7034bb000c775f22e3e834e1c52ff78f041cae8"
+dependencies = [
+ "proc-macro2 1.0.1",
+ "quote 1.0.2",
+ "syn 1.0.3",
+]
+
+[[package]]
 name = "device"
 version = "0.0.1"
 source = "git+https://github.com/servo/devices#cb28c4725ffbfece99dab842d17d3e8c50774778"
@@ -1387,7 +1398,7 @@ name = "fallible"
 version = "0.0.1"
 dependencies = [
  "hashglobe",
- "smallvec",
+ "smallvec 1.0.0",
 ]
 
 [[package]]
@@ -1609,7 +1620,7 @@ dependencies = [
  "servo_arc",
  "servo_atoms",
  "servo_url",
- "smallvec",
+ "smallvec 0.6.10",
  "style",
  "time",
  "truetype",
@@ -1646,7 +1657,7 @@ dependencies = [
  "parking_lot",
  "range-alloc",
  "raw-window-handle",
- "smallvec",
+ "smallvec 0.6.10",
  "spirv_cross",
  "winapi",
  "wio",
@@ -1665,7 +1676,7 @@ dependencies = [
  "log",
  "range-alloc",
  "raw-window-handle",
- "smallvec",
+ "smallvec 0.6.10",
  "spirv_cross",
  "winapi",
 ]
@@ -1702,7 +1713,7 @@ dependencies = [
  "parking_lot",
  "range-alloc",
  "raw-window-handle",
- "smallvec",
+ "smallvec 0.6.10",
  "spirv_cross",
  "storage-map",
 ]
@@ -1722,7 +1733,7 @@ dependencies = [
  "log",
  "objc",
  "raw-window-handle",
- "smallvec",
+ "smallvec 0.6.10",
  "winapi",
  "x11",
 ]
@@ -1735,7 +1746,7 @@ checksum = "7c88981665c780447bb08eb099e1ded330754a7246719bab927ee4a949c0ba7f"
 dependencies = [
  "bitflags",
  "raw-window-handle",
- "smallvec",
+ "smallvec 0.6.10",
 ]
 
 [[package]]
@@ -2706,7 +2717,7 @@ dependencies = [
  "servo_geometry",
  "servo_url",
  "size_of_test",
- "smallvec",
+ "smallvec 0.6.10",
  "style",
  "style_traits",
  "unicode-bidi",
@@ -2938,7 +2949,7 @@ dependencies = [
  "rust-webvr",
  "servo-egl",
  "simpleservo",
- "smallvec",
+ "smallvec 0.6.10",
  "webxr",
  "webxr-api",
 ]
@@ -3137,7 +3148,7 @@ dependencies = [
  "serde_bytes",
  "servo_arc",
  "smallbitvec",
- "smallvec",
+ "smallvec 1.0.0",
  "string_cache",
  "thin-slice",
  "time",
@@ -3812,7 +3823,7 @@ dependencies = [
  "libc",
  "redox_syscall",
  "rustc_version",
- "smallvec",
+ "smallvec 0.6.10",
  "winapi",
 ]
 
@@ -4307,7 +4318,7 @@ dependencies = [
  "gfx-hal",
  "log",
  "relevant",
- "smallvec",
+ "smallvec 0.6.10",
 ]
 
 [[package]]
@@ -4322,7 +4333,7 @@ dependencies = [
  "log",
  "relevant",
  "slab",
- "smallvec",
+ "smallvec 0.6.10",
 ]
 
 [[package]]
@@ -4514,7 +4525,7 @@ dependencies = [
  "servo_geometry",
  "servo_rand",
  "servo_url",
- "smallvec",
+ "smallvec 0.6.10",
  "sparkle",
  "style",
  "style_traits",
@@ -4633,7 +4644,7 @@ version = "0.21.0"
 dependencies = [
  "bitflags",
  "cssparser",
- "derive_more",
+ "derive_more 0.99.2",
  "fxhash",
  "log",
  "matches",
@@ -4641,7 +4652,7 @@ dependencies = [
  "phf_codegen",
  "precomputed-hash",
  "servo_arc",
- "smallvec",
+ "smallvec 1.0.0",
  "thin-slice",
  "to_shmem",
  "to_shmem_derive",
@@ -4836,7 +4847,7 @@ dependencies = [
  "servo-media-player",
  "servo-media-traits",
  "servo_media_derive",
- "smallvec",
+ "smallvec 0.6.10",
 ]
 
 [[package]]
@@ -5224,6 +5235,12 @@ dependencies = [
 ]
 
 [[package]]
+name = "smallvec"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ecf3b85f68e8abaa7555aa5abdb1153079387e60b718283d732f03897fcfc86"
+
+[[package]]
 name = "smithay-client-toolkit"
 version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -5351,7 +5368,7 @@ dependencies = [
  "byteorder",
  "crossbeam-channel",
  "cssparser",
- "derive_more",
+ "derive_more 0.99.2",
  "encoding_rs",
  "euclid",
  "fallible",
@@ -5384,7 +5401,7 @@ dependencies = [
  "servo_config",
  "servo_url",
  "smallbitvec",
- "smallvec",
+ "smallvec 1.0.0",
  "string_cache",
  "style_derive",
  "style_traits",
@@ -5689,7 +5706,7 @@ dependencies = [
  "cssparser",
  "servo_arc",
  "smallbitvec",
- "smallvec",
+ "smallvec 1.0.0",
  "string_cache",
  "thin-slice",
 ]
@@ -6279,7 +6296,7 @@ dependencies = [
  "malloc_size_of",
  "serde",
  "servo_config",
- "smallvec",
+ "smallvec 0.6.10",
  "wgpu-core",
 ]
 
@@ -6314,7 +6331,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sha2",
- "smallvec",
+ "smallvec 0.6.10",
  "svg_fmt",
  "thread_profiler",
  "time",
@@ -6334,7 +6351,7 @@ dependencies = [
  "byteorder",
  "core-foundation",
  "core-graphics",
- "derive_more",
+ "derive_more 0.13.0",
  "euclid",
  "malloc_size_of_derive",
  "peek-poke",
@@ -6443,7 +6460,7 @@ dependencies = [
  "rendy-descriptor",
  "rendy-memory",
  "serde",
- "smallvec",
+ "smallvec 0.6.10",
  "vec_map",
 ]
 
diff --git a/components/fallible/Cargo.toml b/components/fallible/Cargo.toml
index e8f5314693b..49064da33ea 100644
--- a/components/fallible/Cargo.toml
+++ b/components/fallible/Cargo.toml
@@ -10,7 +10,7 @@ name = "fallible"
 path = "lib.rs"
 
 [dependencies]
-smallvec = "0.6"
+smallvec = "1.0"
 hashglobe = { path = "../hashglobe" }
 
 # This crate effectively does nothing except if the `known_system_malloc`
diff --git a/components/gfx/font.rs b/components/gfx/font.rs
index 3dd5ac9f244..439784ba680 100644
--- a/components/gfx/font.rs
+++ b/components/gfx/font.rs
@@ -131,7 +131,7 @@ impl<'a> From<&'a FontStyleStruct> for FontDescriptor {
         FontDescriptor {
             template_descriptor: FontTemplateDescriptor::from(style),
             variant: style.font_variant_caps,
-            pt_size: style.font_size.size(),
+            pt_size: Au::from_f32_px(style.font_size.size().px()),
         }
     }
 }
diff --git a/components/gfx/font_context.rs b/components/gfx/font_context.rs
index 06755205935..113b384f84d 100644
--- a/components/gfx/font_context.rs
+++ b/components/gfx/font_context.rs
@@ -95,7 +95,7 @@ impl<S: FontSource> FontContext<S> {
         self.expire_font_caches_if_necessary();
 
         let cache_key = FontGroupCacheKey {
-            size: style.font_size.size(),
+            size: Au::from_f32_px(style.font_size.size().px()),
             style,
         };
 
diff --git a/components/layout/block.rs b/components/layout/block.rs
index 80c0fae2243..4b0999489ee 100644
--- a/components/layout/block.rs
+++ b/components/layout/block.rs
@@ -2029,7 +2029,7 @@ impl BlockFlow {
         // If `max-width` is set, then don't perform this speculation. We guess that the
         // page set `max-width` in order to avoid hitting floats. The search box on Google
         // SERPs falls into this category.
-        if self.fragment.style.max_inline_size() != MaxSize::None {
+        if !matches!(self.fragment.style.max_inline_size(), MaxSize::None) {
             return;
         }
 
@@ -2548,8 +2548,16 @@ impl Flow for BlockFlow {
             .base
             .flags
             .contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) &&
-            self.fragment.style().logical_position().inline_start == LengthPercentageOrAuto::Auto &&
-            self.fragment.style().logical_position().inline_end == LengthPercentageOrAuto::Auto
+            self.fragment
+                .style()
+                .logical_position()
+                .inline_start
+                .is_auto() &&
+            self.fragment
+                .style()
+                .logical_position()
+                .inline_end
+                .is_auto()
         {
             self.base.position.start.i = inline_position
         }
@@ -2560,8 +2568,12 @@ impl Flow for BlockFlow {
             .base
             .flags
             .contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) &&
-            self.fragment.style().logical_position().block_start == LengthPercentageOrAuto::Auto &&
-            self.fragment.style().logical_position().block_end == LengthPercentageOrAuto::Auto
+            self.fragment
+                .style()
+                .logical_position()
+                .block_start
+                .is_auto() &&
+            self.fragment.style().logical_position().block_end.is_auto()
         {
             self.base.position.start.b = block_position
         }
@@ -2848,16 +2860,15 @@ pub trait ISizeAndMarginsComputer {
         parent_flow_inline_size: Au,
         shared_context: &SharedStyleContext,
     ) -> MaybeAuto {
+        let inline_size =
+            self.containing_block_inline_size(block, parent_flow_inline_size, shared_context);
+
         MaybeAuto::from_option(
             block
                 .fragment()
                 .style()
                 .content_inline_size()
-                .to_used_value(self.containing_block_inline_size(
-                    block,
-                    parent_flow_inline_size,
-                    shared_context,
-                )),
+                .to_used_value(inline_size),
         )
     }
 
diff --git a/components/layout/display_list/background.rs b/components/layout/display_list/background.rs
index 9d05cef9054..c08dcfe8598 100644
--- a/components/layout/display_list/background.rs
+++ b/components/layout/display_list/background.rs
@@ -47,7 +47,7 @@ pub fn get_cyclic<T>(arr: &[T], index: usize) -> &T {
 /// For a given area and an image compute how big the
 /// image should be displayed on the background.
 fn compute_background_image_size(
-    bg_size: BackgroundSize,
+    bg_size: &BackgroundSize,
     bounds_size: Size2D<Au>,
     intrinsic_size: Option<Size2D<Au>>,
 ) -> Size2D<Au> {
@@ -156,7 +156,7 @@ pub fn placement(
     let bg_position_x = get_cyclic(&bg.background_position_x.0, index);
     let bg_position_y = get_cyclic(&bg.background_position_y.0, index);
     let bg_repeat = get_cyclic(&bg.background_repeat.0, index);
-    let bg_size = *get_cyclic(&bg.background_size.0, index);
+    let bg_size = get_cyclic(&bg.background_size.0, index);
 
     let (clip_rect, clip_radii) = clip(
         bg_clip,
diff --git a/components/layout/display_list/border.rs b/components/layout/display_list/border.rs
index 4970b2a34de..14ca2abe84f 100644
--- a/components/layout/display_list/border.rs
+++ b/components/layout/display_list/border.rs
@@ -25,7 +25,7 @@ use webrender_api::{BorderRadius, BorderSide, BorderStyle, ColorF, NormalBorder}
 ///
 /// [1]: https://drafts.csswg.org/css-backgrounds-3/#border-radius
 fn corner_radius(
-    radius: BorderCornerRadius,
+    radius: &BorderCornerRadius,
     containing_size: UntypedSize2D<Au>,
 ) -> UntypedSize2D<Au> {
     let w = radius.0.width().to_used_value(containing_size.width);
@@ -91,13 +91,13 @@ pub fn radii(abs_bounds: Rect<Au>, border_style: &Border) -> BorderRadius {
     overlapping_radii(
         abs_bounds.size.to_layout(),
         BorderRadius {
-            top_left: corner_radius(border_style.border_top_left_radius, abs_bounds.size)
+            top_left: corner_radius(&border_style.border_top_left_radius, abs_bounds.size)
                 .to_layout(),
-            top_right: corner_radius(border_style.border_top_right_radius, abs_bounds.size)
+            top_right: corner_radius(&border_style.border_top_right_radius, abs_bounds.size)
                 .to_layout(),
-            bottom_right: corner_radius(border_style.border_bottom_right_radius, abs_bounds.size)
+            bottom_right: corner_radius(&border_style.border_bottom_right_radius, abs_bounds.size)
                 .to_layout(),
-            bottom_left: corner_radius(border_style.border_bottom_left_radius, abs_bounds.size)
+            bottom_left: corner_radius(&border_style.border_bottom_left_radius, abs_bounds.size)
                 .to_layout(),
         },
     )
@@ -161,7 +161,7 @@ pub fn image_outset(
 }
 
 fn side_image_width(
-    border_image_width: BorderImageSideWidth,
+    border_image_width: &BorderImageSideWidth,
     border_width: f32,
     total_length: Au,
 ) -> f32 {
@@ -178,10 +178,10 @@ pub fn image_width(
     border_area: UntypedSize2D<Au>,
 ) -> LayoutSideOffsets {
     LayoutSideOffsets::new(
-        side_image_width(width.0, border.top, border_area.height),
-        side_image_width(width.1, border.right, border_area.width),
-        side_image_width(width.2, border.bottom, border_area.height),
-        side_image_width(width.3, border.left, border_area.width),
+        side_image_width(&width.0, border.top, border_area.height),
+        side_image_width(&width.1, border.right, border_area.width),
+        side_image_width(&width.2, border.bottom, border_area.height),
+        side_image_width(&width.3, border.left, border_area.width),
     )
 }
 
diff --git a/components/layout/display_list/builder.rs b/components/layout/display_list/builder.rs
index 258c4f5490c..542ab95172a 100644
--- a/components/layout/display_list/builder.rs
+++ b/components/layout/display_list/builder.rs
@@ -995,7 +995,7 @@ impl Fragment {
                     };
                     DisplayItem::Gradient(CommonDisplayItem::with_data(base, item, stops))
                 },
-                GradientKind::Radial(shape, center) => {
+                GradientKind::Radial(ref shape, ref center) => {
                     let (gradient, stops) = gradient::radial(
                         style,
                         placement.tile_size,
@@ -1238,7 +1238,7 @@ impl Fragment {
                     stops = linear_stops;
                     NinePatchBorderSource::Gradient(wr_gradient)
                 },
-                GradientKind::Radial(shape, center) => {
+                GradientKind::Radial(ref shape, ref center) => {
                     let (wr_gradient, radial_stops) = gradient::radial(
                         style,
                         border_image_area,
diff --git a/components/layout/display_list/gradient.rs b/components/layout/display_list/gradient.rs
index 3d7730e4fe6..e683bbb963c 100644
--- a/components/layout/display_list/gradient.rs
+++ b/components/layout/display_list/gradient.rs
@@ -91,9 +91,12 @@ fn convert_gradient_stops(
                 color,
                 position: None,
             }),
-            GradientItem::ComplexColorStop { color, position } => Some(ColorStop {
+            GradientItem::ComplexColorStop {
                 color,
-                position: Some(position),
+                ref position,
+            } => Some(ColorStop {
+                color,
+                position: Some(position.clone()),
             }),
             _ => None,
         })
@@ -122,15 +125,24 @@ fn convert_gradient_stops(
 
     // Step 2: Move any stops placed before earlier stops to the
     // same position as the preceding stop.
-    let mut last_stop_position = stop_items.first().unwrap().position.unwrap();
+    //
+    // FIXME(emilio): Once we know the offsets, it seems like converting the
+    // positions to absolute at once then process that would be cheaper.
+    let mut last_stop_position = stop_items
+        .first()
+        .unwrap()
+        .position
+        .as_ref()
+        .unwrap()
+        .clone();
     for stop in stop_items.iter_mut().skip(1) {
-        if let Some(pos) = stop.position {
-            if position_to_offset(last_stop_position, total_length) >
+        if let Some(ref pos) = stop.position {
+            if position_to_offset(&last_stop_position, total_length) >
                 position_to_offset(pos, total_length)
             {
                 stop.position = Some(last_stop_position);
             }
-            last_stop_position = stop.position.unwrap();
+            last_stop_position = stop.position.as_ref().unwrap().clone();
         }
     }
 
@@ -144,8 +156,10 @@ fn convert_gradient_stops(
                     // Initialize a new stop run.
                     // `unwrap()` here should never fail because this is the beginning of
                     // a stop run, which is always bounded by a length or percentage.
-                    let start_offset =
-                        position_to_offset(stop_items[i - 1].position.unwrap(), total_length);
+                    let start_offset = position_to_offset(
+                        stop_items[i - 1].position.as_ref().unwrap(),
+                        total_length,
+                    );
                     // `unwrap()` here should never fail because this is the end of
                     // a stop run, which is always bounded by a length or percentage.
                     let (end_index, end_stop) = stop_items[(i + 1)..]
@@ -153,7 +167,8 @@ fn convert_gradient_stops(
                         .enumerate()
                         .find(|&(_, ref stop)| stop.position.is_some())
                         .unwrap();
-                    let end_offset = position_to_offset(end_stop.position.unwrap(), total_length);
+                    let end_offset =
+                        position_to_offset(end_stop.position.as_ref().unwrap(), total_length);
                     stop_run = Some(StopRun {
                         start_offset,
                         end_offset,
@@ -168,7 +183,7 @@ fn convert_gradient_stops(
                     stop_run_length * (i - stop_run.start_index) as f32 /
                         ((2 + stop_run.stop_count) as f32)
             },
-            Some(position) => {
+            Some(ref position) => {
                 stop_run = None;
                 position_to_offset(position, total_length)
             },
@@ -212,7 +227,7 @@ where
     Size2D::new(cmp(left_side, right_side), cmp(top_side, bottom_side))
 }
 
-fn position_to_offset(position: LengthPercentage, total_length: Au) -> f32 {
+fn position_to_offset(position: &LengthPercentage, total_length: Au) -> f32 {
     if total_length == Au(0) {
         return 0.0;
     }
@@ -289,8 +304,8 @@ pub fn radial(
     style: &ComputedValues,
     size: Size2D<Au>,
     stops: &[GradientItem],
-    shape: EndingShape,
-    center: Position,
+    shape: &EndingShape,
+    center: &Position,
     repeating: bool,
 ) -> (RadialGradient, Vec<GradientStop>) {
     let center = Point2D::new(
@@ -299,15 +314,15 @@ pub fn radial(
     );
     let radius = match shape {
         EndingShape::Circle(Circle::Radius(length)) => {
-            let length = Au::from(length);
+            let length = Au::from(*length);
             Size2D::new(length, length)
         },
-        EndingShape::Circle(Circle::Extent(extent)) => circle_size_keyword(extent, &size, &center),
+        EndingShape::Circle(Circle::Extent(extent)) => circle_size_keyword(*extent, &size, &center),
         EndingShape::Ellipse(Ellipse::Radii(x, y)) => {
             Size2D::new(x.to_used_value(size.width), y.to_used_value(size.height))
         },
         EndingShape::Ellipse(Ellipse::Extent(extent)) => {
-            ellipse_size_keyword(extent, &size, &center)
+            ellipse_size_keyword(*extent, &size, &center)
         },
     };
 
diff --git a/components/layout/flex.rs b/components/layout/flex.rs
index 8d2f7b98fe1..204e87f23fc 100644
--- a/components/layout/flex.rs
+++ b/components/layout/flex.rs
@@ -43,7 +43,7 @@ enum AxisSize {
 impl AxisSize {
     /// Generate a new available cross or main axis size from the specified size of the container,
     /// containing block size, min constraint, and max constraint
-    pub fn new(size: Size, content_size: Option<Au>, min: Size, max: MaxSize) -> AxisSize {
+    pub fn new(size: &Size, content_size: Option<Au>, min: &Size, max: &MaxSize) -> AxisSize {
         match size {
             Size::Auto => AxisSize::MinMax(SizeConstraint::new(content_size, min, max, None)),
             Size::LengthPercentage(ref lp) => match lp.maybe_to_used_value(content_size) {
@@ -58,10 +58,10 @@ impl AxisSize {
 /// and the container size, then return the used value of flex basis. it can be used to help
 /// determining the flex base size and to indicate whether the main size of the item
 /// is definite after flex size resolving.
-fn from_flex_basis(flex_basis: FlexBasis, main_length: Size, containing_length: Au) -> MaybeAuto {
+fn from_flex_basis(flex_basis: &FlexBasis, main_length: &Size, containing_length: Au) -> MaybeAuto {
     let width = match flex_basis {
         FlexBasis::Content => return MaybeAuto::Auto,
-        FlexBasis::Size(width) => width,
+        FlexBasis::Size(ref width) => width,
     };
 
     let width = match width {
@@ -135,7 +135,7 @@ impl FlexItem {
             // https://drafts.csswg.org/css-flexbox-1/#min-size-auto
             Direction::Inline => {
                 let basis = from_flex_basis(
-                    block.fragment.style.get_position().flex_basis,
+                    &block.fragment.style.get_position().flex_basis,
                     block.fragment.style.content_inline_size(),
                     containing_length,
                 );
@@ -170,7 +170,7 @@ impl FlexItem {
             },
             Direction::Block => {
                 let basis = from_flex_basis(
-                    block.fragment.style.get_position().flex_basis,
+                    &block.fragment.style.get_position().flex_basis,
                     block.fragment.style.content_block_size(),
                     containing_length,
                 );
@@ -452,7 +452,7 @@ impl FlexFlow {
     fn inline_mode_bubble_inline_sizes(&mut self) {
         // FIXME(emilio): This doesn't handle at all writing-modes.
         let fixed_width =
-            !model::style_length(self.block_flow.fragment.style().get_position().width, None)
+            !model::style_length(&self.block_flow.fragment.style().get_position().width, None)
                 .is_auto();
 
         let mut computation = self.block_flow.fragment.compute_intrinsic_inline_sizes();
@@ -478,7 +478,7 @@ impl FlexFlow {
     // stripped out.
     fn block_mode_bubble_inline_sizes(&mut self) {
         let fixed_width =
-            !model::style_length(self.block_flow.fragment.style().get_position().width, None)
+            !model::style_length(&self.block_flow.fragment.style().get_position().width, None)
                 .is_auto();
 
         let mut computation = self.block_flow.fragment.compute_intrinsic_inline_sizes();
@@ -960,9 +960,9 @@ impl Flow for FlexFlow {
             let style = &self.block_flow.fragment.style;
             let (specified_block_size, specified_inline_size) = if style.writing_mode.is_vertical()
             {
-                (style.get_position().width, style.get_position().height)
+                (&style.get_position().width, &style.get_position().height)
             } else {
-                (style.get_position().height, style.get_position().width)
+                (&style.get_position().height, &style.get_position().width)
             };
 
             let available_inline_size = AxisSize::new(
diff --git a/components/layout/flow.rs b/components/layout/flow.rs
index 2d6e449766e..c2d01b7f9f9 100644
--- a/components/layout/flow.rs
+++ b/components/layout/flow.rs
@@ -64,7 +64,6 @@ use style::logical_geometry::{LogicalRect, LogicalSize, WritingMode};
 use style::properties::ComputedValues;
 use style::selector_parser::RestyleDamage;
 use style::servo::restyle_damage::ServoRestyleDamage;
-use style::values::computed::LengthPercentageOrAuto;
 use webrender_api::units::LayoutTransform;
 
 /// This marker trait indicates that a type is a struct with `#[repr(C)]` whose first field
@@ -1020,13 +1019,13 @@ impl BaseFlow {
                         flags.insert(FlowFlags::IS_ABSOLUTELY_POSITIONED);
 
                         let logical_position = style.logical_position();
-                        if logical_position.inline_start == LengthPercentageOrAuto::Auto &&
-                            logical_position.inline_end == LengthPercentageOrAuto::Auto
+                        if logical_position.inline_start.is_auto() &&
+                            logical_position.inline_end.is_auto()
                         {
                             flags.insert(FlowFlags::INLINE_POSITION_IS_STATIC);
                         }
-                        if logical_position.block_start == LengthPercentageOrAuto::Auto &&
-                            logical_position.block_end == LengthPercentageOrAuto::Auto
+                        if logical_position.block_start.is_auto() &&
+                            logical_position.block_end.is_auto()
                         {
                             flags.insert(FlowFlags::BLOCK_POSITION_IS_STATIC);
                         }
@@ -1113,13 +1112,12 @@ impl BaseFlow {
                 let logical_position = style.logical_position();
                 self.flags.set(
                     FlowFlags::INLINE_POSITION_IS_STATIC,
-                    logical_position.inline_start == LengthPercentageOrAuto::Auto &&
-                        logical_position.inline_end == LengthPercentageOrAuto::Auto,
+                    logical_position.inline_start.is_auto() &&
+                        logical_position.inline_end.is_auto(),
                 );
                 self.flags.set(
                     FlowFlags::BLOCK_POSITION_IS_STATIC,
-                    logical_position.block_start == LengthPercentageOrAuto::Auto &&
-                        logical_position.block_end == LengthPercentageOrAuto::Auto,
+                    logical_position.block_start.is_auto() && logical_position.block_end.is_auto(),
                 );
             }
         }
diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs
index f663dad744d..c0240f72071 100644
--- a/components/layout/fragment.rs
+++ b/components/layout/fragment.rs
@@ -61,10 +61,9 @@ use style::selector_parser::RestyleDamage;
 use style::servo::restyle_damage::ServoRestyleDamage;
 use style::str::char_is_whitespace;
 use style::values::computed::counters::ContentItem;
-use style::values::computed::{LengthPercentage, LengthPercentageOrAuto, Size, VerticalAlign};
+use style::values::computed::{Size, VerticalAlign};
 use style::values::generics::box_::{Perspective, VerticalAlignKeyword};
 use style::values::generics::transform;
-use style::Zero;
 use webrender_api;
 use webrender_api::units::LayoutTransform;
 
@@ -1329,13 +1328,17 @@ impl Fragment {
                 return;
             },
             _ => {
-                let margin = self.style().logical_margin();
-                self.margin.inline_start =
-                    MaybeAuto::from_style(margin.inline_start, containing_block_inline_size)
-                        .specified_or_zero();
-                self.margin.inline_end =
-                    MaybeAuto::from_style(margin.inline_end, containing_block_inline_size)
-                        .specified_or_zero();
+                let (inline_start, inline_end) = {
+                    let margin = self.style().logical_margin();
+                    (
+                        MaybeAuto::from_style(margin.inline_start, containing_block_inline_size)
+                            .specified_or_zero(),
+                        MaybeAuto::from_style(margin.inline_end, containing_block_inline_size)
+                            .specified_or_zero(),
+                    )
+                };
+                self.margin.inline_start = inline_start;
+                self.margin.inline_end = inline_end;
             },
         }
 
@@ -1384,13 +1387,17 @@ impl Fragment {
             _ => {
                 // NB: Percentages are relative to containing block inline-size (not block-size)
                 // per CSS 2.1.
-                let margin = self.style().logical_margin();
-                self.margin.block_start =
-                    MaybeAuto::from_style(margin.block_start, containing_block_inline_size)
-                        .specified_or_zero();
-                self.margin.block_end =
-                    MaybeAuto::from_style(margin.block_end, containing_block_inline_size)
-                        .specified_or_zero();
+                let (block_start, block_end) = {
+                    let margin = self.style().logical_margin();
+                    (
+                        MaybeAuto::from_style(margin.block_start, containing_block_inline_size)
+                            .specified_or_zero(),
+                        MaybeAuto::from_style(margin.block_end, containing_block_inline_size)
+                            .specified_or_zero(),
+                    )
+                };
+                self.margin.block_start = block_start;
+                self.margin.block_end = block_end;
             },
         }
     }
@@ -1458,14 +1465,14 @@ impl Fragment {
     pub fn relative_position(&self, containing_block_size: &LogicalSize<Au>) -> LogicalSize<Au> {
         fn from_style(style: &ComputedValues, container_size: &LogicalSize<Au>) -> LogicalSize<Au> {
             let offsets = style.logical_position();
-            let offset_i = if offsets.inline_start != LengthPercentageOrAuto::Auto {
+            let offset_i = if !offsets.inline_start.is_auto() {
                 MaybeAuto::from_style(offsets.inline_start, container_size.inline)
                     .specified_or_zero()
             } else {
                 -MaybeAuto::from_style(offsets.inline_end, container_size.inline)
                     .specified_or_zero()
             };
-            let offset_b = if offsets.block_start != LengthPercentageOrAuto::Auto {
+            let offset_b = if !offsets.block_start.is_auto() {
                 MaybeAuto::from_style(offsets.block_start, container_size.block).specified_or_zero()
             } else {
                 -MaybeAuto::from_style(offsets.block_end, container_size.block).specified_or_zero()
@@ -2520,13 +2527,19 @@ impl Fragment {
                         {
                             continue;
                         }
-                        if inline_context_node.style.logical_margin().inline_end !=
-                            LengthPercentageOrAuto::zero()
+                        if !inline_context_node
+                            .style
+                            .logical_margin()
+                            .inline_end
+                            .is_definitely_zero()
                         {
                             return false;
                         }
-                        if inline_context_node.style.logical_padding().inline_end !=
-                            LengthPercentage::zero()
+                        if !inline_context_node
+                            .style
+                            .logical_padding()
+                            .inline_end
+                            .is_definitely_zero()
                         {
                             return false;
                         }
@@ -2546,13 +2559,19 @@ impl Fragment {
                         {
                             continue;
                         }
-                        if inline_context_node.style.logical_margin().inline_start !=
-                            LengthPercentageOrAuto::zero()
+                        if !inline_context_node
+                            .style
+                            .logical_margin()
+                            .inline_start
+                            .is_definitely_zero()
                         {
                             return false;
                         }
-                        if inline_context_node.style.logical_padding().inline_start !=
-                            LengthPercentage::zero()
+                        if !inline_context_node
+                            .style
+                            .logical_padding()
+                            .inline_start
+                            .is_definitely_zero()
                         {
                             return false;
                         }
@@ -3193,7 +3212,7 @@ impl Fragment {
     ) -> Option<LayoutTransform> {
         match self.style().get_box().perspective {
             Perspective::Length(length) => {
-                let perspective_origin = self.style().get_box().perspective_origin;
+                let perspective_origin = &self.style().get_box().perspective_origin;
                 let perspective_origin = Point2D::new(
                     perspective_origin
                         .horizontal
diff --git a/components/layout/inline.rs b/components/layout/inline.rs
index 5ba82c1c95b..dfdb20e309b 100644
--- a/components/layout/inline.rs
+++ b/components/layout/inline.rs
@@ -1275,7 +1275,7 @@ impl InlineFlow {
             &mut line_metrics,
             &inline_metrics,
             style.get_box().display,
-            VerticalAlign::baseline(),
+            &VerticalAlign::baseline(),
             &mut largest_block_size_for_top_fragments,
             &mut largest_block_size_for_bottom_fragments,
         );
@@ -1296,7 +1296,7 @@ impl InlineFlow {
                     &mut line_metrics,
                     &inline_metrics,
                     node.style.get_box().display,
-                    node.style.get_box().vertical_align,
+                    &node.style.get_box().vertical_align,
                     &mut largest_block_size_for_top_fragments,
                     &mut largest_block_size_for_bottom_fragments,
                 );
@@ -1318,7 +1318,7 @@ impl InlineFlow {
             line_metrics: &mut LineMetrics,
             inline_metrics: &InlineMetrics,
             display_value: Display,
-            vertical_align_value: VerticalAlign,
+            vertical_align_value: &VerticalAlign,
             largest_block_size_for_top_fragments: &mut Au,
             largest_block_size_for_bottom_fragments: &mut Au,
         ) {
diff --git a/components/layout/lib.rs b/components/layout/lib.rs
index fdf3971fc3f..582a3e284d5 100644
--- a/components/layout/lib.rs
+++ b/components/layout/lib.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 #![deny(unsafe_code)]
+#![feature(matches_macro)]
 
 #[macro_use]
 extern crate bitflags;
diff --git a/components/layout/model.rs b/components/layout/model.rs
index e6be75e45a4..08f916142e9 100644
--- a/components/layout/model.rs
+++ b/components/layout/model.rs
@@ -437,7 +437,7 @@ pub enum MaybeAuto {
 
 impl MaybeAuto {
     #[inline]
-    pub fn from_style(length: LengthPercentageOrAuto, containing_length: Au) -> MaybeAuto {
+    pub fn from_style(length: &LengthPercentageOrAuto, containing_length: Au) -> MaybeAuto {
         match length {
             LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
             LengthPercentageOrAuto::LengthPercentage(ref lp) => {
@@ -498,7 +498,7 @@ impl MaybeAuto {
 /// Receive an optional container size and return used value for width or height.
 ///
 /// `style_length`: content size as given in the CSS.
-pub fn style_length(style_length: Size, container_size: Option<Au>) -> MaybeAuto {
+pub fn style_length(style_length: &Size, container_size: Option<Au>) -> MaybeAuto {
     match style_length {
         Size::Auto => MaybeAuto::Auto,
         Size::LengthPercentage(ref lp) => {
@@ -546,10 +546,10 @@ pub fn specified_margin_from_style(
     LogicalMargin::from_physical(
         writing_mode,
         SideOffsets2D::new(
-            MaybeAuto::from_style(margin_style.margin_top, Au(0)).specified_or_zero(),
-            MaybeAuto::from_style(margin_style.margin_right, Au(0)).specified_or_zero(),
-            MaybeAuto::from_style(margin_style.margin_bottom, Au(0)).specified_or_zero(),
-            MaybeAuto::from_style(margin_style.margin_left, Au(0)).specified_or_zero(),
+            MaybeAuto::from_style(&margin_style.margin_top, Au(0)).specified_or_zero(),
+            MaybeAuto::from_style(&margin_style.margin_right, Au(0)).specified_or_zero(),
+            MaybeAuto::from_style(&margin_style.margin_bottom, Au(0)).specified_or_zero(),
+            MaybeAuto::from_style(&margin_style.margin_left, Au(0)).specified_or_zero(),
         ),
     )
 }
@@ -568,8 +568,8 @@ impl SizeConstraint {
     /// Create a `SizeConstraint` for an axis.
     pub fn new(
         container_size: Option<Au>,
-        min_size: Size,
-        max_size: MaxSize,
+        min_size: &Size,
+        max_size: &MaxSize,
         border: Option<Au>,
     ) -> SizeConstraint {
         let mut min_size = match min_size {
diff --git a/components/layout/multicol.rs b/components/layout/multicol.rs
index 8890c08e189..4e1bfdf8d58 100644
--- a/components/layout/multicol.rs
+++ b/components/layout/multicol.rs
@@ -102,14 +102,14 @@ impl Flow for MulticolFlow {
         let column_width;
         {
             let style = &self.block_flow.fragment.style;
-            let column_gap = match style.get_position().column_gap {
-                NonNegativeLengthPercentageOrNormal::LengthPercentage(len) => {
-                    len.0.to_pixel_length(content_inline_size).into()
+            let column_gap = Au::from(match style.get_position().column_gap {
+                NonNegativeLengthPercentageOrNormal::LengthPercentage(ref len) => {
+                    len.0.to_pixel_length(content_inline_size)
                 },
                 NonNegativeLengthPercentageOrNormal::Normal => {
                     self.block_flow.fragment.style.get_font().font_size.size()
                 },
-            };
+            });
 
             let column_style = style.get_column();
             let mut column_count;
diff --git a/components/layout/table_colgroup.rs b/components/layout/table_colgroup.rs
index b318dd95efd..ce097083f62 100644
--- a/components/layout/table_colgroup.rs
+++ b/components/layout/table_colgroup.rs
@@ -76,7 +76,7 @@ impl Flow for TableColGroupFlow {
             // Retrieve the specified value from the appropriate CSS property.
             let inline_size = fragment.style().content_inline_size();
             for _ in 0..fragment.column_span() {
-                self.inline_sizes.push(inline_size)
+                self.inline_sizes.push(inline_size.clone())
             }
         }
     }
diff --git a/components/layout/table_row.rs b/components/layout/table_row.rs
index ffaf720467b..58fb40bde3a 100644
--- a/components/layout/table_row.rs
+++ b/components/layout/table_row.rs
@@ -403,11 +403,6 @@ impl Flow for TableRowFlow {
                 let child_row_span;
                 {
                     let child_table_cell = kid.as_mut_table_cell();
-                    child_specified_inline_size = child_table_cell
-                        .block_flow
-                        .fragment
-                        .style
-                        .content_inline_size();
                     child_column_span = child_table_cell.column_span;
                     child_row_span = child_table_cell.row_span;
 
@@ -422,6 +417,13 @@ impl Flow for TableRowFlow {
                             &mut self.preliminary_collapsed_borders,
                         )
                     }
+
+                    child_specified_inline_size = child_table_cell
+                        .block_flow
+                        .fragment
+                        .style
+                        .content_inline_size()
+                        .clone();
                 }
 
                 // Collect minimum and preferred inline-sizes of the cell for automatic table layout
diff --git a/components/layout/text.rs b/components/layout/text.rs
index 199bd7e07f2..ef9515b0726 100644
--- a/components/layout/text.rs
+++ b/components/layout/text.rs
@@ -519,7 +519,7 @@ pub fn line_height_from_style(style: &ComputedValues, metrics: &FontMetrics) ->
     let font_size = style.get_font().font_size.size();
     match style.get_inherited_text().line_height {
         LineHeight::Normal => Au::from(metrics.line_gap),
-        LineHeight::Number(l) => font_size.scale_by(l.0),
+        LineHeight::Number(l) => Au::from(font_size * l.0),
         LineHeight::Length(l) => Au::from(l),
     }
 }
diff --git a/components/layout_2020/geom.rs b/components/layout_2020/geom.rs
index 562fad5c4f6..86e6faf45a7 100644
--- a/components/layout_2020/geom.rs
+++ b/components/layout_2020/geom.rs
@@ -175,13 +175,18 @@ impl flow_relative::Vec2<MaxSize<LengthPercentage>> {
         containing_block: &ContainingBlock,
     ) -> flow_relative::Vec2<Option<Length>> {
         flow_relative::Vec2 {
-            inline: self
-                .inline
-                .to_option()
-                .map(|lp| lp.percentage_relative_to(containing_block.inline_size)),
-            block: self.block.to_option().and_then(|olp| {
-                olp.maybe_percentage_relative_to(containing_block.block_size.non_auto())
-            }),
+            inline: match self.inline {
+                MaxSize::None => None,
+                MaxSize::LengthPercentage(ref lp) => {
+                    Some(lp.percentage_relative_to(containing_block.inline_size))
+                },
+            },
+            block: match self.block {
+                MaxSize::None => None,
+                MaxSize::LengthPercentage(ref lp) => {
+                    lp.maybe_percentage_relative_to(containing_block.block_size.non_auto())
+                },
+            },
         }
     }
 }
diff --git a/components/layout_2020/positioned.rs b/components/layout_2020/positioned.rs
index c9ad2dd97c4..b10b489bc1d 100644
--- a/components/layout_2020/positioned.rs
+++ b/components/layout_2020/positioned.rs
@@ -40,7 +40,7 @@ pub(crate) struct HoistedAbsolutelyPositionedBox<'box_tree> {
     box_offsets: Vec2<AbsoluteBoxOffsets>,
 }
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Debug)]
 pub(crate) enum AbsoluteBoxOffsets {
     StaticStart {
         start: Length,
@@ -113,13 +113,13 @@ impl AbsolutelyPositionedBox {
             box_offsets: Vec2 {
                 inline: absolute_box_offsets(
                     initial_start_corner.inline,
-                    box_offsets.inline_start,
-                    box_offsets.inline_end,
+                    box_offsets.inline_start.clone(),
+                    box_offsets.inline_end.clone(),
                 ),
                 block: absolute_box_offsets(
                     initial_start_corner.block,
-                    box_offsets.block_start,
-                    box_offsets.block_end,
+                    box_offsets.block_start.clone(),
+                    box_offsets.block_end.clone(),
                 ),
             },
         }
@@ -372,20 +372,20 @@ impl<'box_tree> HoistedAbsolutelyPositionedBox<'box_tree> {
         let inline_axis = solve_axis(
             cbis,
             pb.inline_sum(),
-            computed_margin.inline_start,
-            computed_margin.inline_end,
+            computed_margin.inline_start.clone(),
+            computed_margin.inline_end.clone(),
             /* avoid_negative_margin_start */ true,
-            self.box_offsets.inline,
+            self.box_offsets.inline.clone(),
             size.inline,
         );
 
         let block_axis = solve_axis(
             cbis,
             pb.block_sum(),
-            computed_margin.block_start,
-            computed_margin.block_end,
+            computed_margin.block_start.clone(),
+            computed_margin.block_end.clone(),
             /* avoid_negative_margin_start */ false,
-            self.box_offsets.block,
+            self.box_offsets.block.clone(),
             size.block,
         );
 
diff --git a/components/layout_2020/sizing.rs b/components/layout_2020/sizing.rs
index e3c74d3733f..dc7513a7859 100644
--- a/components/layout_2020/sizing.rs
+++ b/components/layout_2020/sizing.rs
@@ -7,6 +7,7 @@
 use crate::style_ext::ComputedValuesExt;
 use style::properties::ComputedValues;
 use style::values::computed::{Length, LengthPercentage, Percentage};
+use style::values::generics::length::MaxSize;
 use style::Zero;
 
 /// Which min/max-content values should be computed during box construction
@@ -114,11 +115,10 @@ impl BoxContentSizes {
             .inline
             .percentage_relative_to(Length::zero())
             .auto_is(Length::zero);
-        let max_inline_size = style
-            .max_box_size()
-            .inline
-            .to_option()
-            .and_then(|lp| lp.as_length());
+        let max_inline_size = match style.max_box_size().inline {
+            MaxSize::None => None,
+            MaxSize::LengthPercentage(ref lp) => lp.as_length(),
+        };
         let clamp = |l: Length| l.clamp_between_extremums(min_inline_size, max_inline_size);
 
         // Percentages for 'width' are treated as 'auto'
diff --git a/components/layout_2020/style_ext.rs b/components/layout_2020/style_ext.rs
index 67d8bc78d7e..2d5af4da38e 100644
--- a/components/layout_2020/style_ext.rs
+++ b/components/layout_2020/style_ext.rs
@@ -55,9 +55,9 @@ impl ComputedValuesExt for ComputedValues {
     fn inline_size_is_length(&self) -> bool {
         let position = self.get_position();
         let size = if self.writing_mode.is_horizontal() {
-            position.width
+            &position.width
         } else {
-            position.height
+            &position.height
         };
         matches!(size, Size::LengthPercentage(lp) if lp.0.as_length().is_some())
     }
@@ -65,21 +65,21 @@ impl ComputedValuesExt for ComputedValues {
     fn inline_box_offsets_are_both_non_auto(&self) -> bool {
         let position = self.get_position();
         let (a, b) = if self.writing_mode.is_horizontal() {
-            (position.left, position.right)
+            (&position.left, &position.right)
         } else {
-            (position.top, position.bottom)
+            (&position.top, &position.bottom)
         };
-        a != LengthPercentageOrAuto::Auto && b != LengthPercentageOrAuto::Auto
+        !a.is_auto() && !b.is_auto()
     }
 
     #[inline]
     fn box_offsets(&self) -> flow_relative::Sides<LengthPercentageOrAuto> {
         let position = self.get_position();
         physical::Sides {
-            top: position.top,
-            left: position.left,
-            bottom: position.bottom,
-            right: position.right,
+            top: position.top.clone(),
+            left: position.left.clone(),
+            bottom: position.bottom.clone(),
+            right: position.right.clone(),
         }
         .to_flow_relative(self.writing_mode)
     }
@@ -88,8 +88,8 @@ impl ComputedValuesExt for ComputedValues {
     fn box_size(&self) -> flow_relative::Vec2<LengthPercentageOrAuto> {
         let position = self.get_position();
         physical::Vec2 {
-            x: size_to_length(position.width),
-            y: size_to_length(position.height),
+            x: size_to_length(position.width.clone()),
+            y: size_to_length(position.height.clone()),
         }
         .size_to_flow_relative(self.writing_mode)
     }
@@ -98,8 +98,8 @@ impl ComputedValuesExt for ComputedValues {
     fn min_box_size(&self) -> flow_relative::Vec2<LengthPercentageOrAuto> {
         let position = self.get_position();
         physical::Vec2 {
-            x: size_to_length(position.min_width),
-            y: size_to_length(position.min_height),
+            x: size_to_length(position.min_width.clone()),
+            y: size_to_length(position.min_height.clone()),
         }
         .size_to_flow_relative(self.writing_mode)
     }
@@ -112,8 +112,8 @@ impl ComputedValuesExt for ComputedValues {
         };
         let position = self.get_position();
         physical::Vec2 {
-            x: unwrap(position.max_width),
-            y: unwrap(position.max_height),
+            x: unwrap(position.max_width.clone()),
+            y: unwrap(position.max_height.clone()),
         }
         .size_to_flow_relative(self.writing_mode)
     }
@@ -122,10 +122,10 @@ impl ComputedValuesExt for ComputedValues {
     fn padding(&self) -> flow_relative::Sides<LengthPercentage> {
         let padding = self.get_padding();
         physical::Sides {
-            top: padding.padding_top.0,
-            left: padding.padding_left.0,
-            bottom: padding.padding_bottom.0,
-            right: padding.padding_right.0,
+            top: padding.padding_top.0.clone(),
+            left: padding.padding_left.0.clone(),
+            bottom: padding.padding_bottom.0.clone(),
+            right: padding.padding_right.0.clone(),
         }
         .to_flow_relative(self.writing_mode)
     }
@@ -144,10 +144,10 @@ impl ComputedValuesExt for ComputedValues {
     fn margin(&self) -> flow_relative::Sides<LengthPercentageOrAuto> {
         let margin = self.get_margin();
         physical::Sides {
-            top: margin.margin_top,
-            left: margin.margin_left,
-            bottom: margin.margin_bottom,
-            right: margin.margin_right,
+            top: margin.margin_top.clone(),
+            left: margin.margin_left.clone(),
+            bottom: margin.margin_bottom.clone(),
+            right: margin.margin_right.clone(),
         }
         .to_flow_relative(self.writing_mode)
     }
@@ -180,7 +180,9 @@ impl From<stylo::Display> for Display {
 
 fn size_to_length(size: Size) -> LengthPercentageOrAuto {
     match size {
-        Size::LengthPercentage(length) => LengthPercentageOrAuto::LengthPercentage(length.0),
+        Size::LengthPercentage(length) => {
+            LengthPercentageOrAuto::LengthPercentage(length.0.clone())
+        },
         Size::Auto => LengthPercentageOrAuto::Auto,
     }
 }
diff --git a/components/malloc_size_of/Cargo.toml b/components/malloc_size_of/Cargo.toml
index d2068a30e9b..1b4872e67f1 100644
--- a/components/malloc_size_of/Cargo.toml
+++ b/components/malloc_size_of/Cargo.toml
@@ -40,7 +40,7 @@ serde = { version = "1.0.27", optional = true }
 serde_bytes = { version = "0.11", optional = true }
 servo_arc = { path = "../servo_arc" }
 smallbitvec = "2.3.0"
-smallvec = "0.6"
+smallvec = "1.0"
 string_cache = { version = "0.8", optional = true }
 thin-slice = "0.1.0"
 time = { version = "0.1.17", optional = true }
diff --git a/components/selectors/Cargo.toml b/components/selectors/Cargo.toml
index d32e82a2336..8bf0ba716cb 100644
--- a/components/selectors/Cargo.toml
+++ b/components/selectors/Cargo.toml
@@ -23,13 +23,13 @@ bench = []
 bitflags = "1.0"
 matches = "0.1"
 cssparser = "0.27"
-derive_more = "0.13"
+derive_more = "0.99"
 log = "0.4"
 fxhash = "0.2"
 phf = "0.8"
 precomputed-hash = "0.1"
 servo_arc = { version = "0.1", path = "../servo_arc" }
-smallvec = "0.6"
+smallvec = "1.0"
 thin-slice = "0.1.0"
 to_shmem = { path = "../to_shmem" }
 to_shmem_derive = { path = "../to_shmem_derive" }
diff --git a/components/selectors/builder.rs b/components/selectors/builder.rs
index 41b83b0c40e..7a58e35d17f 100644
--- a/components/selectors/builder.rs
+++ b/components/selectors/builder.rs
@@ -17,7 +17,7 @@
 //! is non-trivial. This module encapsulates those details and presents an
 //! easy-to-use API for the parser.
 
-use crate::parser::{Combinator, Component, SelectorImpl};
+use crate::parser::{Combinator, Component, NonTSPseudoClass, SelectorImpl};
 use crate::sink::Push;
 use servo_arc::{Arc, HeaderWithLength, ThinArc};
 use smallvec::{self, SmallVec};
@@ -142,7 +142,7 @@ impl<Impl: SelectorImpl> SelectorBuilder<Impl> {
         let iter = SelectorBuilderIter {
             current_simple_selectors: current.iter(),
             rest_of_simple_selectors: rest,
-            combinators: self.combinators.drain().rev(),
+            combinators: self.combinators.drain(..).rev(),
         };
 
         Arc::into_thin(Arc::from_header_and_iter(header, iter))
@@ -152,7 +152,7 @@ impl<Impl: SelectorImpl> SelectorBuilder<Impl> {
 struct SelectorBuilderIter<'a, Impl: SelectorImpl> {
     current_simple_selectors: slice::Iter<'a, Component<Impl>>,
     rest_of_simple_selectors: &'a [Component<Impl>],
-    combinators: iter::Rev<smallvec::Drain<'a, (Combinator, usize)>>,
+    combinators: iter::Rev<smallvec::Drain<'a, [(Combinator, usize); 16]>>,
 }
 
 impl<'a, Impl: SelectorImpl> ExactSizeIterator for SelectorBuilderIter<'a, Impl> {
@@ -322,10 +322,14 @@ where
             Component::NthLastOfType(..) |
             Component::FirstOfType |
             Component::LastOfType |
-            Component::OnlyOfType |
-            Component::NonTSPseudoClass(..) => {
+            Component::OnlyOfType => {
                 specificity.class_like_selectors += 1;
             },
+            Component::NonTSPseudoClass(ref pseudo) => {
+                if !pseudo.has_zero_specificity() {
+                    specificity.class_like_selectors += 1;
+                }
+            },
             Component::ExplicitUniversalType |
             Component::ExplicitAnyNamespace |
             Component::ExplicitNoNamespace |
diff --git a/components/selectors/parser.rs b/components/selectors/parser.rs
index 507121bbf97..92a5b039b90 100644
--- a/components/selectors/parser.rs
+++ b/components/selectors/parser.rs
@@ -52,6 +52,9 @@ pub trait NonTSPseudoClass: Sized + ToCss {
     ///
     /// https://drafts.csswg.org/selectors-4/#useraction-pseudos
     fn is_user_action_state(&self) -> bool;
+
+    /// Whether this pseudo-class has zero specificity.
+    fn has_zero_specificity(&self) -> bool;
 }
 
 /// Returns a Cow::Borrowed if `s` is already ASCII lowercase, and a
@@ -2336,6 +2339,11 @@ pub mod tests {
         fn is_user_action_state(&self) -> bool {
             self.is_active_or_hover()
         }
+
+        #[inline]
+        fn has_zero_specificity(&self) -> bool {
+            false
+        }
     }
 
     impl ToCss for PseudoClass {
diff --git a/components/style/Cargo.toml b/components/style/Cargo.toml
index 47a0d4392ef..6adb71e89d7 100644
--- a/components/style/Cargo.toml
+++ b/components/style/Cargo.toml
@@ -35,7 +35,7 @@ bitflags = "1.0"
 byteorder = "1.0"
 cssparser = "0.27"
 crossbeam-channel = { version = "0.3", optional = true }
-derive_more = "0.13"
+derive_more = "0.99"
 new_debug_unreachable = "1.0"
 encoding_rs = {version = "0.8", optional = true}
 euclid = "0.20"
@@ -66,7 +66,7 @@ servo_arc = { path = "../servo_arc" }
 servo_atoms = {path = "../atoms", optional = true}
 servo_config = {path = "../config", optional = true}
 smallbitvec = "2.3.0"
-smallvec = "0.6.6"
+smallvec = "1.0"
 string_cache = { version = "0.8", optional = true }
 style_derive = {path = "../style_derive"}
 style_traits = {path = "../style_traits"}
diff --git a/components/style/bloom.rs b/components/style/bloom.rs
index a24dac42b2a..c17b31d1bee 100644
--- a/components/style/bloom.rs
+++ b/components/style/bloom.rs
@@ -216,7 +216,7 @@ impl<E: TElement> StyleBloom<E> {
             self.filter.clear();
             self.pushed_hashes.clear();
         } else {
-            for hash in self.pushed_hashes.drain() {
+            for hash in self.pushed_hashes.drain(..) {
                 self.filter.remove_hash(hash);
             }
             debug_assert!(self.filter.is_zeroed());
@@ -233,7 +233,7 @@ impl<E: TElement> StyleBloom<E> {
             element = parent;
         }
 
-        for parent in parents_to_insert.drain().rev() {
+        for parent in parents_to_insert.drain(..).rev() {
             self.push(parent);
         }
     }
@@ -374,7 +374,7 @@ impl<E: TElement> StyleBloom<E> {
 
         // Now the parents match, so insert the stack of elements we have been
         // collecting so far.
-        for parent in parents_to_insert.drain().rev() {
+        for parent in parents_to_insert.drain(..).rev() {
             self.push(parent);
         }
 
diff --git a/components/style/dom.rs b/components/style/dom.rs
index fbe35e2e49d..74067e225c8 100644
--- a/components/style/dom.rs
+++ b/components/style/dom.rs
@@ -807,6 +807,9 @@ pub trait TElement:
     /// data if it comes from Shadow DOM.
     ///
     /// Returns whether normal document author rules should apply.
+    ///
+    /// TODO(emilio): We could separate the invalidation data for elements
+    /// matching in other scopes to avoid over-invalidation.
     fn each_applicable_non_document_style_rule_data<'a, F>(&self, mut f: F) -> bool
     where
         Self: 'a,
@@ -841,11 +844,42 @@ pub trait TElement:
             // Slots can only have assigned nodes when in a shadow tree.
             let shadow = slot.containing_shadow().unwrap();
             if let Some(data) = shadow.style_data() {
-                f(data, shadow.host());
+                if data.any_slotted_rule() {
+                    f(data, shadow.host());
+                }
             }
             current = slot.assigned_slot();
         }
 
+        if target.has_part_attr() {
+            if let Some(mut inner_shadow) = target.containing_shadow() {
+                loop {
+                    let inner_shadow_host = inner_shadow.host();
+                    match inner_shadow_host.containing_shadow() {
+                        Some(shadow) => {
+                            if let Some(data) = shadow.style_data() {
+                                if data.any_part_rule() {
+                                    f(data, shadow.host())
+                                }
+                            }
+                            // TODO: Could be more granular.
+                            if !shadow.host().exports_any_part() {
+                                break;
+                            }
+                            inner_shadow = shadow;
+                        },
+                        None => {
+                            // TODO(emilio): Should probably distinguish with
+                            // MatchesDocumentRules::{No,Yes,IfPart} or
+                            // something so that we could skip some work.
+                            doc_rules_apply = true;
+                            break;
+                        },
+                    }
+                }
+            }
+        }
+
         doc_rules_apply
     }
 
diff --git a/components/style/font_metrics.rs b/components/style/font_metrics.rs
index 8e69118ade4..b521fdf76c9 100644
--- a/components/style/font_metrics.rs
+++ b/components/style/font_metrics.rs
@@ -7,17 +7,17 @@
 #![deny(missing_docs)]
 
 use crate::context::SharedStyleContext;
+use crate::values::computed::Length;
 use crate::Atom;
-use app_units::Au;
 
 /// Represents the font metrics that style needs from a font to compute the
 /// value of certain CSS units like `ex`.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct FontMetrics {
     /// The x-height of the font.
-    pub x_height: Option<Au>,
+    pub x_height: Option<Length>,
     /// The zero advance. This is usually writing mode dependent
-    pub zero_advance_measure: Option<Au>,
+    pub zero_advance_measure: Option<Length>,
 }
 
 /// Type of font metrics to retrieve.
@@ -47,7 +47,7 @@ pub trait FontMetricsProvider {
         &self,
         font_name: &Atom,
         font_family: crate::values::computed::font::GenericFontFamily,
-    ) -> Au;
+    ) -> Length;
 
     /// Construct from a shared style context
     fn create_from(context: &SharedStyleContext) -> Self
@@ -70,7 +70,7 @@ impl FontMetricsProvider for ServoMetricsProvider {
         ServoMetricsProvider
     }
 
-    fn get_size(&self, _: &Atom, _: crate::values::computed::font::GenericFontFamily) -> Au {
+    fn get_size(&self, _: &Atom, _: crate::values::computed::font::GenericFontFamily) -> Length {
         unreachable!("Dummy provider should never be used to compute font size")
     }
 }
diff --git a/components/style/gecko/media_queries.rs b/components/style/gecko/media_queries.rs
index 3463c1f95e9..3f82b832bce 100644
--- a/components/style/gecko/media_queries.rs
+++ b/components/style/gecko/media_queries.rs
@@ -11,10 +11,9 @@ use crate::gecko_bindings::structs;
 use crate::media_queries::MediaType;
 use crate::properties::ComputedValues;
 use crate::string_cache::Atom;
-use crate::values::computed::font::FontSize;
+use crate::values::specified::font::FONT_MEDIUM_PX;
 use crate::values::{CustomIdent, KeyframesName};
-use app_units::Au;
-use app_units::AU_PER_PX;
+use app_units::{Au, AU_PER_PX};
 use cssparser::RGBA;
 use euclid::default::Size2D;
 use euclid::Scale;
@@ -87,7 +86,7 @@ impl Device {
             document,
             default_values: ComputedValues::default_values(doc),
             // FIXME(bz): Seems dubious?
-            root_font_size: AtomicIsize::new(FontSize::medium().size().0 as isize),
+            root_font_size: AtomicIsize::new(Au::from_px(FONT_MEDIUM_PX as i32).0 as isize),
             body_text_color: AtomicUsize::new(prefs.mDefaultColor as usize),
             used_root_font_size: AtomicBool::new(false),
             used_viewport_size: AtomicBool::new(false),
diff --git a/components/style/gecko/non_ts_pseudo_class_list.rs b/components/style/gecko/non_ts_pseudo_class_list.rs
index f38757189d0..8d9fc3d2d85 100644
--- a/components/style/gecko/non_ts_pseudo_class_list.rs
+++ b/components/style/gecko/non_ts_pseudo_class_list.rs
@@ -48,8 +48,7 @@ macro_rules! apply_non_ts_list {
                 ("indeterminate", Indeterminate, indeterminate, IN_INDETERMINATE_STATE, _),
                 ("-moz-devtools-highlighted", MozDevtoolsHighlighted, mozDevtoolsHighlighted, IN_DEVTOOLS_HIGHLIGHTED_STATE, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),
                 ("-moz-styleeditor-transitioning", MozStyleeditorTransitioning, mozStyleeditorTransitioning, IN_STYLEEDITOR_TRANSITIONING_STATE, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),
-                ("fullscreen", Fullscreen, fullscreen, IN_FULLSCREEN_STATE, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME),
-                ("-moz-full-screen", MozFullScreen, mozFullScreen, IN_FULLSCREEN_STATE, _),
+                ("fullscreen", Fullscreen, fullscreen, IN_FULLSCREEN_STATE, _),
                 // TODO(emilio): This is inconsistently named (the capital R).
                 ("-moz-focusring", MozFocusRing, mozFocusRing, IN_FOCUSRING_STATE, _),
                 ("-moz-broken", MozBroken, mozBroken, IN_BROKEN_STATE, _),
@@ -94,6 +93,7 @@ macro_rules! apply_non_ts_list {
                 ("-moz-last-node", MozLastNode, lastNode, _, _),
                 ("-moz-only-whitespace", MozOnlyWhitespace, mozOnlyWhitespace, _, _),
                 ("-moz-native-anonymous", MozNativeAnonymous, mozNativeAnonymous, _, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),
+                ("-moz-native-anonymous-no-specificity", MozNativeAnonymousNoSpecificity, mozNativeAnonymousNoSpecificity, _, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),
                 ("-moz-use-shadow-tree-root", MozUseShadowTreeRoot, mozUseShadowTreeRoot, _, PSEUDO_CLASS_ENABLED_IN_UA_SHEETS),
                 ("-moz-is-html", MozIsHTML, mozIsHTML, _, _),
                 ("-moz-placeholder", MozPlaceholder, mozPlaceholder, _, _),
diff --git a/components/style/gecko/pseudo_element_definition.mako.rs b/components/style/gecko/pseudo_element_definition.mako.rs
index d8d80d60165..f4a6671bd39 100644
--- a/components/style/gecko/pseudo_element_definition.mako.rs
+++ b/components/style/gecko/pseudo_element_definition.mako.rs
@@ -193,18 +193,18 @@ impl PseudoElement {
             % for pseudo in SIMPLE_PSEUDOS:
             "${pseudo.value[1:]}" => {
                 return Some(${pseudo_element_variant(pseudo)})
-            }
+            },
             % endfor
             // Alias some legacy prefixed pseudos to their standardized name at parse time:
             "-moz-selection" => {
                 return Some(PseudoElement::Selection);
-            }
+            },
             "-moz-placeholder" => {
                 return Some(PseudoElement::Placeholder);
-            }
+            },
             "-moz-list-bullet" | "-moz-list-number" => {
                 return Some(PseudoElement::Marker);
-            }
+            },
             _ => {
                 if starts_with_ignore_ascii_case(name, "-moz-tree-") {
                     return PseudoElement::tree_pseudo_element(name, Box::new([]))
diff --git a/components/style/gecko/selector_parser.rs b/components/style/gecko/selector_parser.rs
index 2aad41adc9c..9f5b49c5c13 100644
--- a/components/style/gecko/selector_parser.rs
+++ b/components/style/gecko/selector_parser.rs
@@ -137,6 +137,7 @@ impl NonTSPseudoClass {
             ([$(($css:expr, $name:ident, $gecko_type:tt, $state:tt, $flags:tt),)*]) => {
                 match_ignore_ascii_case! { &name,
                     $($css => Some(NonTSPseudoClass::$name),)*
+                    "-moz-full-screen" => Some(NonTSPseudoClass::Fullscreen),
                     _ => None,
                 }
             }
@@ -169,16 +170,9 @@ impl NonTSPseudoClass {
     }
 
     /// Returns whether the pseudo-class is enabled in content sheets.
+    #[inline]
     fn is_enabled_in_content(&self) -> bool {
-        match *self {
-            // For pseudo-classes with pref, the availability in content
-            // depends on the pref.
-            NonTSPseudoClass::Fullscreen => static_prefs::pref!("full-screen-api.unprefix.enabled"),
-            // Otherwise, a pseudo-class is enabled in content when it
-            // doesn't have any enabled flag.
-            _ => !self
-                .has_any_flag(NonTSPseudoClassFlag::PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME),
-        }
+        !self.has_any_flag(NonTSPseudoClassFlag::PSEUDO_CLASS_ENABLED_IN_UA_SHEETS_AND_CHROME)
     }
 
     /// Get the state flag associated with a pseudo-class, if any.
@@ -233,6 +227,9 @@ impl NonTSPseudoClass {
                       // across all the elements involved and the latter is already
                       // checked for by our caching precondtions.
                       NonTSPseudoClass::MozIsHTML |
+                      // We prevent style sharing for NAC.
+                      NonTSPseudoClass::MozNativeAnonymous |
+                      NonTSPseudoClass::MozNativeAnonymousNoSpecificity |
                       // :-moz-placeholder is parsed but never matches.
                       NonTSPseudoClass::MozPlaceholder |
                       // :-moz-locale-dir and :-moz-window-inactive depend only on
@@ -275,6 +272,11 @@ impl ::selectors::parser::NonTSPseudoClass for NonTSPseudoClass {
             NonTSPseudoClass::Hover | NonTSPseudoClass::Active | NonTSPseudoClass::Focus
         )
     }
+
+    #[inline]
+    fn has_zero_specificity(&self) -> bool {
+        matches!(*self, NonTSPseudoClass::MozNativeAnonymousNoSpecificity)
+    }
 }
 
 /// The dummy struct we use to implement our selector parsing.
@@ -394,7 +396,7 @@ impl<'a, 'i> ::selectors::Parser<'i> for SelectorParser<'a> {
                         parser,
                     )?.into()
                 )
-            }
+            },
             _ => return Err(parser.new_custom_error(
                 SelectorParseErrorKind::UnsupportedPseudoClassOrElement(name.clone())
             ))
diff --git a/components/style/gecko/snapshot.rs b/components/style/gecko/snapshot.rs
index 02707682b4d..fa9914f6222 100644
--- a/components/style/gecko/snapshot.rs
+++ b/components/style/gecko/snapshot.rs
@@ -71,7 +71,7 @@ impl GeckoElementSnapshot {
     }
 
     /// Returns true if the snapshot recorded an attribute change which isn't a
-    /// class or id change.
+    /// class / id
     #[inline]
     pub fn other_attr_changed(&self) -> bool {
         self.mOtherAttributeChanged()
diff --git a/components/style/gecko/wrapper.rs b/components/style/gecko/wrapper.rs
index bf4da090646..e4b2d7f0be1 100644
--- a/components/style/gecko/wrapper.rs
+++ b/components/style/gecko/wrapper.rs
@@ -68,6 +68,7 @@ use crate::shared_lock::Locked;
 use crate::string_cache::{Atom, Namespace, WeakAtom, WeakNamespace};
 use crate::stylist::CascadeData;
 use crate::values::computed::font::GenericFontFamily;
+use crate::values::computed::Length;
 use crate::values::specified::length::FontBaseSize;
 use crate::CaseSensitivityExt;
 use app_units::Au;
@@ -929,7 +930,7 @@ impl FontMetricsProvider for GeckoFontMetricsProvider {
         GeckoFontMetricsProvider::new()
     }
 
-    fn get_size(&self, font_name: &Atom, font_family: GenericFontFamily) -> Au {
+    fn get_size(&self, font_name: &Atom, font_family: GenericFontFamily) -> Length {
         let mut cache = self.font_size_cache.borrow_mut();
         if let Some(sizes) = cache.iter().find(|el| el.0 == *font_name) {
             return sizes.1.size_for_generic(font_family);
@@ -950,7 +951,7 @@ impl FontMetricsProvider for GeckoFontMetricsProvider {
             None => return Default::default(),
         };
 
-        let size = base_size.resolve(context);
+        let size = Au::from(base_size.resolve(context));
         let style = context.style();
 
         let (wm, font) = match base_size {
@@ -977,9 +978,9 @@ impl FontMetricsProvider for GeckoFontMetricsProvider {
             )
         };
         FontMetrics {
-            x_height: Some(Au(gecko_metrics.mXSize)),
+            x_height: Some(Au(gecko_metrics.mXSize).into()),
             zero_advance_measure: if gecko_metrics.mChSize >= 0 {
-                Some(Au(gecko_metrics.mChSize))
+                Some(Au(gecko_metrics.mChSize).into())
             } else {
                 None
             },
@@ -988,7 +989,7 @@ impl FontMetricsProvider for GeckoFontMetricsProvider {
 }
 
 impl structs::FontSizePrefs {
-    fn size_for_generic(&self, font_family: GenericFontFamily) -> Au {
+    fn size_for_generic(&self, font_family: GenericFontFamily) -> Length {
         Au(match font_family {
             GenericFontFamily::None => self.mDefaultVariableSize,
             GenericFontFamily::Serif => self.mDefaultSerifSize,
@@ -1000,6 +1001,7 @@ impl structs::FontSizePrefs {
                 "Should never get here, since this doesn't (yet) appear on font family"
             ),
         })
+        .into()
     }
 }
 
@@ -2045,7 +2047,6 @@ impl<'le> ::selectors::Element for GeckoElement<'le> {
             NonTSPseudoClass::Disabled |
             NonTSPseudoClass::Checked |
             NonTSPseudoClass::Fullscreen |
-            NonTSPseudoClass::MozFullScreen |
             NonTSPseudoClass::Indeterminate |
             NonTSPseudoClass::PlaceholderShown |
             NonTSPseudoClass::Target |
@@ -2130,7 +2131,10 @@ impl<'le> ::selectors::Element for GeckoElement<'le> {
                 }
                 true
             },
-            NonTSPseudoClass::MozNativeAnonymous => self.is_in_native_anonymous_subtree(),
+            NonTSPseudoClass::MozNativeAnonymous |
+            NonTSPseudoClass::MozNativeAnonymousNoSpecificity => {
+                self.is_in_native_anonymous_subtree()
+            },
             NonTSPseudoClass::MozUseShadowTreeRoot => self.is_root_of_use_element_shadow_tree(),
             NonTSPseudoClass::MozTableBorderNonzero => unsafe {
                 bindings::Gecko_IsTableBorderNonzero(self.0)
diff --git a/components/style/gecko_bindings/sugar/ns_t_array.rs b/components/style/gecko_bindings/sugar/ns_t_array.rs
index 64ca9ffab78..e3d4e5b86bd 100644
--- a/components/style/gecko_bindings/sugar/ns_t_array.rs
+++ b/components/style/gecko_bindings/sugar/ns_t_array.rs
@@ -89,9 +89,11 @@ impl<T> nsTArray<T> {
     pub unsafe fn set_len(&mut self, len: u32) {
         // this can leak
         debug_assert!(len >= self.len() as u32);
+        if self.len() == len as usize {
+            return;
+        }
         self.ensure_capacity(len as usize);
-        let header = self.header_mut();
-        header.mLength = len;
+        self.header_mut().mLength = len;
     }
 
     /// Resizes an array containing only POD elements
@@ -103,6 +105,9 @@ impl<T> nsTArray<T> {
     where
         T: Copy,
     {
+        if self.len() == len as usize {
+            return;
+        }
         self.ensure_capacity(len as usize);
         let header = self.header_mut();
         header.mLength = len;
diff --git a/components/style/invalidation/element/invalidation_map.rs b/components/style/invalidation/element/invalidation_map.rs
index e0b9cf8d747..6d9f6a8602d 100644
--- a/components/style/invalidation/element/invalidation_map.rs
+++ b/components/style/invalidation/element/invalidation_map.rs
@@ -142,6 +142,19 @@ pub struct DocumentStateDependency {
     pub state: DocumentState,
 }
 
+bitflags! {
+    /// A set of flags that denote whether any invalidations have occurred
+    /// for a particular attribute selector.
+    #[derive(MallocSizeOf)]
+    #[repr(C)]
+    pub struct InvalidationMapFlags : u8 {
+        /// Whether [class] or such is used.
+        const HAS_CLASS_ATTR_SELECTOR = 1 << 0;
+        /// Whether [id] or such is used.
+        const HAS_ID_ATTR_SELECTOR = 1 << 1;
+    }
+}
+
 /// A map where we store invalidations.
 ///
 /// This is slightly different to a SelectorMap, in the sense of that the same
@@ -164,16 +177,9 @@ pub struct InvalidationMap {
     pub document_state_selectors: Vec<DocumentStateDependency>,
     /// A map of other attribute affecting selectors.
     pub other_attribute_affecting_selectors: SelectorMap<Dependency>,
-    /// Whether there are attribute rules of the form `[class~="foo"]` that may
-    /// match. In that case, we need to look at
-    /// `other_attribute_affecting_selectors` too even if only the `class` has
-    /// changed.
-    pub has_class_attribute_selectors: bool,
-    /// Whether there are attribute rules of the form `[id|="foo"]` that may
-    /// match. In that case, we need to look at
-    /// `other_attribute_affecting_selectors` too even if only the `id` has
-    /// changed.
-    pub has_id_attribute_selectors: bool,
+    /// A set of flags that contain whether various special attributes are used
+    /// in this invalidation map.
+    pub flags: InvalidationMapFlags,
 }
 
 impl InvalidationMap {
@@ -185,8 +191,7 @@ impl InvalidationMap {
             state_affecting_selectors: SelectorMap::new(),
             document_state_selectors: Vec::new(),
             other_attribute_affecting_selectors: SelectorMap::new(),
-            has_class_attribute_selectors: false,
-            has_id_attribute_selectors: false,
+            flags: InvalidationMapFlags::empty(),
         }
     }
 
@@ -210,8 +215,7 @@ impl InvalidationMap {
         self.state_affecting_selectors.clear();
         self.document_state_selectors.clear();
         self.other_attribute_affecting_selectors.clear();
-        self.has_id_attribute_selectors = false;
-        self.has_class_attribute_selectors = false;
+        self.flags = InvalidationMapFlags::empty();
     }
 
     /// Adds a selector to this `InvalidationMap`.  Returns Err(..) to
@@ -238,8 +242,7 @@ impl InvalidationMap {
                 state: ElementState::empty(),
                 document_state: &mut document_state,
                 other_attributes: false,
-                has_id_attribute_selectors: false,
-                has_class_attribute_selectors: false,
+                flags: &mut self.flags,
             };
 
             // Visit all the simple selectors in this sequence.
@@ -255,9 +258,6 @@ impl InvalidationMap {
                 index += 1; // Account for the simple selector.
             }
 
-            self.has_id_attribute_selectors |= compound_visitor.has_id_attribute_selectors;
-            self.has_class_attribute_selectors |= compound_visitor.has_class_attribute_selectors;
-
             for class in compound_visitor.classes {
                 self.class_to_selector
                     .try_entry(class, quirks_mode)?
@@ -349,11 +349,8 @@ struct CompoundSelectorDependencyCollector<'a> {
     /// [id] attribute selectors).
     other_attributes: bool,
 
-    /// Whether there were attribute selectors with the id attribute.
-    has_id_attribute_selectors: bool,
-
-    /// Whether there were attribute selectors with the class attribute.
-    has_class_attribute_selectors: bool,
+    /// The invalidation map flags, that we set when some attribute selectors are present.
+    flags: &'a mut InvalidationMapFlags,
 }
 
 impl<'a> SelectorVisitor for CompoundSelectorDependencyCollector<'a> {
@@ -398,8 +395,13 @@ impl<'a> SelectorVisitor for CompoundSelectorDependencyCollector<'a> {
         };
 
         if may_match_in_no_namespace {
-            self.has_id_attribute_selectors |= *local_name_lower == local_name!("id");
-            self.has_class_attribute_selectors |= *local_name_lower == local_name!("class");
+            if *local_name_lower == local_name!("id") {
+                self.flags
+                    .insert(InvalidationMapFlags::HAS_ID_ATTR_SELECTOR)
+            } else if *local_name_lower == local_name!("class") {
+                self.flags
+                    .insert(InvalidationMapFlags::HAS_CLASS_ATTR_SELECTOR)
+            }
         }
 
         true
diff --git a/components/style/invalidation/element/invalidator.rs b/components/style/invalidation/element/invalidator.rs
index e094be281b4..f0f55595dff 100644
--- a/components/style/invalidation/element/invalidator.rs
+++ b/components/style/invalidation/element/invalidator.rs
@@ -698,7 +698,7 @@ where
             }
         }
 
-        sibling_invalidations.extend(new_sibling_invalidations.drain());
+        sibling_invalidations.extend(new_sibling_invalidations.drain(..));
         invalidated_self
     }
 
diff --git a/components/style/invalidation/element/state_and_attributes.rs b/components/style/invalidation/element/state_and_attributes.rs
index e678413218c..628f174a3d7 100644
--- a/components/style/invalidation/element/state_and_attributes.rs
+++ b/components/style/invalidation/element/state_and_attributes.rs
@@ -42,6 +42,7 @@ where
     descendant_invalidations: &'a mut DescendantInvalidationLists<'selectors>,
     sibling_invalidations: &'a mut InvalidationVector<'selectors>,
     invalidates_self: bool,
+    attr_selector_flags: InvalidationMapFlags,
 }
 
 /// An invalidation processor for style changes due to state and attribute
@@ -155,6 +156,8 @@ where
             return false;
         }
 
+        let mut attr_selector_flags = InvalidationMapFlags::empty();
+
         // If we the visited state changed, we force a restyle here. Matching
         // doesn't depend on the actual visited state at all, so we can't look
         // at matching results to decide what to do for this case.
@@ -172,6 +175,7 @@ where
         let mut classes_removed = SmallVec::<[Atom; 8]>::new();
         let mut classes_added = SmallVec::<[Atom; 8]>::new();
         if snapshot.class_changed() {
+            attr_selector_flags.insert(InvalidationMapFlags::HAS_CLASS_ATTR_SELECTOR);
             // TODO(emilio): Do this more efficiently!
             snapshot.each_class(|c| {
                 if !element.has_class(c, CaseSensitivity::CaseSensitive) {
@@ -189,6 +193,7 @@ where
         let mut id_removed = None;
         let mut id_added = None;
         if snapshot.id_changed() {
+            attr_selector_flags.insert(InvalidationMapFlags::HAS_ID_ATTR_SELECTOR);
             let old_id = snapshot.id_attr();
             let current_id = element.id();
 
@@ -199,7 +204,10 @@ where
         }
 
         if log_enabled!(::log::Level::Debug) {
-            debug!("Collecting changes for: {:?}", element);
+            debug!(
+                "Collecting changes for: {:?}, flags {:?}",
+                element, attr_selector_flags
+            );
             if !state_changes.is_empty() {
                 debug!(" > state: {:?}", state_changes);
             }
@@ -247,6 +255,7 @@ where
                 descendant_invalidations,
                 sibling_invalidations,
                 invalidates_self: false,
+                attr_selector_flags,
             };
 
             let document_origins = if !matches_document_author_rules {
@@ -356,9 +365,8 @@ where
             }
         }
 
-        let should_examine_attribute_selector_map = self.snapshot.other_attr_changed() ||
-            (self.snapshot.class_changed() && map.has_class_attribute_selectors) ||
-            (self.snapshot.id_changed() && map.has_id_attribute_selectors);
+        let should_examine_attribute_selector_map =
+            self.snapshot.other_attr_changed() || map.flags.intersects(self.attr_selector_flags);
 
         if should_examine_attribute_selector_map {
             self.collect_dependencies_in_map(&map.other_attribute_affecting_selectors)
diff --git a/components/style/logical_geometry.rs b/components/style/logical_geometry.rs
index cb45544146b..d4d058adc61 100644
--- a/components/style/logical_geometry.rs
+++ b/components/style/logical_geometry.rs
@@ -468,7 +468,7 @@ impl<T: Zero> LogicalSize<T> {
     }
 }
 
-impl<T: Copy> LogicalSize<T> {
+impl<T> LogicalSize<T> {
     #[inline]
     pub fn new(mode: WritingMode, inline: T, block: T) -> LogicalSize<T> {
         LogicalSize {
@@ -486,7 +486,9 @@ impl<T: Copy> LogicalSize<T> {
             LogicalSize::new(mode, size.width, size.height)
         }
     }
+}
 
+impl<T: Copy> LogicalSize<T> {
     #[inline]
     pub fn width(&self, mode: WritingMode) -> T {
         self.debug_writing_mode.check(mode);
@@ -860,7 +862,7 @@ impl<T: Zero> LogicalMargin<T> {
     }
 }
 
-impl<T: Copy> LogicalMargin<T> {
+impl<T> LogicalMargin<T> {
     #[inline]
     pub fn new(
         mode: WritingMode,
@@ -879,11 +881,6 @@ impl<T: Copy> LogicalMargin<T> {
     }
 
     #[inline]
-    pub fn new_all_same(mode: WritingMode, value: T) -> LogicalMargin<T> {
-        LogicalMargin::new(mode, value, value, value, value)
-    }
-
-    #[inline]
     pub fn from_physical(mode: WritingMode, offsets: SideOffsets2D<T>) -> LogicalMargin<T> {
         let block_start;
         let inline_end;
@@ -917,6 +914,13 @@ impl<T: Copy> LogicalMargin<T> {
         }
         LogicalMargin::new(mode, block_start, inline_end, block_end, inline_start)
     }
+}
+
+impl<T: Copy> LogicalMargin<T> {
+    #[inline]
+    pub fn new_all_same(mode: WritingMode, value: T) -> LogicalMargin<T> {
+        LogicalMargin::new(mode, value, value, value, value)
+    }
 
     #[inline]
     pub fn top(&self, mode: WritingMode) -> T {
diff --git a/components/style/matching.rs b/components/style/matching.rs
index 01246ed3878..7ec94d35346 100644
--- a/components/style/matching.rs
+++ b/components/style/matching.rs
@@ -715,7 +715,7 @@ pub trait MatchMethods: TElement {
                 .map_or(true, |s| s.get_font().clone_font_size() != new_font_size)
             {
                 debug_assert!(self.owner_doc_matches_for_testing(device));
-                device.set_root_font_size(new_font_size.size());
+                device.set_root_font_size(new_font_size.size().into());
                 // If the root font-size changed since last time, and something
                 // in the document did use rem units, ensure we recascade the
                 // entire tree.
diff --git a/components/style/parallel.rs b/components/style/parallel.rs
index d4aa0af6acf..9e578e9e9e6 100644
--- a/components/style/parallel.rs
+++ b/components/style/parallel.rs
@@ -180,7 +180,7 @@ fn top_down_dom<'a, 'scope, E, D>(
                 let mut traversal_data_copy = traversal_data.clone();
                 traversal_data_copy.current_dom_depth += 1;
                 traverse_nodes(
-                    discovered_child_nodes.drain(),
+                    discovered_child_nodes.drain(..),
                     DispatchMode::NotTailCall,
                     recursion_ok,
                     root,
@@ -210,7 +210,7 @@ fn top_down_dom<'a, 'scope, E, D>(
     if !discovered_child_nodes.is_empty() {
         traversal_data.current_dom_depth += 1;
         traverse_nodes(
-            discovered_child_nodes.drain(),
+            discovered_child_nodes.drain(..),
             DispatchMode::TailCall,
             recursion_ok,
             root,
diff --git a/components/style/properties/cascade.rs b/components/style/properties/cascade.rs
index a667cba09bc..dd87916cf7d 100644
--- a/components/style/properties/cascade.rs
+++ b/components/style/properties/cascade.rs
@@ -743,6 +743,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
     fn recompute_keyword_font_size_if_needed(&mut self) {
         use crate::values::computed::ToComputedValue;
         use crate::values::specified;
+        use app_units::Au;
 
         if !self.seen.contains(LonghandId::XLang) &&
            !self.seen.contains(LonghandId::FontFamily) {
@@ -759,7 +760,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
                 None => return,
             };
 
-            if font.gecko().mScriptUnconstrainedSize == new_size.size().0 {
+            if font.gecko().mScriptUnconstrainedSize == Au::from(new_size.size()).0 {
                 return;
             }
 
diff --git a/components/style/properties/counted_unknown_properties.py b/components/style/properties/counted_unknown_properties.py
index de36199e77a..047d129a2ff 100644
--- a/components/style/properties/counted_unknown_properties.py
+++ b/components/style/properties/counted_unknown_properties.py
@@ -10,7 +10,8 @@
 #    "offset-distance",
 #    "offset-path",
 #    "offset-rotate",
-#    "offset"
+#    "offset",
+#    "text-underline-position",
 COUNTED_UNKNOWN_PROPERTIES = [
     "-webkit-font-smoothing",
     "-webkit-tap-highlight-color",
@@ -40,7 +41,6 @@ COUNTED_UNKNOWN_PROPERTIES = [
     "baseline-shift",
     "-webkit-hyphenate-character",
     "page",
-    "text-underline-position",
     "-webkit-highlight",
     "background-repeat-x",
     "-webkit-padding-end",
diff --git a/components/style/properties/data.py b/components/style/properties/data.py
index 87ec87a7fa5..15ab380789b 100644
--- a/components/style/properties/data.py
+++ b/components/style/properties/data.py
@@ -385,6 +385,7 @@ class Longhand(object):
                 "TextDecorationLine",
                 "TextEmphasisPosition",
                 "TextTransform",
+                "TextUnderlinePosition",
                 "TouchAction",
                 "TransformStyle",
                 "UserSelect",
diff --git a/components/style/properties/declaration_block.rs b/components/style/properties/declaration_block.rs
index 930d4400d3d..90dec0a47d7 100644
--- a/components/style/properties/declaration_block.rs
+++ b/components/style/properties/declaration_block.rs
@@ -1433,7 +1433,7 @@ fn report_css_errors(
     selectors: Option<&SelectorList<SelectorImpl>>,
     errors: &mut SmallParseErrorVec,
 ) {
-    for (error, slice, property) in errors.drain() {
+    for (error, slice, property) in errors.drain(..) {
         report_one_css_error(context, Some(block), selectors, error, slice, property)
     }
 }
diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index b6cd741038c..14262e7a074 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -426,7 +426,7 @@ def set_gecko_property(ffi_name, expr):
 
     pub fn copy_${ident}_from(&mut self, other: &Self) {
         use crate::gecko_bindings::structs::nsStyleSVG_${ident.upper()}_CONTEXT as CONTEXT_VALUE;
-        self.gecko.${gecko_ffi_name} = other.gecko.${gecko_ffi_name};
+        self.gecko.${gecko_ffi_name} = other.gecko.${gecko_ffi_name}.clone();
         self.gecko.mContextFlags =
             (self.gecko.mContextFlags & !CONTEXT_VALUE) |
             (other.gecko.mContextFlags & CONTEXT_VALUE);
@@ -442,7 +442,7 @@ def set_gecko_property(ffi_name, expr):
         if (self.gecko.mContextFlags & CONTEXT_VALUE) != 0 {
             return SVGLength::ContextValue;
         }
-        SVGLength::LengthPercentage(self.gecko.${gecko_ffi_name})
+        SVGLength::LengthPercentage(self.gecko.${gecko_ffi_name}.clone())
     }
 </%def>
 
@@ -563,7 +563,7 @@ def set_gecko_property(ffi_name, expr):
     #[allow(non_snake_case)]
     pub fn copy_${ident}_from(&mut self, other: &Self) {
         self.gecko.${gecko_ffi_name}.${index} =
-            other.gecko.${gecko_ffi_name}.${index};
+            other.gecko.${gecko_ffi_name}.${index}.clone();
     }
     #[allow(non_snake_case)]
     pub fn reset_${ident}(&mut self, other: &Self) {
@@ -572,7 +572,7 @@ def set_gecko_property(ffi_name, expr):
 
     #[allow(non_snake_case)]
     pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
-        self.gecko.${gecko_ffi_name}.${index}
+        self.gecko.${gecko_ffi_name}.${index}.clone()
     }
 </%def>
 
@@ -601,7 +601,7 @@ def set_gecko_property(ffi_name, expr):
     #[allow(non_snake_case)]
     pub fn copy_${ident}_from(&mut self, other: &Self) {
         self.gecko.${gecko_ffi_name}.${corner} =
-            other.gecko.${gecko_ffi_name}.${corner};
+            other.gecko.${gecko_ffi_name}.${corner}.clone();
     }
     #[allow(non_snake_case)]
     pub fn reset_${ident}(&mut self, other: &Self) {
@@ -609,7 +609,7 @@ def set_gecko_property(ffi_name, expr):
     }
     #[allow(non_snake_case)]
     pub fn clone_${ident}(&self) -> longhands::${ident}::computed_value::T {
-        self.gecko.${gecko_ffi_name}.${corner}
+        self.gecko.${gecko_ffi_name}.${corner}.clone()
     }
 </%def>
 
@@ -1134,7 +1134,7 @@ fn static_assert() {
     pub fn set_font_size(&mut self, v: FontSize) {
         use crate::values::specified::font::KeywordSize;
 
-        let size = v.size();
+        let size = Au::from(v.size());
         self.gecko.mScriptUnconstrainedSize = size.0;
 
         // These two may be changed from Cascade::fixup_font_stuff.
@@ -1852,7 +1852,7 @@ fn static_assert() {
         for (layer, other) in self.gecko.${layers_field_name}.mLayers.iter_mut()
                                   .zip(other.gecko.${layers_field_name}.mLayers.iter())
                                   .take(count as usize) {
-            layer.${field_name} = other.${field_name};
+            layer.${field_name} = other.${field_name}.clone();
         }
         self.gecko.${layers_field_name}.${field_name}Count = count;
     }
@@ -2006,7 +2006,7 @@ fn static_assert() {
         for (layer, other) in self.gecko.${image_layers_field}.mLayers.iter_mut()
                                   .zip(other.gecko.${image_layers_field}.mLayers.iter())
                                   .take(count as usize) {
-            layer.mPosition.${keyword} = other.mPosition.${keyword};
+            layer.mPosition.${keyword} = other.mPosition.${keyword}.clone();
         }
         self.gecko.${image_layers_field}.mPosition${orientation.upper()}Count = count;
     }
@@ -2020,7 +2020,7 @@ fn static_assert() {
         longhands::${shorthand}_position_${orientation}::computed_value::List(
             self.gecko.${image_layers_field}.mLayers.iter()
                 .take(self.gecko.${image_layers_field}.mPosition${orientation.upper()}Count as usize)
-                .map(|position| position.mPosition.${keyword})
+                .map(|position| position.mPosition.${keyword}.clone())
                 .collect()
         )
     }
@@ -2054,7 +2054,7 @@ fn static_assert() {
 
     pub fn clone_${shorthand}_size(&self) -> longhands::${shorthand}_size::computed_value::T {
         longhands::${shorthand}_size::computed_value::List(
-            self.gecko.${image_layers_field}.mLayers.iter().map(|layer| layer.mSize).collect()
+            self.gecko.${image_layers_field}.mLayers.iter().map(|layer| layer.mSize.clone()).collect()
         )
     }
 
diff --git a/components/style/properties/longhands/border.mako.rs b/components/style/properties/longhands/border.mako.rs
index 4d68c8bfc93..09cbea19a7f 100644
--- a/components/style/properties/longhands/border.mako.rs
+++ b/components/style/properties/longhands/border.mako.rs
@@ -108,7 +108,6 @@ ${helpers.predefined_type(
     "border-image-source",
     "ImageLayer",
     engines="gecko servo-2013 servo-2020",
-    servo_2020_pref="layout.2020.unimplemented",
     initial_value="computed::ImageLayer::none()",
     initial_specified_value="specified::ImageLayer::none()",
     spec="https://drafts.csswg.org/css-backgrounds/#the-background-image",
@@ -122,7 +121,6 @@ ${helpers.predefined_type(
     "border-image-outset",
     "NonNegativeLengthOrNumberRect",
     engines="gecko servo-2013 servo-2020",
-    servo_2020_pref="layout.2020.unimplemented",
     initial_value="generics::rect::Rect::all(computed::NonNegativeLengthOrNumber::zero())",
     initial_specified_value="generics::rect::Rect::all(specified::NonNegativeLengthOrNumber::zero())",
     spec="https://drafts.csswg.org/css-backgrounds/#border-image-outset",
@@ -135,7 +133,6 @@ ${helpers.predefined_type(
     "BorderImageRepeat",
     "computed::BorderImageRepeat::stretch()",
     engines="gecko servo-2013 servo-2020",
-    servo_2020_pref="layout.2020.unimplemented",
     initial_specified_value="specified::BorderImageRepeat::stretch()",
     animation_value_type="discrete",
     spec="https://drafts.csswg.org/css-backgrounds/#the-border-image-repeat",
@@ -145,7 +142,6 @@ ${helpers.predefined_type(
     "border-image-width",
     "BorderImageWidth",
     engines="gecko servo-2013 servo-2020",
-    servo_2020_pref="layout.2020.unimplemented",
     initial_value="computed::BorderImageWidth::all(computed::BorderImageSideWidth::one())",
     initial_specified_value="specified::BorderImageWidth::all(specified::BorderImageSideWidth::one())",
     spec="https://drafts.csswg.org/css-backgrounds/#border-image-width",
@@ -157,7 +153,6 @@ ${helpers.predefined_type(
     "border-image-slice",
     "BorderImageSlice",
     engines="gecko servo-2013 servo-2020",
-    servo_2020_pref="layout.2020.unimplemented",
     initial_value="computed::BorderImageSlice::hundred_percent()",
     initial_specified_value="specified::BorderImageSlice::hundred_percent()",
     spec="https://drafts.csswg.org/css-backgrounds/#border-image-slice",
diff --git a/components/style/properties/longhands/box.mako.rs b/components/style/properties/longhands/box.mako.rs
index aa6118b8a8a..f5f09f32e6e 100644
--- a/components/style/properties/longhands/box.mako.rs
+++ b/components/style/properties/longhands/box.mako.rs
@@ -24,7 +24,7 @@ ${helpers.single_keyword(
     "-moz-top-layer",
     "none top",
     engines="gecko",
-    gecko_constant_prefix="NS_STYLE_TOP_LAYER",
+    gecko_enum_prefix="StyleTopLayer",
     gecko_ffi_name="mTopLayer",
     animation_value_type="none",
     enabled_in="ua",
@@ -494,6 +494,7 @@ ${helpers.single_keyword(
     engines="gecko",
     spec="https://drafts.fxtf.org/compositing/#isolation",
     flags="CREATES_STACKING_CONTEXT",
+    gecko_enum_prefix="StyleIsolation",
     animation_value_type="discrete",
 )}
 
diff --git a/components/style/properties/longhands/inherited_box.mako.rs b/components/style/properties/longhands/inherited_box.mako.rs
index a92d638671b..78c2e6023ee 100644
--- a/components/style/properties/longhands/inherited_box.mako.rs
+++ b/components/style/properties/longhands/inherited_box.mako.rs
@@ -16,6 +16,7 @@ ${helpers.single_keyword(
     gecko_ffi_name="mVisible",
     animation_value_type="ComputedValue",
     spec="https://drafts.csswg.org/css-box/#propdef-visibility",
+    gecko_enum_prefix="StyleVisibility",
 )}
 
 // CSS Writing Modes Level 3
diff --git a/components/style/properties/longhands/inherited_text.mako.rs b/components/style/properties/longhands/inherited_text.mako.rs
index e7cfbba377b..9784e2529e9 100644
--- a/components/style/properties/longhands/inherited_text.mako.rs
+++ b/components/style/properties/longhands/inherited_text.mako.rs
@@ -53,7 +53,7 @@ ${helpers.single_keyword(
     "-moz-text-size-adjust",
     "auto none",
     engines="gecko",
-    gecko_constant_prefix="NS_STYLE_TEXT_SIZE_ADJUST",
+    gecko_enum_prefix="StyleTextSizeAdjust",
     gecko_ffi_name="mTextSizeAdjust",
     animation_value_type="discrete",
     spec="https://drafts.csswg.org/css-size-adjust/#adjustment-control",
@@ -332,6 +332,7 @@ ${helpers.single_keyword(
     "space-around start center space-between",
     engines="gecko",
     animation_value_type="discrete",
+    gecko_enum_prefix="StyleRubyAlign",
     spec="https://drafts.csswg.org/css-ruby/#ruby-align-property",
 )}
 
@@ -341,6 +342,7 @@ ${helpers.single_keyword(
     engines="gecko",
     animation_value_type="discrete",
     spec="https://drafts.csswg.org/css-ruby/#ruby-position-property",
+    gecko_enum_prefix="StyleRubyPosition",
 )}
 
 // CSS Writing Modes Module Level 3
@@ -389,6 +391,18 @@ ${helpers.predefined_type(
     spec="https://drafts.csswg.org/css-text-decor-4/#underline-offset",
 )}
 
+// text underline position
+${helpers.predefined_type(
+    "text-underline-position",
+    "TextUnderlinePosition",
+    "computed::TextUnderlinePosition::AUTO",
+    engines="gecko",
+    animation_value_type="discrete",
+    gecko_pref="layout.css.text-underline-position.enabled",
+    has_effect_on_gecko_scrollbars=False,
+    spec="https://drafts.csswg.org/css-text-decor-3/#text-underline-position-property",
+)}
+
 // text decoration skip ink
 ${helpers.predefined_type(
     "text-decoration-skip-ink",
diff --git a/components/style/properties/longhands/inherited_ui.mako.rs b/components/style/properties/longhands/inherited_ui.mako.rs
index a7b83f0ea99..25b53190964 100644
--- a/components/style/properties/longhands/inherited_ui.mako.rs
+++ b/components/style/properties/longhands/inherited_ui.mako.rs
@@ -26,6 +26,7 @@ ${helpers.single_keyword(
     animation_value_type="discrete",
     extra_gecko_values="visiblepainted visiblefill visiblestroke visible painted fill stroke all",
     spec="https://www.w3.org/TR/SVG11/interact.html#PointerEventsProperty",
+    gecko_enum_prefix="StylePointerEvents",
 )}
 
 ${helpers.single_keyword(
diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs
index 38243aa45e4..30a03f79290 100644
--- a/components/style/properties/properties.mako.rs
+++ b/components/style/properties/properties.mako.rs
@@ -3121,59 +3121,59 @@ impl ComputedValuesInner {
 
     /// Get the logical computed inline size.
     #[inline]
-    pub fn content_inline_size(&self) -> computed::Size {
+    pub fn content_inline_size(&self) -> &computed::Size {
         let position_style = self.get_position();
         if self.writing_mode.is_vertical() {
-            position_style.height
+            &position_style.height
         } else {
-            position_style.width
+            &position_style.width
         }
     }
 
     /// Get the logical computed block size.
     #[inline]
-    pub fn content_block_size(&self) -> computed::Size {
+    pub fn content_block_size(&self) -> &computed::Size {
         let position_style = self.get_position();
-        if self.writing_mode.is_vertical() { position_style.width } else { position_style.height }
+        if self.writing_mode.is_vertical() { &position_style.width } else { &position_style.height }
     }
 
     /// Get the logical computed min inline size.
     #[inline]
-    pub fn min_inline_size(&self) -> computed::Size {
+    pub fn min_inline_size(&self) -> &computed::Size {
         let position_style = self.get_position();
-        if self.writing_mode.is_vertical() { position_style.min_height } else { position_style.min_width }
+        if self.writing_mode.is_vertical() { &position_style.min_height } else { &position_style.min_width }
     }
 
     /// Get the logical computed min block size.
     #[inline]
-    pub fn min_block_size(&self) -> computed::Size {
+    pub fn min_block_size(&self) -> &computed::Size {
         let position_style = self.get_position();
-        if self.writing_mode.is_vertical() { position_style.min_width } else { position_style.min_height }
+        if self.writing_mode.is_vertical() { &position_style.min_width } else { &position_style.min_height }
     }
 
     /// Get the logical computed max inline size.
     #[inline]
-    pub fn max_inline_size(&self) -> computed::MaxSize {
+    pub fn max_inline_size(&self) -> &computed::MaxSize {
         let position_style = self.get_position();
-        if self.writing_mode.is_vertical() { position_style.max_height } else { position_style.max_width }
+        if self.writing_mode.is_vertical() { &position_style.max_height } else { &position_style.max_width }
     }
 
     /// Get the logical computed max block size.
     #[inline]
-    pub fn max_block_size(&self) -> computed::MaxSize {
+    pub fn max_block_size(&self) -> &computed::MaxSize {
         let position_style = self.get_position();
-        if self.writing_mode.is_vertical() { position_style.max_width } else { position_style.max_height }
+        if self.writing_mode.is_vertical() { &position_style.max_width } else { &position_style.max_height }
     }
 
     /// Get the logical computed padding for this writing mode.
     #[inline]
-    pub fn logical_padding(&self) -> LogicalMargin<computed::LengthPercentage> {
+    pub fn logical_padding(&self) -> LogicalMargin<<&computed::LengthPercentage> {
         let padding_style = self.get_padding();
         LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new(
-            padding_style.padding_top.0,
-            padding_style.padding_right.0,
-            padding_style.padding_bottom.0,
-            padding_style.padding_left.0,
+            &padding_style.padding_top.0,
+            &padding_style.padding_right.0,
+            &padding_style.padding_bottom.0,
+            &padding_style.padding_left.0,
         ))
     }
 
@@ -3197,26 +3197,26 @@ impl ComputedValuesInner {
 
     /// Gets the logical computed margin from this style.
     #[inline]
-    pub fn logical_margin(&self) -> LogicalMargin<computed::LengthPercentageOrAuto> {
+    pub fn logical_margin(&self) -> LogicalMargin<<&computed::LengthPercentageOrAuto> {
         let margin_style = self.get_margin();
         LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new(
-            margin_style.margin_top,
-            margin_style.margin_right,
-            margin_style.margin_bottom,
-            margin_style.margin_left,
+            &margin_style.margin_top,
+            &margin_style.margin_right,
+            &margin_style.margin_bottom,
+            &margin_style.margin_left,
         ))
     }
 
     /// Gets the logical position from this style.
     #[inline]
-    pub fn logical_position(&self) -> LogicalMargin<computed::LengthPercentageOrAuto> {
+    pub fn logical_position(&self) -> LogicalMargin<<&computed::LengthPercentageOrAuto> {
         // FIXME(SimonSapin): should be the writing mode of the containing block, maybe?
         let position_style = self.get_position();
         LogicalMargin::from_physical(self.writing_mode, SideOffsets2D::new(
-            position_style.top,
-            position_style.right,
-            position_style.bottom,
-            position_style.left,
+            &position_style.top,
+            &position_style.right,
+            &position_style.bottom,
+            &position_style.left,
         ))
     }
 
diff --git a/components/style/properties/shorthands/border.mako.rs b/components/style/properties/shorthands/border.mako.rs
index c1bf200fe45..d584e568aed 100644
--- a/components/style/properties/shorthands/border.mako.rs
+++ b/components/style/properties/shorthands/border.mako.rs
@@ -179,6 +179,16 @@ pub fn parse_border<'i, 't>(
 
     impl<'a> ToCss for LonghandsToSerialize<'a>  {
         fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result where W: fmt::Write {
+            use crate::properties::longhands;
+
+            // If any of the border-image longhands differ from their initial specified values we should not
+            // invoke serialize_directional_border(), so there is no point in continuing on to compute all_equal.
+            % for name in "outset repeat slice source width".split():
+                if *self.border_image_${name} != longhands::border_image_${name}::get_initial_specified_value() {
+                    return Ok(());
+                }
+            % endfor
+
             let all_equal = {
                 % for side in PHYSICAL_SIDES:
                   let border_${side}_width = self.border_${side}_width;
diff --git a/components/style/rule_collector.rs b/components/style/rule_collector.rs
index ab1fb88d7f2..9841eb9e70f 100644
--- a/components/style/rule_collector.rs
+++ b/components/style/rule_collector.rs
@@ -348,7 +348,8 @@ where
                 return;
             }
 
-            let outer_shadow = inner_shadow.host().containing_shadow();
+            let inner_shadow_host = inner_shadow.host();
+            let outer_shadow = inner_shadow_host.containing_shadow();
             let part_rules = match outer_shadow {
                 Some(shadow) => shadow
                     .style_data()
@@ -387,8 +388,6 @@ where
                 shadow_cascade_order.inc();
             }
 
-            let inner_shadow_host = inner_shadow.host();
-
             inner_shadow = match outer_shadow {
                 Some(s) => s,
                 None => break, // Nowhere to export to.
diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs
index 7cb153de375..19e3accb851 100644
--- a/components/style/rule_tree/mod.rs
+++ b/components/style/rule_tree/mod.rs
@@ -345,7 +345,7 @@ impl RuleTree {
             important_author.sort_by_key(|&(_, order)| -order);
         }
 
-        for (source, shadow_cascade_order) in important_author.drain() {
+        for (source, shadow_cascade_order) in important_author.drain(..) {
             current = current.ensure_child(
                 self.root.downgrade(),
                 source,
@@ -355,11 +355,11 @@ impl RuleTree {
             );
         }
 
-        for source in important_user.drain() {
+        for source in important_user.drain(..) {
             current = current.ensure_child(self.root.downgrade(), source, UserImportant);
         }
 
-        for source in important_ua.drain() {
+        for source in important_ua.drain(..) {
             current = current.ensure_child(self.root.downgrade(), source, UAImportant);
         }
 
@@ -378,7 +378,7 @@ impl RuleTree {
         guards: &StylesheetGuards,
     ) -> StrongRuleNode {
         self.insert_ordered_rules_with_important(
-            applicable_declarations.drain().map(|d| d.for_rule_tree()),
+            applicable_declarations.drain(..).map(|d| d.for_rule_tree()),
             guards,
         )
     }
@@ -556,7 +556,7 @@ impl RuleTree {
 
         // Now the rule is in the relevant place, push the children as
         // necessary.
-        let rule = self.insert_ordered_rules_from(current, children.drain().rev());
+        let rule = self.insert_ordered_rules_from(current, children.drain(..).rev());
         Some(rule)
     }
 
@@ -592,8 +592,8 @@ impl RuleTree {
             last = node;
         }
 
-        let rule =
-            self.insert_ordered_rules_from(last.parent().unwrap().clone(), children.drain().rev());
+        let rule = self
+            .insert_ordered_rules_from(last.parent().unwrap().clone(), children.drain(..).rev());
         rule
     }
 
diff --git a/components/style/servo/media_queries.rs b/components/style/servo/media_queries.rs
index df7bf93b8ac..4cdfc80eef7 100644
--- a/components/style/servo/media_queries.rs
+++ b/components/style/servo/media_queries.rs
@@ -10,8 +10,8 @@ use crate::media_queries::media_feature::{Evaluator, MediaFeatureDescription};
 use crate::media_queries::media_feature_expression::RangeOrOperator;
 use crate::media_queries::MediaType;
 use crate::properties::ComputedValues;
-use crate::values::computed::font::FontSize;
 use crate::values::computed::CSSPixelLength;
+use crate::values::specified::font::FONT_MEDIUM_PX;
 use crate::values::KeyframesName;
 use app_units::Au;
 use cssparser::RGBA;
@@ -68,7 +68,7 @@ impl Device {
             viewport_size,
             device_pixel_ratio,
             // FIXME(bz): Seems dubious?
-            root_font_size: AtomicIsize::new(FontSize::medium().size().0 as isize),
+            root_font_size: AtomicIsize::new(Au::from_px(FONT_MEDIUM_PX).0 as isize),
             used_root_font_size: AtomicBool::new(false),
             used_viewport_units: AtomicBool::new(false),
             environment: CssEnvironment,
diff --git a/components/style/servo/selector_parser.rs b/components/style/servo/selector_parser.rs
index 977a6c59a85..942dcdba1bb 100644
--- a/components/style/servo/selector_parser.rs
+++ b/components/style/servo/selector_parser.rs
@@ -309,6 +309,11 @@ impl ::selectors::parser::NonTSPseudoClass for NonTSPseudoClass {
             NonTSPseudoClass::Active | NonTSPseudoClass::Hover | NonTSPseudoClass::Focus
         )
     }
+
+    #[inline]
+    fn has_zero_specificity(&self) -> bool {
+        false
+    }
 }
 
 impl ToCss for NonTSPseudoClass {
diff --git a/components/style/stylesheets/mod.rs b/components/style/stylesheets/mod.rs
index b74413866f5..c9697ead615 100644
--- a/components/style/stylesheets/mod.rs
+++ b/components/style/stylesheets/mod.rs
@@ -59,6 +59,7 @@ pub use self::rules_iterator::{AllRules, EffectiveRules};
 pub use self::rules_iterator::{NestedRuleIterationCondition, RulesIterator};
 pub use self::style_rule::StyleRule;
 pub use self::stylesheet::{DocumentStyleSheet, Namespaces, Stylesheet};
+pub use self::stylesheet::{SanitizationData, SanitizationKind};
 pub use self::stylesheet::{StylesheetContents, StylesheetInDocument, UserAgentStylesheets};
 pub use self::supports_rule::SupportsRule;
 pub use self::viewport_rule::ViewportRule;
diff --git a/components/style/stylesheets/namespace_rule.rs b/components/style/stylesheets/namespace_rule.rs
index 81a92f1c300..d76703e4f81 100644
--- a/components/style/stylesheets/namespace_rule.rs
+++ b/components/style/stylesheets/namespace_rule.rs
@@ -7,8 +7,9 @@
 use crate::shared_lock::{SharedRwLockReadGuard, ToCssWithGuard};
 use crate::str::CssStringWriter;
 use crate::{Namespace, Prefix};
-use cssparser::SourceLocation;
+use cssparser::{self, SourceLocation};
 use std::fmt::{self, Write};
+use style_traits::{CssWriter, ToCss};
 
 /// A `@namespace` rule.
 #[derive(Clone, Debug, PartialEq, ToShmem)]
@@ -27,13 +28,12 @@ impl ToCssWithGuard for NamespaceRule {
     fn to_css(&self, _guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result {
         dest.write_str("@namespace ")?;
         if let Some(ref prefix) = self.prefix {
-            dest.write_str(&*prefix.to_string())?;
+            let prefix = prefix.to_string();
+            cssparser::serialize_identifier(&prefix, dest)?;
             dest.write_str(" ")?;
         }
-
-        // FIXME(emilio): Pretty sure this needs some escaping, or something?
-        dest.write_str("url(\"")?;
-        dest.write_str(&*self.url.to_string())?;
-        dest.write_str("\");")
+        dest.write_str("url(")?;
+        self.url.to_string().to_css(&mut CssWriter::new(dest))?;
+        dest.write_str(");")
     }
 }
diff --git a/components/style/stylesheets/stylesheet.rs b/components/style/stylesheets/stylesheet.rs
index f5194d7d443..068bfb6502a 100644
--- a/components/style/stylesheets/stylesheet.rs
+++ b/components/style/stylesheets/stylesheet.rs
@@ -81,6 +81,7 @@ impl StylesheetContents {
         quirks_mode: QuirksMode,
         line_number_offset: u32,
         use_counters: Option<&UseCounters>,
+        sanitization_data: Option<&mut SanitizationData>,
     ) -> Self {
         let namespaces = RwLock::new(Namespaces::default());
         let (rules, source_map_url, source_url) = Stylesheet::parse_rules(
@@ -94,6 +95,7 @@ impl StylesheetContents {
             quirks_mode,
             line_number_offset,
             use_counters,
+            sanitization_data,
         );
 
         Self {
@@ -341,6 +343,69 @@ impl StylesheetInDocument for DocumentStyleSheet {
     }
 }
 
+/// The kind of sanitization to use when parsing a stylesheet.
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum SanitizationKind {
+    /// Perform no sanitization.
+    None,
+    /// Allow only @font-face, style rules, and @namespace.
+    Standard,
+    /// Allow everything but conditional rules.
+    NoConditionalRules,
+}
+
+impl SanitizationKind {
+    fn allows(self, rule: &CssRule) -> bool {
+        debug_assert_ne!(self, SanitizationKind::None);
+        // NOTE(emilio): If this becomes more complex (not filtering just by
+        // top-level rules), we should thread all the data through nested rules
+        // and such. But this doesn't seem necessary at the moment.
+        let is_standard = matches!(self, SanitizationKind::Standard);
+        match *rule {
+            CssRule::Document(..) |
+            CssRule::Media(..) |
+            CssRule::Supports(..) |
+            CssRule::Import(..) => false,
+
+            CssRule::FontFace(..) | CssRule::Namespace(..) | CssRule::Style(..) => true,
+
+            CssRule::Keyframes(..) |
+            CssRule::Page(..) |
+            CssRule::FontFeatureValues(..) |
+            CssRule::Viewport(..) |
+            CssRule::CounterStyle(..) => !is_standard,
+        }
+    }
+}
+
+/// A struct to hold the data relevant to style sheet sanitization.
+#[derive(Debug)]
+pub struct SanitizationData {
+    kind: SanitizationKind,
+    output: String,
+}
+
+impl SanitizationData {
+    /// Create a new input for sanitization.
+    #[inline]
+    pub fn new(kind: SanitizationKind) -> Option<Self> {
+        if matches!(kind, SanitizationKind::None) {
+            return None;
+        }
+        Some(Self {
+            kind,
+            output: String::new(),
+        })
+    }
+
+    /// Take the sanitized output.
+    #[inline]
+    pub fn take(self) -> String {
+        self.output
+    }
+}
+
 impl Stylesheet {
     /// Updates an empty stylesheet from a given string of text.
     pub fn update_from_str(
@@ -365,6 +430,7 @@ impl Stylesheet {
             existing.contents.quirks_mode,
             line_number_offset,
             /* use_counters = */ None,
+            /* sanitization_data = */ None,
         );
 
         *existing.contents.url_data.write() = url_data;
@@ -391,6 +457,7 @@ impl Stylesheet {
         quirks_mode: QuirksMode,
         line_number_offset: u32,
         use_counters: Option<&UseCounters>,
+        mut sanitization_data: Option<&mut SanitizationData>,
     ) -> (Vec<CssRule>, Option<String>, Option<String>) {
         let mut rules = Vec::new();
         let mut input = ParserInput::new_with_line_number_offset(css, line_number_offset);
@@ -419,12 +486,24 @@ impl Stylesheet {
         {
             let mut iter = RuleListParser::new_for_stylesheet(&mut input, rule_parser);
 
-            while let Some(result) = iter.next() {
+            loop {
+                let rule_start = iter.input.position().byte_index();
+                let result = match iter.next() {
+                    Some(result) => result,
+                    None => break,
+                };
                 match result {
                     Ok(rule) => {
-                        // Use a fallible push here, and if it fails, just
-                        // fall out of the loop.  This will cause the page to
-                        // be shown incorrectly, but it's better than OOMing.
+                        if let Some(ref mut data) = sanitization_data {
+                            if !data.kind.allows(&rule) {
+                                continue;
+                            }
+                            let end = iter.input.position().byte_index();
+                            data.output.push_str(&css[rule_start..end]);
+                        }
+                        // Use a fallible push here, and if it fails, just fall
+                        // out of the loop.  This will cause the page to be
+                        // shown incorrectly, but it's better than OOMing.
                         if rules.try_push(rule).is_err() {
                             break;
                         }
@@ -470,6 +549,7 @@ impl Stylesheet {
             quirks_mode,
             line_number_offset,
             /* use_counters = */ None,
+            /* sanitized_output = */ None,
         );
 
         Stylesheet {
diff --git a/components/style/stylist.rs b/components/style/stylist.rs
index 83db2ec4b17..9de1ec4e71b 100644
--- a/components/style/stylist.rs
+++ b/components/style/stylist.rs
@@ -1013,7 +1013,7 @@ impl Stylist {
             );
             if !declarations.is_empty() {
                 let rule_node = self.rule_tree.insert_ordered_rules_with_important(
-                    declarations.drain().map(|a| a.for_rule_tree()),
+                    declarations.drain(..).map(|a| a.for_rule_tree()),
                     guards,
                 );
                 if rule_node != *self.rule_tree.root() {
@@ -1889,18 +1889,33 @@ impl CascadeData {
         self.host_rules.as_ref().and_then(|d| d.rules(pseudo))
     }
 
+    /// Whether there's any host rule that could match in this scope.
+    pub fn any_host_rules(&self) -> bool {
+        self.host_rules.is_some()
+    }
+
     /// Returns the slotted rule map for a given pseudo-element.
     #[inline]
     pub fn slotted_rules(&self, pseudo: Option<&PseudoElement>) -> Option<&SelectorMap<Rule>> {
         self.slotted_rules.as_ref().and_then(|d| d.rules(pseudo))
     }
 
+    /// Whether there's any ::slotted rule that could match in this scope.
+    pub fn any_slotted_rule(&self) -> bool {
+        self.slotted_rules.is_some()
+    }
+
     /// Returns the parts rule map for a given pseudo-element.
     #[inline]
     pub fn part_rules(&self, pseudo: Option<&PseudoElement>) -> Option<&PartMap> {
         self.part_rules.as_ref().and_then(|d| d.rules(pseudo))
     }
 
+    /// Whether there's any ::part rule that could match in this scope.
+    pub fn any_part_rule(&self) -> bool {
+        self.part_rules.is_some()
+    }
+
     /// Collects all the applicable media query results into `results`.
     ///
     /// This duplicates part of the logic in `add_stylesheet`, which is
diff --git a/components/style/values/animated/transform.rs b/components/style/values/animated/transform.rs
index aceb70f6766..3d93ae93f6d 100644
--- a/components/style/values/animated/transform.rs
+++ b/components/style/values/animated/transform.rs
@@ -1373,7 +1373,7 @@ impl ComputedTranslate {
                 LengthPercentage::zero(),
                 Length::zero(),
             ),
-            Translate::Translate(tx, ty, tz) => (tx, ty, tz),
+            Translate::Translate(ref tx, ref ty, ref tz) => (tx.clone(), ty.clone(), tz.clone()),
         }
     }
 }
diff --git a/components/style/values/computed/font.rs b/components/style/values/computed/font.rs
index a4fa6013277..658d3412475 100644
--- a/components/style/values/computed/font.rs
+++ b/components/style/values/computed/font.rs
@@ -21,7 +21,6 @@ use crate::values::specified::font::{
 use crate::values::specified::length::{FontBaseSize, NoCalcLength};
 use crate::values::CSSFloat;
 use crate::Atom;
-use app_units::Au;
 use byteorder::{BigEndian, ByteOrder};
 use cssparser::{serialize_identifier, CssStringWriter, Parser};
 #[cfg(feature = "gecko")]
@@ -148,15 +147,16 @@ impl FontWeight {
 
 impl FontSize {
     /// The actual computed font size.
-    pub fn size(self) -> Au {
-        self.size.into()
+    #[inline]
+    pub fn size(&self) -> Length {
+        self.size.0
     }
 
     #[inline]
     /// Get default value of font size.
     pub fn medium() -> Self {
         Self {
-            size: Au::from_px(specified::FONT_MEDIUM_PX).into(),
+            size: NonNegative(Length::new(specified::FONT_MEDIUM_PX as CSSFloat)),
             keyword_info: Some(KeywordInfo::medium()),
         }
     }
diff --git a/components/style/values/computed/length.rs b/components/style/values/computed/length.rs
index 2423d447a6a..c9248f97c95 100644
--- a/components/style/values/computed/length.rs
+++ b/components/style/values/computed/length.rs
@@ -29,7 +29,7 @@ pub use crate::values::specified::url::UrlOrNone;
 pub use crate::values::specified::{Angle, BorderStyle, Time};
 
 impl ToComputedValue for specified::NoCalcLength {
-    type ComputedValue = CSSPixelLength;
+    type ComputedValue = Length;
 
     #[inline]
     fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
@@ -75,9 +75,7 @@ impl ToComputedValue for specified::Length {
 ///
 /// https://drafts.csswg.org/css-values-4/#typedef-length-percentage
 #[allow(missing_docs)]
-#[derive(
-    Clone, Copy, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue,
-)]
+#[derive(Clone, Debug, Deserialize, MallocSizeOf, Serialize, ToAnimatedZero, ToResolvedValue)]
 #[repr(C)]
 pub struct LengthPercentage {
     length: Length,
@@ -543,14 +541,14 @@ impl ToAnimatedValue for NonNegativeLengthPercentage {
 impl From<NonNegativeLength> for NonNegativeLengthPercentage {
     #[inline]
     fn from(length: NonNegativeLength) -> Self {
-        LengthPercentage::new(length.0, None).into()
+        NonNegative(LengthPercentage::new(length.0, None))
     }
 }
 
 impl From<LengthPercentage> for NonNegativeLengthPercentage {
     #[inline]
     fn from(lp: LengthPercentage) -> Self {
-        NonNegative::<LengthPercentage>(lp)
+        NonNegative(lp)
     }
 }
 
diff --git a/components/style/values/computed/mod.rs b/components/style/values/computed/mod.rs
index 6e6f20ad0fe..f5b3440f426 100644
--- a/components/style/values/computed/mod.rs
+++ b/components/style/values/computed/mod.rs
@@ -75,6 +75,7 @@ pub use self::resolution::Resolution;
 pub use self::svg::MozContextProperties;
 pub use self::svg::{SVGLength, SVGOpacity, SVGPaint, SVGPaintKind};
 pub use self::svg::{SVGPaintOrder, SVGStrokeDashArray, SVGWidth};
+pub use self::text::TextUnderlinePosition;
 pub use self::text::{InitialLetter, LetterSpacing, LineBreak, LineHeight};
 pub use self::text::{OverflowWrap, TextOverflow, WordBreak, WordSpacing};
 pub use self::text::{TextAlign, TextEmphasisPosition, TextEmphasisStyle};
diff --git a/components/style/values/computed/text.rs b/components/style/values/computed/text.rs
index 4cccd248d1c..3f9ffb2ad0f 100644
--- a/components/style/values/computed/text.rs
+++ b/components/style/values/computed/text.rs
@@ -19,6 +19,7 @@ use std::fmt::{self, Write};
 use style_traits::{CssWriter, ToCss};
 
 pub use crate::values::specified::TextAlignKeyword as TextAlign;
+pub use crate::values::specified::TextUnderlinePosition;
 pub use crate::values::specified::{LineBreak, OverflowWrap, WordBreak};
 pub use crate::values::specified::{TextDecorationLine, TextEmphasisPosition};
 pub use crate::values::specified::{TextDecorationSkipInk, TextTransform};
diff --git a/components/style/values/generics/length.rs b/components/style/values/generics/length.rs
index b2f34058283..4183f40a942 100644
--- a/components/style/values/generics/length.rs
+++ b/components/style/values/generics/length.rs
@@ -207,15 +207,6 @@ impl<LengthPercentage> MaxSize<LengthPercentage> {
     pub fn none() -> Self {
         MaxSize::None
     }
-
-    /// Convert
-    #[cfg(not(feature = "gecko"))]
-    pub fn to_option(self) -> Option<LengthPercentage> {
-        match self {
-            Self::LengthPercentage(lp) => Some(lp),
-            Self::None => None,
-        }
-    }
 }
 
 /// A generic `<length>` | `<number>` value for the `-moz-tab-size` property.
diff --git a/components/style/values/specified/align.rs b/components/style/values/specified/align.rs
index 7c2ecda19a4..0dc1e422515 100644
--- a/components/style/values/specified/align.rs
+++ b/components/style/values/specified/align.rs
@@ -691,11 +691,11 @@ fn parse_baseline<'i, 't>(input: &mut Parser<'i, 't>) -> Result<AlignFlags, Pars
         "first" => {
             input.expect_ident_matching("baseline")?;
             Ok(AlignFlags::BASELINE)
-        }
+        },
         "last" => {
             input.expect_ident_matching("baseline")?;
             Ok(AlignFlags::LAST_BASELINE)
-        }
+        },
     }
 }
 
@@ -794,7 +794,7 @@ fn parse_legacy<'i, 't>(input: &mut Parser<'i, 't>) -> Result<AlignFlags, ParseE
                 .unwrap_or(AlignFlags::empty());
 
             return Ok(AlignFlags::LEGACY | flags)
-        }
+        },
         "left" => AlignFlags::LEFT,
         "right" => AlignFlags::RIGHT,
         "center" => AlignFlags::CENTER,
diff --git a/components/style/values/specified/box.rs b/components/style/values/specified/box.rs
index 1fea857d3e8..ad8602ac431 100644
--- a/components/style/values/specified/box.rs
+++ b/components/style/values/specified/box.rs
@@ -389,21 +389,10 @@ impl Display {
                 };
                 Display::from3(DisplayOutside::Block, inside, self.is_list_item())
             },
-            // If this pref is true, then we'll blockify "-moz-inline-box" to
-            // "-moz-box", and blockify "-moz-box" to itself. Otherwise, we
-            // blockify both to "block".
             #[cfg(feature = "gecko")]
-            DisplayOutside::XUL => {
-                if static_prefs::pref!(
-                    "layout.css.xul-box-display-values.survive-blockification.enabled"
-                ) {
-                    match self.inside() {
-                        DisplayInside::MozInlineBox | DisplayInside::MozBox => Display::MozBox,
-                        _ => Display::Block,
-                    }
-                } else {
-                    Display::Block
-                }
+            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"))]
diff --git a/components/style/values/specified/font.rs b/components/style/values/specified/font.rs
index c09d5a2c34c..05a29c94087 100644
--- a/components/style/values/specified/font.rs
+++ b/components/style/values/specified/font.rs
@@ -20,7 +20,6 @@ use crate::values::specified::{AllowQuirks, Angle, Integer, LengthPercentage};
 use crate::values::specified::{NoCalcLength, NonNegativeNumber, Number, Percentage};
 use crate::values::CustomIdent;
 use crate::Atom;
-use app_units::Au;
 use byteorder::{BigEndian, ByteOrder};
 use cssparser::{Parser, Token};
 #[cfg(feature = "gecko")]
@@ -773,18 +772,18 @@ impl ToComputedValue for KeywordSize {
     type ComputedValue = NonNegativeLength;
     #[inline]
     fn to_computed_value(&self, _: &Context) -> NonNegativeLength {
+        let medium = Length::new(FONT_MEDIUM_PX as f32);
         // https://drafts.csswg.org/css-fonts-3/#font-size-prop
-        match *self {
-            KeywordSize::XXSmall => Au::from_px(FONT_MEDIUM_PX) * 3 / 5,
-            KeywordSize::XSmall => Au::from_px(FONT_MEDIUM_PX) * 3 / 4,
-            KeywordSize::Small => Au::from_px(FONT_MEDIUM_PX) * 8 / 9,
-            KeywordSize::Medium => Au::from_px(FONT_MEDIUM_PX),
-            KeywordSize::Large => Au::from_px(FONT_MEDIUM_PX) * 6 / 5,
-            KeywordSize::XLarge => Au::from_px(FONT_MEDIUM_PX) * 3 / 2,
-            KeywordSize::XXLarge => Au::from_px(FONT_MEDIUM_PX) * 2,
-            KeywordSize::XXXLarge => Au::from_px(FONT_MEDIUM_PX) * 3,
-        }
-        .into()
+        NonNegative(match *self {
+            KeywordSize::XXSmall => medium * 3.0 / 5.0,
+            KeywordSize::XSmall => medium * 3.0 / 4.0,
+            KeywordSize::Small => medium * 8.0 / 9.0,
+            KeywordSize::Medium => medium,
+            KeywordSize::Large => medium * 6.0 / 5.0,
+            KeywordSize::XLarge => medium * 3.0 / 2.0,
+            KeywordSize::XXLarge => medium * 2.0,
+            KeywordSize::XXXLarge => medium * 3.0,
+        })
     }
 
     #[inline]
@@ -799,7 +798,6 @@ impl ToComputedValue for KeywordSize {
     #[inline]
     fn to_computed_value(&self, cx: &Context) -> NonNegativeLength {
         use crate::context::QuirksMode;
-        use crate::values::specified::length::au_to_int_px;
 
         // The tables in this function are originally from
         // nsRuleNode::CalcFontPointSize in Gecko:
@@ -850,22 +848,21 @@ impl ToComputedValue for KeywordSize {
             Atom::with(gecko_font.mLanguage.mRawPtr, |atom| {
                 cx.font_metrics_provider
                     .get_size(atom, gecko_font.mGenericID)
-                    .0
             })
         };
 
-        let base_size_px = au_to_int_px(base_size as f32);
+        let base_size_px = base_size.px().round() as i32;
         let html_size = self.html_size() as usize;
-        if base_size_px >= 9 && base_size_px <= 16 {
+        NonNegative(if base_size_px >= 9 && base_size_px <= 16 {
             let mapping = if cx.quirks_mode == QuirksMode::Quirks {
                 QUIRKS_FONT_SIZE_MAPPING
             } else {
                 FONT_SIZE_MAPPING
             };
-            Au::from_px(mapping[(base_size_px - 9) as usize][html_size]).into()
+            Length::new(mapping[(base_size_px - 9) as usize][html_size] as f32)
         } else {
-            Au(FONT_SIZE_FACTORS[html_size] * base_size / 100).into()
-        }
+            base_size * FONT_SIZE_FACTORS[html_size] as f32 / 100.0
+        })
     }
 
     #[inline]
@@ -927,7 +924,7 @@ impl FontSize {
                 // If the parent font was keyword-derived, this is too.
                 // Tack the % onto the factor
                 info = compose_keyword(pc.0);
-                base_size.resolve(context).scale_by(pc.0).into()
+                base_size.resolve(context) * pc.0
             },
             FontSize::Length(LengthPercentage::Calc(ref calc)) => {
                 let parent = context.style().get_parent_font().clone_font_size();
@@ -964,7 +961,7 @@ impl FontSize {
                 // others should reject negatives during parsing. But SMIL
                 // allows parsing negatives, and relies on us _not_ doing that
                 // clamping. That's so bonkers :(
-                CSSPixelLength::from(calc.to_used_value(base_size.resolve(context)))
+                calc.percentage_relative_to(base_size.resolve(context))
                     .clamp_to_non_negative()
             },
             FontSize::Keyword(i) => {
diff --git a/components/style/values/specified/gecko.rs b/components/style/values/specified/gecko.rs
index 131c2a1a314..4c85d1df668 100644
--- a/components/style/values/specified/gecko.rs
+++ b/components/style/values/specified/gecko.rs
@@ -5,8 +5,7 @@
 //! Specified types for legacy Gecko-only properties.
 
 use crate::parser::{Parse, ParserContext};
-use crate::values::computed::length::CSSPixelLength;
-use crate::values::computed::{self, LengthPercentage};
+use crate::values::computed::{self, Length, LengthPercentage};
 use crate::values::generics::rect::Rect;
 use cssparser::{Parser, Token};
 use std::fmt;
@@ -24,7 +23,7 @@ fn parse_pixel_or_percent<'i, 't>(
             value, ref unit, ..
         } => {
             match_ignore_ascii_case! { unit,
-                "px" => Ok(LengthPercentage::new(CSSPixelLength::new(value), None)),
+                "px" => Ok(LengthPercentage::new(Length::new(value), None)),
                 _ => Err(()),
             }
         },
diff --git a/components/style/values/specified/length.rs b/components/style/values/specified/length.rs
index ebf7746ee11..d9a51665ead 100644
--- a/components/style/values/specified/length.rs
+++ b/components/style/values/specified/length.rs
@@ -47,14 +47,6 @@ pub const AU_PER_PT: CSSFloat = AU_PER_IN / 72.;
 /// Number of app units per pica
 pub const AU_PER_PC: CSSFloat = AU_PER_PT * 12.;
 
-/// Same as Gecko's AppUnitsToIntCSSPixels
-///
-/// Converts app units to integer pixel values,
-/// rounding during the conversion
-pub fn au_to_int_px(au: f32) -> i32 {
-    (au / AU_PER_PX).round() as i32
-}
-
 /// A font relative length.
 #[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToCss, ToShmem)]
 pub enum FontRelativeLength {
@@ -87,7 +79,7 @@ pub enum FontBaseSize {
 
 impl FontBaseSize {
     /// Calculate the actual size for a given context
-    pub fn resolve(&self, context: &Context) -> Au {
+    pub fn resolve(&self, context: &Context) -> computed::Length {
         match *self {
             FontBaseSize::CurrentStyle => context.style().get_font().clone_font_size().size(),
             FontBaseSize::InheritedStyleButStripEmUnits | FontBaseSize::InheritedStyle => {
@@ -109,13 +101,13 @@ impl FontRelativeLength {
     }
 
     /// Computes the font-relative length.
-    pub fn to_computed_value(&self, context: &Context, base_size: FontBaseSize) -> CSSPixelLength {
-        use std::f32;
+    pub fn to_computed_value(
+        &self,
+        context: &Context,
+        base_size: FontBaseSize,
+    ) -> computed::Length {
         let (reference_size, length) = self.reference_font_size_and_length(context, base_size);
-        let pixel = (length * reference_size.to_f32_px())
-            .min(f32::MAX)
-            .max(f32::MIN);
-        CSSPixelLength::new(pixel)
+        reference_size * length
     }
 
     /// Return reference font size.
@@ -129,7 +121,7 @@ impl FontRelativeLength {
         &self,
         context: &Context,
         base_size: FontBaseSize,
-    ) -> (Au, CSSFloat) {
+    ) -> (computed::Length, CSSFloat) {
         fn query_font_metrics(
             context: &Context,
             base_size: FontBaseSize,
@@ -153,7 +145,7 @@ impl FontRelativeLength {
                 }
 
                 if base_size == FontBaseSize::InheritedStyleButStripEmUnits {
-                    (Au(0), length)
+                    (Zero::zero(), length)
                 } else {
                     (reference_font_size, length)
                 }
@@ -175,7 +167,7 @@ impl FontRelativeLength {
                     //     determine the x-height, a value of 0.5em must be
                     //     assumed.
                     //
-                    reference_font_size.scale_by(0.5)
+                    reference_font_size * 0.5
                 });
                 (reference_size, length)
             },
@@ -210,7 +202,7 @@ impl FontRelativeLength {
                     if wm.is_vertical() && wm.is_upright() {
                         reference_font_size
                     } else {
-                        reference_font_size.scale_by(0.5)
+                        reference_font_size * 0.5
                     }
                 });
                 (reference_size, length)
@@ -225,7 +217,7 @@ impl FontRelativeLength {
                 let reference_size = if context.is_root_element || context.in_media_query {
                     reference_font_size
                 } else {
-                    context.device().root_font_size()
+                    computed::Length::new(context.device().root_font_size().to_f32_px())
                 };
                 (reference_size, length)
             },
@@ -290,15 +282,14 @@ pub struct CharacterWidth(pub i32);
 
 impl CharacterWidth {
     /// Computes the given character width.
-    pub fn to_computed_value(&self, reference_font_size: Au) -> CSSPixelLength {
-        // This applies the *converting a character width to pixels* algorithm as specified
-        // in HTML5 § 14.5.4.
+    pub fn to_computed_value(&self, reference_font_size: computed::Length) -> computed::Length {
+        // This applies the *converting a character width to pixels* algorithm
+        // as specified in HTML5 § 14.5.4.
         //
         // TODO(pcwalton): Find these from the font.
-        let average_advance = reference_font_size.scale_by(0.5);
+        let average_advance = reference_font_size * 0.5;
         let max_advance = reference_font_size;
-        let au = average_advance.scale_by(self.0 as CSSFloat - 1.0) + max_advance;
-        au.into()
+        average_advance * (self.0 as CSSFloat - 1.0) + max_advance
     }
 }
 
diff --git a/components/style/values/specified/mod.rs b/components/style/values/specified/mod.rs
index bc7a8203dee..7f3ecfb96b3 100644
--- a/components/style/values/specified/mod.rs
+++ b/components/style/values/specified/mod.rs
@@ -80,6 +80,7 @@ pub use self::svg::MozContextProperties;
 pub use self::svg::{SVGLength, SVGOpacity, SVGPaint};
 pub use self::svg::{SVGPaintOrder, SVGStrokeDashArray, SVGWidth};
 pub use self::svg_path::SVGPathData;
+pub use self::text::TextUnderlinePosition;
 pub use self::text::{InitialLetter, LetterSpacing, LineBreak, LineHeight, TextAlign};
 pub use self::text::{OverflowWrap, TextEmphasisPosition, TextEmphasisStyle, WordBreak};
 pub use self::text::{TextAlignKeyword, TextDecorationLine, TextOverflow, WordSpacing};
diff --git a/components/style/values/specified/text.rs b/components/style/values/specified/text.rs
index cc4bcee1a55..8c50a61ef94 100644
--- a/components/style/values/specified/text.rs
+++ b/components/style/values/specified/text.rs
@@ -77,7 +77,6 @@ impl ToComputedValue for LineHeight {
 
     #[inline]
     fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
-        use crate::values::computed::Length as ComputedLength;
         use crate::values::specified::length::FontBaseSize;
         match *self {
             GenericLineHeight::Normal => GenericLineHeight::Normal,
@@ -97,16 +96,8 @@ impl ToComputedValue for LineHeight {
                     LengthPercentage::Calc(ref calc) => {
                         let computed_calc =
                             calc.to_computed_value_zoomed(context, FontBaseSize::CurrentStyle);
-                        let font_relative_length =
-                            FontRelativeLength::Em(computed_calc.percentage())
-                                .to_computed_value(context, FontBaseSize::CurrentStyle)
-                                .px();
-
-                        let absolute_length = computed_calc.unclamped_length().px();
-                        let pixel = computed_calc
-                            .clamping_mode
-                            .clamp(absolute_length + font_relative_length);
-                        ComputedLength::new(pixel)
+                        let base = context.style().get_font().clone_font_size().size();
+                        computed_calc.percentage_relative_to(base)
                     },
                 };
                 GenericLineHeight::Length(result.into())
@@ -1054,3 +1045,98 @@ impl TextDecorationLength {
         matches!(*self, GenericTextDecorationLength::Auto)
     }
 }
+
+bitflags! {
+    #[derive(MallocSizeOf, SpecifiedValueInfo, ToComputedValue, ToResolvedValue, ToShmem)]
+    #[value_info(other_values = "auto,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
+    pub struct TextUnderlinePosition: u8 {
+        /// Use automatic positioning below the alphabetic baseline.
+        const AUTO = 0;
+        /// Below the glyph box.
+        const UNDER = 1 << 0;
+        /// In vertical mode, place to the left of the text.
+        const LEFT = 1 << 1;
+        /// In vertical mode, place to the right of the text.
+        const RIGHT = 1 << 2;
+    }
+}
+
+impl Parse for TextUnderlinePosition {
+    fn parse<'i, 't>(
+        _context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+    ) -> Result<TextUnderlinePosition, ParseError<'i>> {
+        let mut result = TextUnderlinePosition::empty();
+
+        loop {
+            let location = input.current_source_location();
+            let ident = match input.next() {
+                Ok(&Token::Ident(ref ident)) => ident,
+                Ok(other) => return Err(location.new_unexpected_token_error(other.clone())),
+                Err(..) => break,
+            };
+
+            match_ignore_ascii_case! { ident,
+                "auto" if result.is_empty() => {
+                    return Ok(result);
+                },
+                "under" if !result.intersects(TextUnderlinePosition::UNDER) => {
+                    result.insert(TextUnderlinePosition::UNDER);
+                },
+                "left" if !result.intersects(TextUnderlinePosition::LEFT |
+                                             TextUnderlinePosition::RIGHT) => {
+                    result.insert(TextUnderlinePosition::LEFT);
+                },
+                "right" if !result.intersects(TextUnderlinePosition::LEFT |
+                                              TextUnderlinePosition::RIGHT) => {
+                    result.insert(TextUnderlinePosition::RIGHT);
+                },
+                _ => return Err(location.new_custom_error(
+                    SelectorParseErrorKind::UnexpectedIdent(ident.clone())
+                )),
+            }
+        }
+
+        if !result.is_empty() {
+            Ok(result)
+        } else {
+            Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
+        }
+    }
+}
+
+impl ToCss for TextUnderlinePosition {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        if self.is_empty() {
+            return dest.write_str("auto");
+        }
+
+        let mut writer = SequenceWriter::new(dest, " ");
+        let mut any = false;
+
+        macro_rules! maybe_write {
+            ($ident:ident => $str:expr) => {
+                if self.contains(TextUnderlinePosition::$ident) {
+                    any = true;
+                    writer.raw_item($str)?;
+                }
+            };
+        }
+
+        maybe_write!(UNDER => "under");
+        maybe_write!(LEFT => "left");
+        maybe_write!(RIGHT => "right");
+
+        debug_assert!(any);
+
+        Ok(())
+    }
+}
diff --git a/components/to_shmem/Cargo.toml b/components/to_shmem/Cargo.toml
index dd3614111e1..76be7671da3 100644
--- a/components/to_shmem/Cargo.toml
+++ b/components/to_shmem/Cargo.toml
@@ -17,6 +17,6 @@ gecko = []
 cssparser = "0.27"
 servo_arc = { path = "../servo_arc" }
 smallbitvec = "2.1.1"
-smallvec = "0.6.6"
+smallvec = "1.0"
 string_cache = { version = "0.8", optional = true }
 thin-slice = "0.1.0"
diff --git a/servo-tidy.toml b/servo-tidy.toml
index c35e180c260..b0d2477edad 100644
--- a/servo-tidy.toml
+++ b/servo-tidy.toml
@@ -35,6 +35,12 @@ packages = [
   # https://github.com/servo/servo/pull/23288#issuecomment-494687746
   "gl_generator",
 
+  # Just needs a WR update.
+  "derive_more",
+
+  # Lots of crates to update.
+  "smallvec",
+
   # https://github.com/servo/servo/issues/24421
   "proc-macro2",
   "quote",
diff --git a/tests/wpt/metadata/css/cssom/border-shorthand-serialization.html.ini b/tests/wpt/metadata/css/cssom/border-shorthand-serialization.html.ini
deleted file mode 100644
index 5e4163cc85d..00000000000
--- a/tests/wpt/metadata/css/cssom/border-shorthand-serialization.html.ini
+++ /dev/null
@@ -1,4 +0,0 @@
-[border-shorthand-serialization.html]
-  [Declaration with border longhands and border-image is not serialized to a border shorthand declaration.]
-    expected: FAIL
-