From 2a6cdaa30a94939b36119030a6b88f60a6a4fd80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Mon, 7 Jan 2019 16:57:43 +0100 Subject: [PATCH] Rustfmt recent changes. --- components/layout/block.rs | 17 ++++---- components/layout/flex.rs | 22 +++++----- components/layout/floats.rs | 5 +-- components/layout/fragment.rs | 5 +-- components/layout/model.rs | 13 +++--- components/layout/multicol.rs | 14 +++---- components/script/dom/element.rs | 40 +++++++------------ components/style/gecko/conversions.rs | 29 ++++++-------- components/style/gecko/values.rs | 12 ++++-- .../gecko_bindings/sugar/ns_css_value.rs | 11 ++--- components/style/stylesheets/viewport_rule.rs | 13 +++--- components/style/values/animated/length.rs | 4 +- components/style/values/animated/svg.rs | 16 ++++---- .../style/values/computed/basic_shape.rs | 3 +- components/style/values/computed/image.rs | 10 ++++- components/style/values/computed/length.rs | 40 ++++++++----------- components/style/values/generics/transform.rs | 6 +-- components/style/values/specified/box.rs | 3 +- components/style/values/specified/grid.rs | 3 +- components/style/values/specified/image.rs | 12 +++--- components/style/values/specified/length.rs | 21 ++++------ tests/unit/style/viewport.rs | 14 +++---- 22 files changed, 141 insertions(+), 172 deletions(-) diff --git a/components/layout/block.rs b/components/layout/block.rs index db60a1ed5796..8c4a8a771aa5 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 807e35952653..44055ae7d183 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 32aaccc9834e..5a58e27f9d1d 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 40f3c3f41b2e..db4fd8f4625c 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 3c7441d92827..0650c8887a13 100644 --- a/components/layout/model.rs +++ b/components/layout/model.rs @@ -481,7 +481,6 @@ impl MaybeAuto { } } - #[inline] pub fn map(&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, -) -> MaybeAuto { +pub fn style_length(style_length: LengthPercentageOrAuto, container_size: Option) -> 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, ) -> 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 3f80055e9aa6..14ea36626f91 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 df00142a67d0..d461cd11527f 100644 --- a/components/script/dom/element.rs +++ b/components/script/dom/element.rs @@ -719,7 +719,7 @@ impl LayoutElementHelpers for LayoutDom { 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 { 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 { )); }, 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 { 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 { )); }, 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 { 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 { 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 7e896b375695..89cce99beb09 100644 --- a/components/style/gecko/conversions.rs +++ b/components/style/gecko/conversions.rs @@ -80,8 +80,8 @@ impl From for LengthPercentageOrAuto { // disappear as we move more stuff to cbindgen. impl From 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 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( - " should be a length, percentage, or calc value", - ), + LengthPercentage::from_gecko_style_coord(&other.data_at(index + 1)).expect( + " should be a length, percentage, or calc value", + ), ), ) }; diff --git a/components/style/gecko/values.rs b/components/style/gecko/values.rs index 4937b019b5cf..2288db104a4d 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(&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(coord: &T) -> Option { 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(coord: &T) -> Option { 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(coord: &T) -> Option { 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 b8cc1f9c5c42..73657af3e354 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 ce63ffbfc472..862399e065c1 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 18360fad46bb..672c4117b00d 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 4f181981d911..af627bba7849 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, ) -> Result { 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 9b4be5388545..28067fb0c81f 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; /// A computed circle. -pub type Circle = - generic::Circle; +pub type Circle = generic::Circle; /// A computed ellipse. pub type Ellipse = diff --git a/components/style/values/computed/image.rs b/components/style/values/computed/image.rs index 749c2e44e3ac..a77da59dda3c 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 65f19d117ae8..daf14ea19e34 100644 --- a/components/style/values/computed/length.rs +++ b/components/style/values/computed/length.rs @@ -5,7 +5,7 @@ //! `` 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 87f26efa0d9d..4591f3addd28 100644 --- a/components/style/values/generics/transform.rs +++ b/components/style/values/generics/transform.rs @@ -191,8 +191,7 @@ pub enum TransformOperation { #[allow(missing_docs)] #[css(comma, function = "interpolatematrix")] InterpolateMatrix { - from_list: - Transform>, + from_list: Transform>, to_list: Transform>, progress: computed::Percentage, }, @@ -200,8 +199,7 @@ pub enum TransformOperation { #[allow(missing_docs)] #[css(comma, function = "accumulatematrix")] AccumulateMatrix { - from_list: - Transform>, + from_list: Transform>, to_list: Transform>, count: Integer, }, diff --git a/components/style/values/specified/box.rs b/components/style/values/specified/box.rs index 62d1ba50333a..30111170bc0a 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> { - 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 55a977baf8c0..b3e18e66e8ec 100644 --- a/components/style/values/specified/grid.rs +++ b/components/style/values/specified/grid.rs @@ -73,8 +73,7 @@ impl Parse for TrackSize { } 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 42b090686ca7..2dc56f8ad3fc 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 18969f0dcf7a..e83abebc37ca 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> { - LengthPercentage::parse_non_negative(context, input) - .map(NonNegative::) + LengthPercentage::parse_non_negative(context, input).map(NonNegative::) } } diff --git a/tests/unit/style/viewport.rs b/tests/unit/style/viewport.rs index 219eb0e37231..89f708643b95 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))), + )) }; }