Rustfmt recent changes.

22 files changed, 141 insertions, 172 deletions

diff --git a/components/layout/block.rs b/components/layout/block.rs
index db60a1ed579..8c4a8a771aa 100644
--- a/components/layout/block.rs
+++ b/components/layout/block.rs
@@ -431,8 +431,11 @@ impl CandidateBSizeIterator {
             },
         };
 
-        let min_block_size =
-            fragment.style.min_block_size().maybe_to_used_value(block_container_block_size).unwrap_or(Au(0));
+        let min_block_size = fragment
+            .style
+            .min_block_size()
+            .maybe_to_used_value(block_container_block_size)
+            .unwrap_or(Au(0));
 
         // If the style includes `box-sizing: border-box`, subtract the border and padding.
         let adjustment_for_box_sizing = match fragment.style.get_position().box_sizing {
@@ -2154,7 +2157,9 @@ impl Flow for BlockFlow {
         // rather than bubbling up children inline width.
         let consult_children = match self.fragment.style().get_position().width {
             LengthPercentageOrAuto::Auto => true,
-            LengthPercentageOrAuto::LengthPercentage(ref lp) => lp.maybe_to_used_value(None).is_none(),
+            LengthPercentageOrAuto::LengthPercentage(ref lp) => {
+                lp.maybe_to_used_value(None).is_none()
+            },
         };
         self.bubble_inline_sizes_for_block(consult_children);
         self.fragment
@@ -2540,8 +2545,7 @@ 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_start == LengthPercentageOrAuto::Auto &&
             self.fragment.style().logical_position().inline_end == LengthPercentageOrAuto::Auto
         {
             self.base.position.start.i = inline_position
@@ -2553,8 +2557,7 @@ 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_start == LengthPercentageOrAuto::Auto &&
             self.fragment.style().logical_position().block_end == LengthPercentageOrAuto::Auto
         {
             self.base.position.start.b = block_position
diff --git a/components/layout/flex.rs b/components/layout/flex.rs
index 807e3595265..44055ae7d18 100644
--- a/components/layout/flex.rs
+++ b/components/layout/flex.rs
@@ -28,9 +28,7 @@ use style::logical_geometry::{Direction, LogicalSize};
 use style::properties::ComputedValues;
 use style::servo::restyle_damage::ServoRestyleDamage;
 use style::values::computed::flex::FlexBasis;
-use style::values::computed::{
-    LengthPercentage, LengthPercentageOrAuto, LengthPercentageOrNone,
-};
+use style::values::computed::{LengthPercentage, LengthPercentageOrAuto, LengthPercentageOrNone};
 use style::values::generics::flex::FlexBasis as GenericFlexBasis;
 
 /// The size of an axis. May be a specified size, a min/max
@@ -54,13 +52,13 @@ impl AxisSize {
         match size {
             LengthPercentageOrAuto::Auto => {
                 AxisSize::MinMax(SizeConstraint::new(content_size, min, max, None))
-            }
+            },
             LengthPercentageOrAuto::LengthPercentage(ref lp) => {
                 match lp.maybe_to_used_value(content_size) {
                     Some(length) => AxisSize::Definite(length),
                     None => AxisSize::Infinite,
                 }
-            }
+            },
         }
     }
 }
@@ -459,10 +457,9 @@ impl FlexFlow {
     // stripped out, and max replaced with union_nonbreaking_inline.
     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,
-        ).is_auto();
+        let fixed_width =
+            !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();
         if !fixed_width {
@@ -486,10 +483,9 @@ impl FlexFlow {
     // Currently, this is the core of BlockFlow::bubble_inline_sizes() with all float logic
     // 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,
-        ).is_auto();
+        let fixed_width =
+            !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();
         if !fixed_width {
diff --git a/components/layout/floats.rs b/components/layout/floats.rs
index 32aaccc9834..5a58e27f9d1 100644
--- a/components/layout/floats.rs
+++ b/components/layout/floats.rs
@@ -547,13 +547,12 @@ impl SpeculatedFloatPlacement {
                 // nonzero value (in this case, 1px) so that the layout
                 // traversal logic will know that objects later in the document
                 // might flow around this float.
-                let inline_size =
-                    flow.as_block().fragment.style.content_inline_size();
+                let inline_size = flow.as_block().fragment.style.content_inline_size();
                 let fixed = match inline_size {
                     LengthPercentageOrAuto::Auto => false,
                     LengthPercentageOrAuto::LengthPercentage(ref lp) => {
                         lp.is_definitely_zero() || lp.maybe_to_used_value(None).is_some()
-                    }
+                    },
                 };
                 if !fixed {
                     float_inline_size = Au::from_px(1)
diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs
index 40f3c3f41b2..db4fd8f4625 100644
--- a/components/layout/fragment.rs
+++ b/components/layout/fragment.rs
@@ -1614,7 +1614,7 @@ impl Fragment {
                     LengthPercentageOrAuto::Auto => None,
                     LengthPercentageOrAuto::LengthPercentage(ref lp) => {
                         lp.maybe_to_used_value(None)
-                    }
+                    },
                 };
 
                 let mut inline_size = inline_size.unwrap_or_else(|| {
@@ -1622,8 +1622,7 @@ impl Fragment {
                     // the size constraints work properly.
                     // TODO(stshine): Find a cleaner way to do this.
                     let padding = self.style.logical_padding();
-                    self.border_padding.inline_start =
-                        padding.inline_start.to_used_value(Au(0));
+                    self.border_padding.inline_start = padding.inline_start.to_used_value(Au(0));
                     self.border_padding.inline_end = padding.inline_end.to_used_value(Au(0));
                     self.border_padding.block_start = padding.block_start.to_used_value(Au(0));
                     self.border_padding.block_end = padding.block_end.to_used_value(Au(0));
diff --git a/components/layout/model.rs b/components/layout/model.rs
index 3c7441d9282..0650c8887a1 100644
--- a/components/layout/model.rs
+++ b/components/layout/model.rs
@@ -481,7 +481,6 @@ impl MaybeAuto {
         }
     }
 
-
     #[inline]
     pub fn map<F>(&self, mapper: F) -> MaybeAuto
     where
@@ -497,15 +496,12 @@ 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: LengthPercentageOrAuto,
-    container_size: Option<Au>,
-) -> MaybeAuto {
+pub fn style_length(style_length: LengthPercentageOrAuto, container_size: Option<Au>) -> MaybeAuto {
     match style_length {
         LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
         LengthPercentageOrAuto::LengthPercentage(ref lp) => {
             MaybeAuto::from_option(lp.maybe_to_used_value(container_size))
-        }
+        },
     }
 }
 
@@ -574,8 +570,9 @@ impl SizeConstraint {
         max_size: LengthPercentageOrNone,
         border: Option<Au>,
     ) -> SizeConstraint {
-        let mut min_size =
-            min_size.maybe_to_used_value(container_size).unwrap_or(Au(0));
+        let mut min_size = min_size
+            .maybe_to_used_value(container_size)
+            .unwrap_or(Au(0));
 
         let mut max_size = match max_size {
             LengthPercentageOrNone::None => None,
diff --git a/components/layout/multicol.rs b/components/layout/multicol.rs
index 3f80055e9aa..14ea36626f9 100644
--- a/components/layout/multicol.rs
+++ b/components/layout/multicol.rs
@@ -158,15 +158,13 @@ impl Flow for MulticolFlow {
                     LengthPercentageOrAuto::Auto => None,
                     LengthPercentageOrAuto::LengthPercentage(ref lp) => {
                         lp.maybe_to_used_value(None)
-                    }
+                    },
                 };
-                let size = size.or_else(|| {
-                    match style.max_block_size() {
-                        LengthPercentageOrNone::None => None,
-                        LengthPercentageOrNone::LengthPercentage(ref lp) => {
-                            lp.maybe_to_used_value(None)
-                        }
-                    }
+                let size = size.or_else(|| match style.max_block_size() {
+                    LengthPercentageOrNone::None => None,
+                    LengthPercentageOrNone::LengthPercentage(ref lp) => {
+                        lp.maybe_to_used_value(None)
+                    },
                 });
 
                 size.unwrap_or_else(|| {
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index df00142a67d..d461cd11527 100644
--- a/components/script/dom/element.rs
+++ b/components/script/dom/element.rs
@@ -719,7 +719,7 @@ impl LayoutElementHelpers for LayoutDom<Element> {
             hints.push(from_declaration(
                 shared_lock,
                 PropertyDeclaration::Width(specified::LengthPercentageOrAuto::LengthPercentage(
-                    specified::LengthPercentage::Length(value)
+                    specified::LengthPercentage::Length(value),
                 )),
             ));
         }
@@ -746,9 +746,7 @@ impl LayoutElementHelpers for LayoutDom<Element> {
             LengthOrPercentageOrAuto::Auto => {},
             LengthOrPercentageOrAuto::Percentage(percentage) => {
                 let width_value = specified::LengthPercentageOrAuto::LengthPercentage(
-                    specified::LengthPercentage::Percentage(
-                        computed::Percentage(percentage),
-                    ),
+                    specified::LengthPercentage::Percentage(computed::Percentage(percentage)),
                 );
                 hints.push(from_declaration(
                     shared_lock,
@@ -756,14 +754,11 @@ impl LayoutElementHelpers for LayoutDom<Element> {
                 ));
             },
             LengthOrPercentageOrAuto::Length(length) => {
-                let width_value =
-                    specified::LengthPercentageOrAuto::LengthPercentage(
-                        specified::LengthPercentage::Length(
-                            specified::NoCalcLength::Absolute(
-                                specified::AbsoluteLength::Px(length.to_f32_px()),
-                            ),
-                        ),
-                    );
+                let width_value = specified::LengthPercentageOrAuto::LengthPercentage(
+                    specified::LengthPercentage::Length(specified::NoCalcLength::Absolute(
+                        specified::AbsoluteLength::Px(length.to_f32_px()),
+                    )),
+                );
                 hints.push(from_declaration(
                     shared_lock,
                     PropertyDeclaration::Width(width_value),
@@ -785,9 +780,7 @@ impl LayoutElementHelpers for LayoutDom<Element> {
             LengthOrPercentageOrAuto::Auto => {},
             LengthOrPercentageOrAuto::Percentage(percentage) => {
                 let height_value = specified::LengthPercentageOrAuto::LengthPercentage(
-                    specified::LengthPercentage::Percentage(
-                        computed::Percentage(percentage),
-                    )
+                    specified::LengthPercentage::Percentage(computed::Percentage(percentage)),
                 );
                 hints.push(from_declaration(
                     shared_lock,
@@ -795,14 +788,11 @@ impl LayoutElementHelpers for LayoutDom<Element> {
                 ));
             },
             LengthOrPercentageOrAuto::Length(length) => {
-                let height_value =
-                    specified::LengthPercentageOrAuto::LengthPercentage(
-                        specified::LengthPercentage::Length(
-                            specified::NoCalcLength::Absolute(
-                                specified::AbsoluteLength::Px(length.to_f32_px()),
-                            )
-                        )
-                    );
+                let height_value = specified::LengthPercentageOrAuto::LengthPercentage(
+                    specified::LengthPercentage::Length(specified::NoCalcLength::Absolute(
+                        specified::AbsoluteLength::Px(length.to_f32_px()),
+                    )),
+                );
                 hints.push(from_declaration(
                     shared_lock,
                     PropertyDeclaration::Height(height_value),
@@ -830,7 +820,7 @@ impl LayoutElementHelpers for LayoutDom<Element> {
             hints.push(from_declaration(
                 shared_lock,
                 PropertyDeclaration::Width(specified::LengthPercentageOrAuto::LengthPercentage(
-                    specified::LengthPercentage::Length(value)
+                    specified::LengthPercentage::Length(value),
                 )),
             ));
         }
@@ -854,7 +844,7 @@ impl LayoutElementHelpers for LayoutDom<Element> {
             hints.push(from_declaration(
                 shared_lock,
                 PropertyDeclaration::Height(specified::LengthPercentageOrAuto::LengthPercentage(
-                    specified::LengthPercentage::Length(value)
+                    specified::LengthPercentage::Length(value),
                 )),
             ));
         }
diff --git a/components/style/gecko/conversions.rs b/components/style/gecko/conversions.rs
index 7e896b37569..89cce99beb0 100644
--- a/components/style/gecko/conversions.rs
+++ b/components/style/gecko/conversions.rs
@@ -80,8 +80,8 @@ impl From<nsStyleCoord_CalcValue> for LengthPercentageOrAuto {
 // disappear as we move more stuff to cbindgen.
 impl From<nsStyleCoord_CalcValue> for NonNegativeLengthPercentageOrAuto {
     fn from(other: nsStyleCoord_CalcValue) -> Self {
-        NonNegative(
-            LengthPercentageOrAuto::LengthPercentage(LengthPercentage::with_clamping_mode(
+        NonNegative(LengthPercentageOrAuto::LengthPercentage(
+            LengthPercentage::with_clamping_mode(
                 Au(other.mLength).into(),
                 if other.mHasPercent {
                     Some(Percentage(other.mPercent))
@@ -90,8 +90,8 @@ impl From<nsStyleCoord_CalcValue> for NonNegativeLengthPercentageOrAuto {
                 },
                 AllowedNumericType::NonNegative,
                 /* was_calc = */ true,
-            ))
-        )
+            ),
+        ))
     }
 }
 
@@ -529,17 +529,15 @@ impl nsStyleImage {
                     structs::NS_STYLE_GRADIENT_SHAPE_ELLIPTICAL => {
                         let length_percentage_keyword = match gecko_gradient.mSize as u32 {
                             structs::NS_STYLE_GRADIENT_SIZE_EXPLICIT_SIZE => match (
-                                LengthPercentage::from_gecko_style_coord(
-                                    &gecko_gradient.mRadiusX,
-                                ),
-                                LengthPercentage::from_gecko_style_coord(
-                                    &gecko_gradient.mRadiusY,
-                                ),
+                                LengthPercentage::from_gecko_style_coord(&gecko_gradient.mRadiusX),
+                                LengthPercentage::from_gecko_style_coord(&gecko_gradient.mRadiusY),
                             ) {
                                 (Some(x), Some(y)) => Ellipse::Radii(x, y),
                                 _ => {
-                                    debug_assert!(false,
-                                                      "mRadiusX, mRadiusY could not convert to LengthPercentage");
+                                    debug_assert!(
+                                        false,
+                                        "mRadiusX, mRadiusY could not convert to LengthPercentage"
+                                    );
                                     Ellipse::Radii(
                                         LengthPercentage::zero(),
                                         LengthPercentage::zero(),
@@ -802,10 +800,9 @@ pub mod basic_shape {
                         ),
                     ),
                     NonNegative(
-                        LengthPercentage::from_gecko_style_coord(&other.data_at(index + 1))
-                            .expect(
-                                "<border-radius> should be a length, percentage, or calc value",
-                            ),
+                        LengthPercentage::from_gecko_style_coord(&other.data_at(index + 1)).expect(
+                            "<border-radius> should be a length, percentage, or calc value",
+                        ),
                     ),
                 )
             };
diff --git a/components/style/gecko/values.rs b/components/style/gecko/values.rs
index 4937b019b5c..2288db104a4 100644
--- a/components/style/gecko/values.rs
+++ b/components/style/gecko/values.rs
@@ -149,7 +149,7 @@ impl GeckoStyleCoordConvertible for NumberOrPercentage {
 impl GeckoStyleCoordConvertible for LengthPercentage {
     fn to_gecko_style_coord<T: CoordDataMut>(&self, coord: &mut T) {
         if self.was_calc {
-            return coord.set_value(CoordDataValue::Calc((*self).into()))
+            return coord.set_value(CoordDataValue::Calc((*self).into()));
         }
         debug_assert!(self.percentage.is_none() || self.unclamped_length() == Length::zero());
         if let Some(p) = self.percentage {
@@ -161,7 +161,9 @@ impl GeckoStyleCoordConvertible for LengthPercentage {
     fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
         match coord.as_value() {
             CoordDataValue::Coord(coord) => Some(LengthPercentage::new(Au(coord).into(), None)),
-            CoordDataValue::Percent(p) => Some(LengthPercentage::new(Au(0).into(), Some(Percentage(p)))),
+            CoordDataValue::Percent(p) => {
+                Some(LengthPercentage::new(Au(0).into(), Some(Percentage(p))))
+            },
             CoordDataValue::Calc(calc) => Some(calc.into()),
             _ => None,
         }
@@ -192,7 +194,8 @@ impl GeckoStyleCoordConvertible for LengthPercentageOrAuto {
     fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
         match coord.as_value() {
             CoordDataValue::Auto => Some(LengthPercentageOrAuto::Auto),
-            _ => LengthPercentage::from_gecko_style_coord(coord).map(LengthPercentageOrAuto::LengthPercentage),
+            _ => LengthPercentage::from_gecko_style_coord(coord)
+                .map(LengthPercentageOrAuto::LengthPercentage),
         }
     }
 }
@@ -208,7 +211,8 @@ impl GeckoStyleCoordConvertible for LengthPercentageOrNone {
     fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
         match coord.as_value() {
             CoordDataValue::None => Some(LengthPercentageOrNone::None),
-            _ => LengthPercentage::from_gecko_style_coord(coord).map(LengthPercentageOrNone::LengthPercentage),
+            _ => LengthPercentage::from_gecko_style_coord(coord)
+                .map(LengthPercentageOrNone::LengthPercentage),
         }
     }
 }
diff --git a/components/style/gecko_bindings/sugar/ns_css_value.rs b/components/style/gecko_bindings/sugar/ns_css_value.rs
index b8cc1f9c5c4..73657af3e35 100644
--- a/components/style/gecko_bindings/sugar/ns_css_value.rs
+++ b/components/style/gecko_bindings/sugar/ns_css_value.rs
@@ -70,7 +70,7 @@ impl nsCSSValue {
     /// Sets LengthPercentage value to this nsCSSValue.
     pub unsafe fn set_length_percentage(&mut self, lp: LengthPercentage) {
         if lp.was_calc {
-            return bindings::Gecko_CSSValue_SetCalc(self, lp.into())
+            return bindings::Gecko_CSSValue_SetCalc(self, lp.into());
         }
         debug_assert!(lp.percentage.is_none() || lp.unclamped_length() == Length::zero());
         if let Some(p) = lp.percentage {
@@ -93,17 +93,12 @@ impl nsCSSValue {
     pub unsafe fn get_length_percentage(&self) -> LengthPercentage {
         match self.mUnit {
             nsCSSUnit::eCSSUnit_Pixel => {
-                LengthPercentage::new(
-                    Length::new(bindings::Gecko_CSSValue_GetNumber(self)),
-                    None,
-                )
+                LengthPercentage::new(Length::new(bindings::Gecko_CSSValue_GetNumber(self)), None)
             },
             nsCSSUnit::eCSSUnit_Percent => LengthPercentage::new_percent(Percentage(
                 bindings::Gecko_CSSValue_GetPercentage(self),
             )),
-            nsCSSUnit::eCSSUnit_Calc => {
-                bindings::Gecko_CSSValue_GetCalc(self).into()
-            },
+            nsCSSUnit::eCSSUnit_Calc => bindings::Gecko_CSSValue_GetCalc(self).into(),
             _ => panic!("Unexpected unit"),
         }
     }
diff --git a/components/style/stylesheets/viewport_rule.rs b/components/style/stylesheets/viewport_rule.rs
index ce63ffbfc47..862399e065c 100644
--- a/components/style/stylesheets/viewport_rule.rs
+++ b/components/style/stylesheets/viewport_rule.rs
@@ -18,7 +18,9 @@ use crate::shared_lock::{SharedRwLockReadGuard, StylesheetGuards, ToCssWithGuard
 use crate::str::CssStringWriter;
 use crate::stylesheets::{Origin, StylesheetInDocument};
 use crate::values::computed::{Context, ToComputedValue};
-use crate::values::specified::{self, LengthPercentageOrAuto, NoCalcLength, ViewportPercentageLength};
+use crate::values::specified::{
+    self, LengthPercentageOrAuto, NoCalcLength, ViewportPercentageLength,
+};
 use app_units::Au;
 use cssparser::CowRcStr;
 use cssparser::{parse_important, AtRuleParser, DeclarationListParser, DeclarationParser, Parser};
@@ -158,7 +160,7 @@ impl FromMeta for ViewportLength {
         macro_rules! specified {
             ($value:expr) => {
                 ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(
-                    specified::LengthPercentage::Length($value)
+                    specified::LengthPercentage::Length($value),
                 ))
             };
         }
@@ -755,9 +757,10 @@ impl MaybeNew for ViewportConstraints {
                     match *$value {
                         ViewportLength::Specified(ref length) => match *length {
                             LengthPercentageOrAuto::Auto => None,
-                            LengthPercentageOrAuto::LengthPercentage(ref lop) => Some(lop
-                                .to_computed_value(&context)
-                                .to_used_value(initial_viewport.$dimension)),
+                            LengthPercentageOrAuto::LengthPercentage(ref lop) => Some(
+                                lop.to_computed_value(&context)
+                                    .to_used_value(initial_viewport.$dimension),
+                            ),
                         },
                         ViewportLength::ExtendToZoom => {
                             // $extend_to will be 'None' if 'extend-to-zoom' is 'auto'
diff --git a/components/style/values/animated/length.rs b/components/style/values/animated/length.rs
index 18360fad46b..672c4117b00 100644
--- a/components/style/values/animated/length.rs
+++ b/components/style/values/animated/length.rs
@@ -27,7 +27,9 @@ impl Animate for LengthPercentage {
             .unclamped_length()
             .animate(&other.unclamped_length(), procedure)?;
         let percentage = animate_percentage_half(self.percentage, other.percentage)?;
-        let is_calc = self.was_calc || other.was_calc || self.percentage.is_some() != other.percentage.is_some();
+        let is_calc = self.was_calc ||
+            other.was_calc ||
+            self.percentage.is_some() != other.percentage.is_some();
         Ok(Self::with_clamping_mode(
             length,
             percentage,
diff --git a/components/style/values/animated/svg.rs b/components/style/values/animated/svg.rs
index 4f181981d91..af627bba784 100644
--- a/components/style/values/animated/svg.rs
+++ b/components/style/values/animated/svg.rs
@@ -32,16 +32,14 @@ fn to_number_or_percentage(
     value: &SvgLengthPercentageOrNumber<LengthPercentage, Number>,
 ) -> Result<NumberOrPercentage, ()> {
     Ok(match *value {
-        SvgLengthPercentageOrNumber::LengthPercentage(ref l) => {
-            match l.percentage {
-                Some(p) => {
-                    if l.unclamped_length().px() != 0. {
-                        return Err(());
-                    }
-                    NumberOrPercentage::Percentage(p)
+        SvgLengthPercentageOrNumber::LengthPercentage(ref l) => match l.percentage {
+            Some(p) => {
+                if l.unclamped_length().px() != 0. {
+                    return Err(());
                 }
-                None => NumberOrPercentage::Number(l.length().px())
-            }
+                NumberOrPercentage::Percentage(p)
+            },
+            None => NumberOrPercentage::Number(l.length().px()),
         },
         SvgLengthPercentageOrNumber::Number(ref n) => NumberOrPercentage::Number(*n),
     })
diff --git a/components/style/values/computed/basic_shape.rs b/components/style/values/computed/basic_shape.rs
index 9b4be538854..28067fb0c81 100644
--- a/components/style/values/computed/basic_shape.rs
+++ b/components/style/values/computed/basic_shape.rs
@@ -34,8 +34,7 @@ pub type BasicShape = generic::BasicShape<
 pub type InsetRect = generic::InsetRect<LengthPercentage, NonNegativeLengthPercentage>;
 
 /// A computed circle.
-pub type Circle =
-    generic::Circle<LengthPercentage, LengthPercentage, NonNegativeLengthPercentage>;
+pub type Circle = generic::Circle<LengthPercentage, LengthPercentage, NonNegativeLengthPercentage>;
 
 /// A computed ellipse.
 pub type Ellipse =
diff --git a/components/style/values/computed/image.rs b/components/style/values/computed/image.rs
index 749c2e44e3a..a77da59dda3 100644
--- a/components/style/values/computed/image.rs
+++ b/components/style/values/computed/image.rs
@@ -71,10 +71,16 @@ impl generic::LineDirection for LineDirection {
             LineDirection::Vertical(Y::Top) if compat_mode != CompatMode::Modern => true,
             LineDirection::Corner(..) => false,
             #[cfg(feature = "gecko")]
-            LineDirection::MozPosition(Some(Position { ref vertical, ref horizontal }), None) => {
+            LineDirection::MozPosition(
+                Some(Position {
+                    ref vertical,
+                    ref horizontal,
+                }),
+                None,
+            ) => {
                 // `50% 0%` is the default value for line direction.
                 horizontal.as_percentage().map_or(false, |p| p.0 == 0.5) &&
-                vertical.as_percentage().map_or(false, |p| p.0 == 0.0)
+                    vertical.as_percentage().map_or(false, |p| p.0 == 0.0)
             },
             _ => false,
         }
diff --git a/components/style/values/computed/length.rs b/components/style/values/computed/length.rs
index 65f19d117ae..daf14ea19e3 100644
--- a/components/style/values/computed/length.rs
+++ b/components/style/values/computed/length.rs
@@ -5,7 +5,7 @@
 //! `<length>` computed values, and related ones.
 
 use super::{Context, Number, Percentage, ToComputedValue};
-use crate::values::animated::{ToAnimatedValue};
+use crate::values::animated::ToAnimatedValue;
 use crate::values::distance::{ComputeSquaredDistance, SquaredDistance};
 use crate::values::generics::length::MaxLength as GenericMaxLength;
 use crate::values::generics::length::MozLength as GenericMozLength;
@@ -170,7 +170,6 @@ impl LengthPercentage {
         self.length
     }
 
-
     /// Return the percentage value as CSSFloat.
     #[inline]
     pub fn percentage(&self) -> CSSFloat {
@@ -380,7 +379,7 @@ impl LengthPercentage {
                 self.percentage,
                 AllowedNumericType::NonNegative,
                 self.was_calc,
-            )
+            );
         }
 
         debug_assert!(self.percentage.is_none() || self.unclamped_length() == Length::zero());
@@ -410,32 +409,25 @@ impl ToComputedValue for specified::LengthPercentage {
             specified::LengthPercentage::Length(ref value) => {
                 LengthPercentage::new(value.to_computed_value(context), None)
             },
-            specified::LengthPercentage::Percentage(value) => {
-                LengthPercentage::new_percent(value)
-            },
-            specified::LengthPercentage::Calc(ref calc) => {
-                (**calc).to_computed_value(context)
-            },
+            specified::LengthPercentage::Percentage(value) => LengthPercentage::new_percent(value),
+            specified::LengthPercentage::Calc(ref calc) => (**calc).to_computed_value(context),
         }
     }
 
     fn from_computed_value(computed: &LengthPercentage) -> Self {
         let length = computed.unclamped_length();
         if let Some(p) = computed.as_percentage() {
-            return specified::LengthPercentage::Percentage(p)
+            return specified::LengthPercentage::Percentage(p);
         }
 
         let percentage = computed.percentage;
-        if percentage.is_none() &&
-            computed.clamping_mode.clamp(length.px()) == length.px() {
-            return specified::LengthPercentage::Length(
-                ToComputedValue::from_computed_value(&length)
-            )
+        if percentage.is_none() && computed.clamping_mode.clamp(length.px()) == length.px() {
+            return specified::LengthPercentage::Length(ToComputedValue::from_computed_value(
+                &length,
+            ));
         }
 
-        specified::LengthPercentage::Calc(Box::new(
-            ToComputedValue::from_computed_value(computed),
-        ))
+        specified::LengthPercentage::Calc(Box::new(ToComputedValue::from_computed_value(computed)))
     }
 }
 
@@ -448,7 +440,9 @@ impl IsZeroLength for LengthPercentage {
 
 #[allow(missing_docs)]
 #[css(derive_debug)]
-#[derive(Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss)]
+#[derive(
+    Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss,
+)]
 pub enum LengthPercentageOrAuto {
     LengthPercentage(LengthPercentage),
     Auto,
@@ -522,9 +516,7 @@ impl ToComputedValue for specified::LengthPercentageOrAuto {
     fn to_computed_value(&self, context: &Context) -> LengthPercentageOrAuto {
         match *self {
             specified::LengthPercentageOrAuto::LengthPercentage(ref value) => {
-                LengthPercentageOrAuto::LengthPercentage(
-                    value.to_computed_value(context),
-                )
+                LengthPercentageOrAuto::LengthPercentage(value.to_computed_value(context))
             },
             specified::LengthPercentageOrAuto::Auto => LengthPercentageOrAuto::Auto,
         }
@@ -545,7 +537,9 @@ impl ToComputedValue for specified::LengthPercentageOrAuto {
 
 #[allow(missing_docs)]
 #[css(derive_debug)]
-#[derive(Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss)]
+#[derive(
+    Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss,
+)]
 pub enum LengthPercentageOrNone {
     LengthPercentage(LengthPercentage),
     None,
diff --git a/components/style/values/generics/transform.rs b/components/style/values/generics/transform.rs
index 87f26efa0d9..4591f3addd2 100644
--- a/components/style/values/generics/transform.rs
+++ b/components/style/values/generics/transform.rs
@@ -191,8 +191,7 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthPercentage> {
     #[allow(missing_docs)]
     #[css(comma, function = "interpolatematrix")]
     InterpolateMatrix {
-        from_list:
-            Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
+        from_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
         to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
         progress: computed::Percentage,
     },
@@ -200,8 +199,7 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthPercentage> {
     #[allow(missing_docs)]
     #[css(comma, function = "accumulatematrix")]
     AccumulateMatrix {
-        from_list:
-            Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
+        from_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
         to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
         count: Integer,
     },
diff --git a/components/style/values/specified/box.rs b/components/style/values/specified/box.rs
index 62d1ba50333..30111170bc0 100644
--- a/components/style/values/specified/box.rs
+++ b/components/style/values/specified/box.rs
@@ -278,8 +278,7 @@ impl Parse for VerticalAlign {
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        if let Ok(lp) =
-            input.try(|i| LengthPercentage::parse_quirky(context, i, AllowQuirks::Yes))
+        if let Ok(lp) = input.try(|i| LengthPercentage::parse_quirky(context, i, AllowQuirks::Yes))
         {
             return Ok(GenericVerticalAlign::Length(lp));
         }
diff --git a/components/style/values/specified/grid.rs b/components/style/values/specified/grid.rs
index 55a977baf8c..b3e18e66e8e 100644
--- a/components/style/values/specified/grid.rs
+++ b/components/style/values/specified/grid.rs
@@ -73,8 +73,7 @@ impl Parse for TrackSize<LengthPercentage> {
         }
 
         input.expect_function_matching("fit-content")?;
-        let lp =
-            input.parse_nested_block(|i| LengthPercentage::parse_non_negative(context, i))?;
+        let lp = input.parse_nested_block(|i| LengthPercentage::parse_non_negative(context, i))?;
         Ok(TrackSize::FitContent(lp))
     }
 }
diff --git a/components/style/values/specified/image.rs b/components/style/values/specified/image.rs
index 42b090686ca..2dc56f8ad3f 100644
--- a/components/style/values/specified/image.rs
+++ b/components/style/values/specified/image.rs
@@ -698,16 +698,16 @@ impl generic::LineDirection for LineDirection {
                 // These percentage values can also be keywords.
                 let x = match *x {
                     OriginComponent::Center => true,
-                    OriginComponent::Length(LengthPercentage::Percentage(
-                        ComputedPercentage(val),
-                    )) => val == 0.5,
+                    OriginComponent::Length(LengthPercentage::Percentage(ComputedPercentage(
+                        val,
+                    ))) => val == 0.5,
                     _ => false,
                 };
                 let y = match *y {
                     OriginComponent::Side(Y::Top) => true,
-                    OriginComponent::Length(LengthPercentage::Percentage(
-                        ComputedPercentage(val),
-                    )) => val == 0.0,
+                    OriginComponent::Length(LengthPercentage::Percentage(ComputedPercentage(
+                        val,
+                    ))) => val == 0.0,
                     _ => false,
                 };
                 x && y
diff --git a/components/style/values/specified/length.rs b/components/style/values/specified/length.rs
index 18969f0dcf7..e83abebc37c 100644
--- a/components/style/values/specified/length.rs
+++ b/components/style/values/specified/length.rs
@@ -922,12 +922,9 @@ impl LengthPercentageOrAuto {
             return Ok(LengthPercentageOrAuto::Auto);
         }
 
-        Ok(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::parse_internal(
-            context,
-            input,
-            num_context,
-            allow_quirks,
-        )?))
+        Ok(LengthPercentageOrAuto::LengthPercentage(
+            LengthPercentage::parse_internal(context, input, num_context, allow_quirks)?,
+        ))
     }
 
     /// Parse a non-negative length, percentage, or auto.
@@ -1052,12 +1049,9 @@ impl LengthPercentageOrNone {
             return Ok(LengthPercentageOrNone::None);
         }
 
-        Ok(LengthPercentageOrNone::LengthPercentage(LengthPercentage::parse_internal(
-            context,
-            input,
-            num_context,
-            allow_quirks,
-        )?))
+        Ok(LengthPercentageOrNone::LengthPercentage(
+            LengthPercentage::parse_internal(context, input, num_context, allow_quirks)?,
+        ))
     }
 
     /// Parse a non-negative LengthPercentageOrNone.
@@ -1117,8 +1111,7 @@ impl Parse for NonNegativeLengthPercentage {
         context: &ParserContext,
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
-        LengthPercentage::parse_non_negative(context, input)
-            .map(NonNegative::<LengthPercentage>)
+        LengthPercentage::parse_non_negative(context, input).map(NonNegative::<LengthPercentage>)
     }
 }
 
diff --git a/tests/unit/style/viewport.rs b/tests/unit/style/viewport.rs
index 219eb0e3723..89f708643b9 100644
--- a/tests/unit/style/viewport.rs
+++ b/tests/unit/style/viewport.rs
@@ -14,10 +14,10 @@ use style::parser::ParserContext;
 use style::shared_lock::{SharedRwLock, StylesheetGuards};
 use style::stylesheets::viewport_rule::*;
 use style::stylesheets::{CssRuleType, Origin, Stylesheet, StylesheetInDocument};
+use style::values::specified::LengthPercentage;
 use style::values::specified::LengthPercentageOrAuto::{self, Auto};
 use style::values::specified::NoCalcLength::{self, ViewportPercentage};
 use style::values::specified::ViewportPercentageLength::Vw;
-use style::values::specified::LengthPercentage;
 use style_traits::viewport::*;
 use style_traits::{ParsingMode, PinchZoomFactor};
 
@@ -97,14 +97,14 @@ macro_rules! assert_decl_len {
 
 macro_rules! viewport_length {
     ($value:expr, px) => {
-        ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::Length(NoCalcLength::from_px(
-            $value,
-        ))))
+        ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(
+            LengthPercentage::Length(NoCalcLength::from_px($value)),
+        ))
     };
     ($value:expr, vw) => {
-        ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::Length(ViewportPercentage(Vw(
-            $value,
-        )))))
+        ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(
+            LengthPercentage::Length(ViewportPercentage(Vw($value))),
+        ))
     };
 }