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 = let min_block_size = fragment
fragment.style.min_block_size().maybe_to_used_value(block_container_block_size).unwrap_or(Au(0)); .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. // 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 { 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. // rather than bubbling up children inline width.
let consult_children = match self.fragment.style().get_position().width { let consult_children = match self.fragment.style().get_position().width {
LengthPercentageOrAuto::Auto => true, 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.bubble_inline_sizes_for_block(consult_children);
self.fragment self.fragment
@ -2540,8 +2545,7 @@ impl Flow for BlockFlow {
.base .base
.flags .flags
.contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) && .contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) &&
self.fragment.style().logical_position().inline_start == self.fragment.style().logical_position().inline_start == LengthPercentageOrAuto::Auto &&
LengthPercentageOrAuto::Auto &&
self.fragment.style().logical_position().inline_end == LengthPercentageOrAuto::Auto self.fragment.style().logical_position().inline_end == LengthPercentageOrAuto::Auto
{ {
self.base.position.start.i = inline_position self.base.position.start.i = inline_position
@ -2553,8 +2557,7 @@ impl Flow for BlockFlow {
.base .base
.flags .flags
.contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) && .contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) &&
self.fragment.style().logical_position().block_start == self.fragment.style().logical_position().block_start == LengthPercentageOrAuto::Auto &&
LengthPercentageOrAuto::Auto &&
self.fragment.style().logical_position().block_end == LengthPercentageOrAuto::Auto self.fragment.style().logical_position().block_end == LengthPercentageOrAuto::Auto
{ {
self.base.position.start.b = block_position 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::properties::ComputedValues;
use style::servo::restyle_damage::ServoRestyleDamage; use style::servo::restyle_damage::ServoRestyleDamage;
use style::values::computed::flex::FlexBasis; use style::values::computed::flex::FlexBasis;
use style::values::computed::{ use style::values::computed::{LengthPercentage, LengthPercentageOrAuto, LengthPercentageOrNone};
LengthPercentage, LengthPercentageOrAuto, LengthPercentageOrNone,
};
use style::values::generics::flex::FlexBasis as GenericFlexBasis; use style::values::generics::flex::FlexBasis as GenericFlexBasis;
/// The size of an axis. May be a specified size, a min/max /// The size of an axis. May be a specified size, a min/max
@ -54,13 +52,13 @@ impl AxisSize {
match size { match size {
LengthPercentageOrAuto::Auto => { LengthPercentageOrAuto::Auto => {
AxisSize::MinMax(SizeConstraint::new(content_size, min, max, None)) AxisSize::MinMax(SizeConstraint::new(content_size, min, max, None))
} },
LengthPercentageOrAuto::LengthPercentage(ref lp) => { LengthPercentageOrAuto::LengthPercentage(ref lp) => {
match lp.maybe_to_used_value(content_size) { match lp.maybe_to_used_value(content_size) {
Some(length) => AxisSize::Definite(length), Some(length) => AxisSize::Definite(length),
None => AxisSize::Infinite, None => AxisSize::Infinite,
} }
} },
} }
} }
} }
@ -459,10 +457,9 @@ impl FlexFlow {
// stripped out, and max replaced with union_nonbreaking_inline. // stripped out, and max replaced with union_nonbreaking_inline.
fn inline_mode_bubble_inline_sizes(&mut self) { fn inline_mode_bubble_inline_sizes(&mut self) {
// FIXME(emilio): This doesn't handle at all writing-modes. // FIXME(emilio): This doesn't handle at all writing-modes.
let fixed_width = !model::style_length( let fixed_width =
self.block_flow.fragment.style().get_position().width, !model::style_length(self.block_flow.fragment.style().get_position().width, None)
None, .is_auto();
).is_auto();
let mut computation = self.block_flow.fragment.compute_intrinsic_inline_sizes(); let mut computation = self.block_flow.fragment.compute_intrinsic_inline_sizes();
if !fixed_width { if !fixed_width {
@ -486,10 +483,9 @@ impl FlexFlow {
// Currently, this is the core of BlockFlow::bubble_inline_sizes() with all float logic // Currently, this is the core of BlockFlow::bubble_inline_sizes() with all float logic
// stripped out. // stripped out.
fn block_mode_bubble_inline_sizes(&mut self) { fn block_mode_bubble_inline_sizes(&mut self) {
let fixed_width = !model::style_length( let fixed_width =
self.block_flow.fragment.style().get_position().width, !model::style_length(self.block_flow.fragment.style().get_position().width, None)
None, .is_auto();
).is_auto();
let mut computation = self.block_flow.fragment.compute_intrinsic_inline_sizes(); let mut computation = self.block_flow.fragment.compute_intrinsic_inline_sizes();
if !fixed_width { 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 // nonzero value (in this case, 1px) so that the layout
// traversal logic will know that objects later in the document // traversal logic will know that objects later in the document
// might flow around this float. // might flow around this float.
let inline_size = let inline_size = flow.as_block().fragment.style.content_inline_size();
flow.as_block().fragment.style.content_inline_size();
let fixed = match inline_size { let fixed = match inline_size {
LengthPercentageOrAuto::Auto => false, LengthPercentageOrAuto::Auto => false,
LengthPercentageOrAuto::LengthPercentage(ref lp) => { LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.is_definitely_zero() || lp.maybe_to_used_value(None).is_some() lp.is_definitely_zero() || lp.maybe_to_used_value(None).is_some()
} },
}; };
if !fixed { if !fixed {
float_inline_size = Au::from_px(1) float_inline_size = Au::from_px(1)

5
components/layout/fragment.rs
View file

@ -1614,7 +1614,7 @@ impl Fragment {
LengthPercentageOrAuto::Auto => None, LengthPercentageOrAuto::Auto => None,
LengthPercentageOrAuto::LengthPercentage(ref lp) => { LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(None) lp.maybe_to_used_value(None)
} },
}; };
let mut inline_size = inline_size.unwrap_or_else(|| { let mut inline_size = inline_size.unwrap_or_else(|| {
@ -1622,8 +1622,7 @@ impl Fragment {
// the size constraints work properly. // the size constraints work properly.
// TODO(stshine): Find a cleaner way to do this. // TODO(stshine): Find a cleaner way to do this.
let padding = self.style.logical_padding(); let padding = self.style.logical_padding();
self.border_padding.inline_start = self.border_padding.inline_start = padding.inline_start.to_used_value(Au(0));
padding.inline_start.to_used_value(Au(0));
self.border_padding.inline_end = padding.inline_end.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_start = padding.block_start.to_used_value(Au(0));
self.border_padding.block_end = padding.block_end.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] #[inline]
pub fn map<F>(&self, mapper: F) -> MaybeAuto pub fn map<F>(&self, mapper: F) -> MaybeAuto
where where
@ -497,15 +496,12 @@ impl MaybeAuto {
/// Receive an optional container size and return used value for width or height. /// Receive an optional container size and return used value for width or height.
/// ///
/// `style_length`: content size as given in the CSS. /// `style_length`: content size as given in the CSS.
pub fn style_length( pub fn style_length(style_length: LengthPercentageOrAuto, container_size: Option<Au>) -> MaybeAuto {
style_length: LengthPercentageOrAuto,
container_size: Option<Au>,
) -> MaybeAuto {
match style_length { match style_length {
LengthPercentageOrAuto::Auto => MaybeAuto::Auto, LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthPercentageOrAuto::LengthPercentage(ref lp) => { LengthPercentageOrAuto::LengthPercentage(ref lp) => {
MaybeAuto::from_option(lp.maybe_to_used_value(container_size)) MaybeAuto::from_option(lp.maybe_to_used_value(container_size))
} },
} }
} }
@ -574,8 +570,9 @@ impl SizeConstraint {
max_size: LengthPercentageOrNone, max_size: LengthPercentageOrNone,
border: Option<Au>, border: Option<Au>,
) -> SizeConstraint { ) -> SizeConstraint {
let mut min_size = let mut min_size = min_size
min_size.maybe_to_used_value(container_size).unwrap_or(Au(0)); .maybe_to_used_value(container_size)
.unwrap_or(Au(0));
let mut max_size = match max_size { let mut max_size = match max_size {
LengthPercentageOrNone::None => None, LengthPercentageOrNone::None => None,

14
components/layout/multicol.rs
View file

@ -158,15 +158,13 @@ impl Flow for MulticolFlow {
LengthPercentageOrAuto::Auto => None, LengthPercentageOrAuto::Auto => None,
LengthPercentageOrAuto::LengthPercentage(ref lp) => { LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(None) lp.maybe_to_used_value(None)
} },
}; };
let size = size.or_else(|| { let size = size.or_else(|| match style.max_block_size() {
match style.max_block_size() { LengthPercentageOrNone::None => None,
LengthPercentageOrNone::None => None, LengthPercentageOrNone::LengthPercentage(ref lp) => {
LengthPercentageOrNone::LengthPercentage(ref lp) => { lp.maybe_to_used_value(None)
lp.maybe_to_used_value(None) },
}
}
}); });
size.unwrap_or_else(|| { 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( hints.push(from_declaration(
shared_lock, shared_lock,
PropertyDeclaration::Width(specified::LengthPercentageOrAuto::LengthPercentage( 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::Auto => {},
LengthOrPercentageOrAuto::Percentage(percentage) => { LengthOrPercentageOrAuto::Percentage(percentage) => {
let width_value = specified::LengthPercentageOrAuto::LengthPercentage( let width_value = specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Percentage( specified::LengthPercentage::Percentage(computed::Percentage(percentage)),
computed::Percentage(percentage),
),
); );
hints.push(from_declaration( hints.push(from_declaration(
shared_lock, shared_lock,
@ -756,14 +754,11 @@ impl LayoutElementHelpers for LayoutDom<Element> {
)); ));
}, },
LengthOrPercentageOrAuto::Length(length) => { LengthOrPercentageOrAuto::Length(length) => {
let width_value = let width_value = specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentageOrAuto::LengthPercentage( specified::LengthPercentage::Length(specified::NoCalcLength::Absolute(
specified::LengthPercentage::Length( specified::AbsoluteLength::Px(length.to_f32_px()),
specified::NoCalcLength::Absolute( )),
specified::AbsoluteLength::Px(length.to_f32_px()), );
),
),
);
hints.push(from_declaration( hints.push(from_declaration(
shared_lock, shared_lock,
PropertyDeclaration::Width(width_value), PropertyDeclaration::Width(width_value),
@ -785,9 +780,7 @@ impl LayoutElementHelpers for LayoutDom<Element> {
LengthOrPercentageOrAuto::Auto => {}, LengthOrPercentageOrAuto::Auto => {},
LengthOrPercentageOrAuto::Percentage(percentage) => { LengthOrPercentageOrAuto::Percentage(percentage) => {
let height_value = specified::LengthPercentageOrAuto::LengthPercentage( let height_value = specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Percentage( specified::LengthPercentage::Percentage(computed::Percentage(percentage)),
computed::Percentage(percentage),
)
); );
hints.push(from_declaration( hints.push(from_declaration(
shared_lock, shared_lock,
@ -795,14 +788,11 @@ impl LayoutElementHelpers for LayoutDom<Element> {
)); ));
}, },
LengthOrPercentageOrAuto::Length(length) => { LengthOrPercentageOrAuto::Length(length) => {
let height_value = let height_value = specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentageOrAuto::LengthPercentage( specified::LengthPercentage::Length(specified::NoCalcLength::Absolute(
specified::LengthPercentage::Length( specified::AbsoluteLength::Px(length.to_f32_px()),
specified::NoCalcLength::Absolute( )),
specified::AbsoluteLength::Px(length.to_f32_px()), );
)
)
);
hints.push(from_declaration( hints.push(from_declaration(
shared_lock, shared_lock,
PropertyDeclaration::Height(height_value), PropertyDeclaration::Height(height_value),
@ -830,7 +820,7 @@ impl LayoutElementHelpers for LayoutDom<Element> {
hints.push(from_declaration( hints.push(from_declaration(
shared_lock, shared_lock,
PropertyDeclaration::Width(specified::LengthPercentageOrAuto::LengthPercentage( 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( hints.push(from_declaration(
shared_lock, shared_lock,
PropertyDeclaration::Height(specified::LengthPercentageOrAuto::LengthPercentage( 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. // disappear as we move more stuff to cbindgen.
impl From<nsStyleCoord_CalcValue> for NonNegativeLengthPercentageOrAuto { impl From<nsStyleCoord_CalcValue> for NonNegativeLengthPercentageOrAuto {
fn from(other: nsStyleCoord_CalcValue) -> Self { fn from(other: nsStyleCoord_CalcValue) -> Self {
NonNegative( NonNegative(LengthPercentageOrAuto::LengthPercentage(
LengthPercentageOrAuto::LengthPercentage(LengthPercentage::with_clamping_mode( LengthPercentage::with_clamping_mode(
Au(other.mLength).into(), Au(other.mLength).into(),
if other.mHasPercent { if other.mHasPercent {
Some(Percentage(other.mPercent)) Some(Percentage(other.mPercent))
@ -90,8 +90,8 @@ impl From<nsStyleCoord_CalcValue> for NonNegativeLengthPercentageOrAuto {
}, },
AllowedNumericType::NonNegative, AllowedNumericType::NonNegative,
/* was_calc = */ true, /* was_calc = */ true,
)) ),
) ))
} }
} }
@ -529,17 +529,15 @@ impl nsStyleImage {
structs::NS_STYLE_GRADIENT_SHAPE_ELLIPTICAL => { structs::NS_STYLE_GRADIENT_SHAPE_ELLIPTICAL => {
let length_percentage_keyword = match gecko_gradient.mSize as u32 { let length_percentage_keyword = match gecko_gradient.mSize as u32 {
structs::NS_STYLE_GRADIENT_SIZE_EXPLICIT_SIZE => match ( structs::NS_STYLE_GRADIENT_SIZE_EXPLICIT_SIZE => match (
LengthPercentage::from_gecko_style_coord( LengthPercentage::from_gecko_style_coord(&gecko_gradient.mRadiusX),
&gecko_gradient.mRadiusX, LengthPercentage::from_gecko_style_coord(&gecko_gradient.mRadiusY),
),
LengthPercentage::from_gecko_style_coord(
&gecko_gradient.mRadiusY,
),
) { ) {
(Some(x), Some(y)) => Ellipse::Radii(x, y), (Some(x), Some(y)) => Ellipse::Radii(x, y),
_ => { _ => {
debug_assert!(false, debug_assert!(
"mRadiusX, mRadiusY could not convert to LengthPercentage"); false,
"mRadiusX, mRadiusY could not convert to LengthPercentage"
);
Ellipse::Radii( Ellipse::Radii(
LengthPercentage::zero(), LengthPercentage::zero(),
LengthPercentage::zero(), LengthPercentage::zero(),
@ -802,10 +800,9 @@ pub mod basic_shape {
), ),
), ),
NonNegative( NonNegative(
LengthPercentage::from_gecko_style_coord(&other.data_at(index + 1)) LengthPercentage::from_gecko_style_coord(&other.data_at(index + 1)).expect(
.expect( "<border-radius> should be a length, percentage, or calc value",
"<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 { impl GeckoStyleCoordConvertible for LengthPercentage {
fn to_gecko_style_coord<T: CoordDataMut>(&self, coord: &mut T) { fn to_gecko_style_coord<T: CoordDataMut>(&self, coord: &mut T) {
if self.was_calc { 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()); debug_assert!(self.percentage.is_none() || self.unclamped_length() == Length::zero());
if let Some(p) = self.percentage { 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> { fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
match coord.as_value() { match coord.as_value() {
CoordDataValue::Coord(coord) => Some(LengthPercentage::new(Au(coord).into(), None)), 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()), CoordDataValue::Calc(calc) => Some(calc.into()),
_ => None, _ => None,
} }
@ -192,7 +194,8 @@ impl GeckoStyleCoordConvertible for LengthPercentageOrAuto {
fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> { fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
match coord.as_value() { match coord.as_value() {
CoordDataValue::Auto => Some(LengthPercentageOrAuto::Auto), 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> { fn from_gecko_style_coord<T: CoordData>(coord: &T) -> Option<Self> {
match coord.as_value() { match coord.as_value() {
CoordDataValue::None => Some(LengthPercentageOrNone::None), 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. /// Sets LengthPercentage value to this nsCSSValue.
pub unsafe fn set_length_percentage(&mut self, lp: LengthPercentage) { pub unsafe fn set_length_percentage(&mut self, lp: LengthPercentage) {
if lp.was_calc { 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()); debug_assert!(lp.percentage.is_none() || lp.unclamped_length() == Length::zero());
if let Some(p) = lp.percentage { if let Some(p) = lp.percentage {
@ -93,17 +93,12 @@ impl nsCSSValue {
pub unsafe fn get_length_percentage(&self) -> LengthPercentage { pub unsafe fn get_length_percentage(&self) -> LengthPercentage {
match self.mUnit { match self.mUnit {
nsCSSUnit::eCSSUnit_Pixel => { nsCSSUnit::eCSSUnit_Pixel => {
LengthPercentage::new( LengthPercentage::new(Length::new(bindings::Gecko_CSSValue_GetNumber(self)), None)
Length::new(bindings::Gecko_CSSValue_GetNumber(self)),
None,
)
}, },
nsCSSUnit::eCSSUnit_Percent => LengthPercentage::new_percent(Percentage( nsCSSUnit::eCSSUnit_Percent => LengthPercentage::new_percent(Percentage(
bindings::Gecko_CSSValue_GetPercentage(self), bindings::Gecko_CSSValue_GetPercentage(self),
)), )),
nsCSSUnit::eCSSUnit_Calc => { nsCSSUnit::eCSSUnit_Calc => bindings::Gecko_CSSValue_GetCalc(self).into(),
bindings::Gecko_CSSValue_GetCalc(self).into()
},
_ => panic!("Unexpected unit"), _ => 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::str::CssStringWriter;
use crate::stylesheets::{Origin, StylesheetInDocument}; use crate::stylesheets::{Origin, StylesheetInDocument};
use crate::values::computed::{Context, ToComputedValue}; 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 app_units::Au;
use cssparser::CowRcStr; use cssparser::CowRcStr;
use cssparser::{parse_important, AtRuleParser, DeclarationListParser, DeclarationParser, Parser}; use cssparser::{parse_important, AtRuleParser, DeclarationListParser, DeclarationParser, Parser};
@ -158,7 +160,7 @@ impl FromMeta for ViewportLength {
macro_rules! specified { macro_rules! specified {
($value:expr) => { ($value:expr) => {
ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage( ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Length($value) specified::LengthPercentage::Length($value),
)) ))
}; };
} }
@ -755,9 +757,10 @@ impl MaybeNew for ViewportConstraints {
match *$value { match *$value {
ViewportLength::Specified(ref length) => match *length { ViewportLength::Specified(ref length) => match *length {
LengthPercentageOrAuto::Auto => None, LengthPercentageOrAuto::Auto => None,
LengthPercentageOrAuto::LengthPercentage(ref lop) => Some(lop LengthPercentageOrAuto::LengthPercentage(ref lop) => Some(
.to_computed_value(&context) lop.to_computed_value(&context)
.to_used_value(initial_viewport.$dimension)), .to_used_value(initial_viewport.$dimension),
),
}, },
ViewportLength::ExtendToZoom => { ViewportLength::ExtendToZoom => {
// $extend_to will be 'None' if 'extend-to-zoom' is 'auto' // $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() .unclamped_length()
.animate(&other.unclamped_length(), procedure)?; .animate(&other.unclamped_length(), procedure)?;
let percentage = animate_percentage_half(self.percentage, other.percentage)?; 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( Ok(Self::with_clamping_mode(
length, length,
percentage, percentage,

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

@ -32,16 +32,14 @@ fn to_number_or_percentage(
value: &SvgLengthPercentageOrNumber<LengthPercentage, Number>, value: &SvgLengthPercentageOrNumber<LengthPercentage, Number>,
) -> Result<NumberOrPercentage, ()> { ) -> Result<NumberOrPercentage, ()> {
Ok(match *value { Ok(match *value {
SvgLengthPercentageOrNumber::LengthPercentage(ref l) => { SvgLengthPercentageOrNumber::LengthPercentage(ref l) => match l.percentage {
match l.percentage { Some(p) => {
Some(p) => { if l.unclamped_length().px() != 0. {
if l.unclamped_length().px() != 0. { return Err(());
return Err(());
}
NumberOrPercentage::Percentage(p)
} }
None => NumberOrPercentage::Number(l.length().px()) NumberOrPercentage::Percentage(p)
} },
None => NumberOrPercentage::Number(l.length().px()),
}, },
SvgLengthPercentageOrNumber::Number(ref n) => NumberOrPercentage::Number(*n), 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>; pub type InsetRect = generic::InsetRect<LengthPercentage, NonNegativeLengthPercentage>;
/// A computed circle. /// A computed circle.
pub type Circle = pub type Circle = generic::Circle<LengthPercentage, LengthPercentage, NonNegativeLengthPercentage>;
generic::Circle<LengthPercentage, LengthPercentage, NonNegativeLengthPercentage>;
/// A computed ellipse. /// A computed ellipse.
pub type 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::Vertical(Y::Top) if compat_mode != CompatMode::Modern => true,
LineDirection::Corner(..) => false, LineDirection::Corner(..) => false,
#[cfg(feature = "gecko")] #[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. // `50% 0%` is the default value for line direction.
horizontal.as_percentage().map_or(false, |p| p.0 == 0.5) && 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, _ => false,
} }

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

@ -5,7 +5,7 @@
//! `<length>` computed values, and related ones. //! `<length>` computed values, and related ones.
use super::{Context, Number, Percentage, ToComputedValue}; 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::distance::{ComputeSquaredDistance, SquaredDistance};
use crate::values::generics::length::MaxLength as GenericMaxLength; use crate::values::generics::length::MaxLength as GenericMaxLength;
use crate::values::generics::length::MozLength as GenericMozLength; use crate::values::generics::length::MozLength as GenericMozLength;
@ -170,7 +170,6 @@ impl LengthPercentage {
self.length self.length
} }
/// Return the percentage value as CSSFloat. /// Return the percentage value as CSSFloat.
#[inline] #[inline]
pub fn percentage(&self) -> CSSFloat { pub fn percentage(&self) -> CSSFloat {
@ -380,7 +379,7 @@ impl LengthPercentage {
self.percentage, self.percentage,
AllowedNumericType::NonNegative, AllowedNumericType::NonNegative,
self.was_calc, self.was_calc,
) );
} }
debug_assert!(self.percentage.is_none() || self.unclamped_length() == Length::zero()); 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) => { specified::LengthPercentage::Length(ref value) => {
LengthPercentage::new(value.to_computed_value(context), None) LengthPercentage::new(value.to_computed_value(context), None)
}, },
specified::LengthPercentage::Percentage(value) => { specified::LengthPercentage::Percentage(value) => LengthPercentage::new_percent(value),
LengthPercentage::new_percent(value) specified::LengthPercentage::Calc(ref calc) => (**calc).to_computed_value(context),
},
specified::LengthPercentage::Calc(ref calc) => {
(**calc).to_computed_value(context)
},
} }
} }
fn from_computed_value(computed: &LengthPercentage) -> Self { fn from_computed_value(computed: &LengthPercentage) -> Self {
let length = computed.unclamped_length(); let length = computed.unclamped_length();
if let Some(p) = computed.as_percentage() { if let Some(p) = computed.as_percentage() {
return specified::LengthPercentage::Percentage(p) return specified::LengthPercentage::Percentage(p);
} }
let percentage = computed.percentage; let percentage = computed.percentage;
if percentage.is_none() && if percentage.is_none() && computed.clamping_mode.clamp(length.px()) == length.px() {
computed.clamping_mode.clamp(length.px()) == length.px() { return specified::LengthPercentage::Length(ToComputedValue::from_computed_value(
return specified::LengthPercentage::Length( &length,
ToComputedValue::from_computed_value(&length) ));
)
} }
specified::LengthPercentage::Calc(Box::new( specified::LengthPercentage::Calc(Box::new(ToComputedValue::from_computed_value(computed)))
ToComputedValue::from_computed_value(computed),
))
} }
} }
@ -448,7 +440,9 @@ impl IsZeroLength for LengthPercentage {
#[allow(missing_docs)] #[allow(missing_docs)]
#[css(derive_debug)] #[css(derive_debug)]
#[derive(Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss)] #[derive(
Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss,
)]
pub enum LengthPercentageOrAuto { pub enum LengthPercentageOrAuto {
LengthPercentage(LengthPercentage), LengthPercentage(LengthPercentage),
Auto, Auto,
@ -522,9 +516,7 @@ impl ToComputedValue for specified::LengthPercentageOrAuto {
fn to_computed_value(&self, context: &Context) -> LengthPercentageOrAuto { fn to_computed_value(&self, context: &Context) -> LengthPercentageOrAuto {
match *self { match *self {
specified::LengthPercentageOrAuto::LengthPercentage(ref value) => { specified::LengthPercentageOrAuto::LengthPercentage(ref value) => {
LengthPercentageOrAuto::LengthPercentage( LengthPercentageOrAuto::LengthPercentage(value.to_computed_value(context))
value.to_computed_value(context),
)
}, },
specified::LengthPercentageOrAuto::Auto => LengthPercentageOrAuto::Auto, specified::LengthPercentageOrAuto::Auto => LengthPercentageOrAuto::Auto,
} }
@ -545,7 +537,9 @@ impl ToComputedValue for specified::LengthPercentageOrAuto {
#[allow(missing_docs)] #[allow(missing_docs)]
#[css(derive_debug)] #[css(derive_debug)]
#[derive(Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss)] #[derive(
Animate, Clone, ComputeSquaredDistance, Copy, MallocSizeOf, PartialEq, ToAnimatedZero, ToCss,
)]
pub enum LengthPercentageOrNone { pub enum LengthPercentageOrNone {
LengthPercentage(LengthPercentage), LengthPercentage(LengthPercentage),
None, 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)] #[allow(missing_docs)]
#[css(comma, function = "interpolatematrix")] #[css(comma, function = "interpolatematrix")]
InterpolateMatrix { InterpolateMatrix {
from_list: from_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>, to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
progress: computed::Percentage, progress: computed::Percentage,
}, },
@ -200,8 +199,7 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthPercentage> {
#[allow(missing_docs)] #[allow(missing_docs)]
#[css(comma, function = "accumulatematrix")] #[css(comma, function = "accumulatematrix")]
AccumulateMatrix { AccumulateMatrix {
from_list: from_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>, to_list: Transform<TransformOperation<Angle, Number, Length, Integer, LengthPercentage>>,
count: Integer, count: Integer,
}, },

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

@ -278,8 +278,7 @@ impl Parse for VerticalAlign {
context: &ParserContext, context: &ParserContext,
input: &mut Parser<'i, 't>, input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> { ) -> Result<Self, ParseError<'i>> {
if let Ok(lp) = if let Ok(lp) = input.try(|i| LengthPercentage::parse_quirky(context, i, AllowQuirks::Yes))
input.try(|i| LengthPercentage::parse_quirky(context, i, AllowQuirks::Yes))
{ {
return Ok(GenericVerticalAlign::Length(lp)); 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")?; input.expect_function_matching("fit-content")?;
let lp = let lp = input.parse_nested_block(|i| LengthPercentage::parse_non_negative(context, i))?;
input.parse_nested_block(|i| LengthPercentage::parse_non_negative(context, i))?;
Ok(TrackSize::FitContent(lp)) 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. // These percentage values can also be keywords.
let x = match *x { let x = match *x {
OriginComponent::Center => true, OriginComponent::Center => true,
OriginComponent::Length(LengthPercentage::Percentage( OriginComponent::Length(LengthPercentage::Percentage(ComputedPercentage(
ComputedPercentage(val), val,
)) => val == 0.5, ))) => val == 0.5,
_ => false, _ => false,
}; };
let y = match *y { let y = match *y {
OriginComponent::Side(Y::Top) => true, OriginComponent::Side(Y::Top) => true,
OriginComponent::Length(LengthPercentage::Percentage( OriginComponent::Length(LengthPercentage::Percentage(ComputedPercentage(
ComputedPercentage(val), val,
)) => val == 0.0, ))) => val == 0.0,
_ => false, _ => false,
}; };
x && y x && y

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

@ -922,12 +922,9 @@ impl LengthPercentageOrAuto {
return Ok(LengthPercentageOrAuto::Auto); return Ok(LengthPercentageOrAuto::Auto);
} }
Ok(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::parse_internal( Ok(LengthPercentageOrAuto::LengthPercentage(
context, LengthPercentage::parse_internal(context, input, num_context, allow_quirks)?,
input, ))
num_context,
allow_quirks,
)?))
} }
/// Parse a non-negative length, percentage, or auto. /// Parse a non-negative length, percentage, or auto.
@ -1052,12 +1049,9 @@ impl LengthPercentageOrNone {
return Ok(LengthPercentageOrNone::None); return Ok(LengthPercentageOrNone::None);
} }
Ok(LengthPercentageOrNone::LengthPercentage(LengthPercentage::parse_internal( Ok(LengthPercentageOrNone::LengthPercentage(
context, LengthPercentage::parse_internal(context, input, num_context, allow_quirks)?,
input, ))
num_context,
allow_quirks,
)?))
} }
/// Parse a non-negative LengthPercentageOrNone. /// Parse a non-negative LengthPercentageOrNone.
@ -1117,8 +1111,7 @@ impl Parse for NonNegativeLengthPercentage {
context: &ParserContext, context: &ParserContext,
input: &mut Parser<'i, 't>, input: &mut Parser<'i, 't>,
) -> Result<Self, ParseError<'i>> { ) -> Result<Self, ParseError<'i>> {
LengthPercentage::parse_non_negative(context, input) LengthPercentage::parse_non_negative(context, input).map(NonNegative::<LengthPercentage>)
.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::shared_lock::{SharedRwLock, StylesheetGuards};
use style::stylesheets::viewport_rule::*; use style::stylesheets::viewport_rule::*;
use style::stylesheets::{CssRuleType, Origin, Stylesheet, StylesheetInDocument}; use style::stylesheets::{CssRuleType, Origin, Stylesheet, StylesheetInDocument};
use style::values::specified::LengthPercentage;
use style::values::specified::LengthPercentageOrAuto::{self, Auto}; use style::values::specified::LengthPercentageOrAuto::{self, Auto};
use style::values::specified::NoCalcLength::{self, ViewportPercentage}; use style::values::specified::NoCalcLength::{self, ViewportPercentage};
use style::values::specified::ViewportPercentageLength::Vw; use style::values::specified::ViewportPercentageLength::Vw;
use style::values::specified::LengthPercentage;
use style_traits::viewport::*; use style_traits::viewport::*;
use style_traits::{ParsingMode, PinchZoomFactor}; use style_traits::{ParsingMode, PinchZoomFactor};
@ -97,14 +97,14 @@ macro_rules! assert_decl_len {
macro_rules! viewport_length { macro_rules! viewport_length {
($value:expr, px) => { ($value:expr, px) => {
ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::Length(NoCalcLength::from_px( ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(
$value, LengthPercentage::Length(NoCalcLength::from_px($value)),
)))) ))
}; };
($value:expr, vw) => { ($value:expr, vw) => {
ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::Length(ViewportPercentage(Vw( ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(
$value, LengthPercentage::Length(ViewportPercentage(Vw($value))),
))))) ))
}; };
} }