Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Rustfmt recent changes.

Browse source
This commit is contained in:
Emilio Cobos Álvarez 2019-01-07 16:57:43 +01:00
parent c7f30ad0df
commit 2a6cdaa30a
22 changed files with 141 additions and 172 deletions
Download patch file Download diff file Expand all files Collapse all files

17
components/layout/block.rs
View file

@ -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

22
components/layout/flex.rs
View file

@ -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 {

5
components/layout/floats.rs
View file

@ -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)

5
components/layout/fragment.rs
View file

@ -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));

13
components/layout/model.rs
View file

@ -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,

14
components/layout/multicol.rs
View file

@ -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(|| {

40
components/script/dom/element.rs
View file

@ -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),
)),
));
}

29
components/style/gecko/conversions.rs
View file

@ -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",
),
),
)
};

12
components/style/gecko/values.rs
View file

@ -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),
}
}
}

11
components/style/gecko_bindings/sugar/ns_css_value.rs
View file

@ -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"),
}
}

13
components/style/stylesheets/viewport_rule.rs
View file

@ -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'

4
components/style/values/animated/length.rs
View file

@ -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,

16
components/style/values/animated/svg.rs
View file

@ -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),
})

3
components/style/values/computed/basic_shape.rs
View file

@ -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 =

10
components/style/values/computed/image.rs
View file

@ -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,
}

40
components/style/values/computed/length.rs
View file

@ -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,

6
components/style/values/generics/transform.rs
View file

@ -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,
},

3
components/style/values/specified/box.rs
View file

@ -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));
}

3
components/style/values/specified/grid.rs
View file

@ -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))
}
}

12
components/style/values/specified/image.rs
View file

@ -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

21
components/style/values/specified/length.rs
View file

@ -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>)
}
}

14
tests/unit/style/viewport.rs
View file

@ -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))),
))
};
}