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

style: Fix servo build.

Browse source
This commit is contained in:
Emilio Cobos Álvarez 2019-01-07 16:55:29 +01:00
parent 80651fde47
commit c7f30ad0df
16 changed files with 117 additions and 117 deletions
Download patch file Download diff file Expand all files Collapse all files

36
components/layout/block.rs
View file

@ -66,7 +66,7 @@ use style::context::SharedStyleContext;
use style::logical_geometry::{LogicalMargin, LogicalPoint, LogicalRect, LogicalSize, WritingMode};
use style::properties::ComputedValues;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::values::computed::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone};
use style::values::computed::{LengthPercentageOrAuto, LengthPercentageOrNone};
/// Information specific to floated blocks.
#[derive(Clone, Serialize)]
@ -418,15 +418,15 @@ impl CandidateBSizeIterator {
// `min-height` and `max-height`, percentage values are ignored.
let block_size = match fragment.style.content_block_size() {
LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
MaybeAuto::from_option(lp.maybe_to_used_value(block_container_block_size))
},
};
let max_block_size = match fragment.style.max_block_size() {
LengthOrPercentageOrNone::None => None,
LengthOrPercentageOrNone::LengthOrPercentage(ref lp) => {
LengthPercentageOrNone::None => None,
LengthPercentageOrNone::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(block_container_block_size)
},
};
@ -1396,7 +1396,7 @@ impl BlockFlow {
let content_block_size = self.fragment.style().content_block_size();
match content_block_size {
LengthOrPercentageOrAuto::Auto => {
LengthPercentageOrAuto::Auto => {
let container_size = containing_block_size?;
let (block_start, block_end) = {
let position = self.fragment.style().logical_position();
@ -1415,11 +1415,11 @@ impl BlockFlow {
// calculated during assign-inline-size.
let margin = self.fragment.style().logical_margin();
let margin_block_start = match margin.block_start {
LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
_ => MaybeAuto::Specified(self.fragment.margin.block_start),
};
let margin_block_end = match margin.block_end {
LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
_ => MaybeAuto::Specified(self.fragment.margin.block_end),
};
@ -1431,7 +1431,7 @@ impl BlockFlow {
(_, _) => None,
}
},
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(containing_block_size)
},
}
@ -1452,11 +1452,11 @@ impl BlockFlow {
// calculated during assign-inline-size.
let margin = self.fragment.style().logical_margin();
let margin_block_start = match margin.block_start {
LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
_ => MaybeAuto::Specified(self.fragment.margin.block_start),
};
let margin_block_end = match margin.block_end {
LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
_ => MaybeAuto::Specified(self.fragment.margin.block_end),
};
@ -2022,7 +2022,7 @@ impl BlockFlow {
// If `max-width` is set, then don't perform this speculation. We guess that the
// page set `max-width` in order to avoid hitting floats. The search box on Google
// SERPs falls into this category.
if self.fragment.style.max_inline_size() != LengthOrPercentageOrNone::None {
if self.fragment.style.max_inline_size() != LengthPercentageOrNone::None {
return;
}
@ -2153,8 +2153,8 @@ impl Flow for BlockFlow {
// If this block has a fixed width, just use that for the minimum and preferred width,
// rather than bubbling up children inline width.
let consult_children = match self.fragment.style().get_position().width {
LengthOrPercentageOrAuto::Auto => true,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => lp.maybe_to_used_value(None).is_none(),
LengthPercentageOrAuto::Auto => true,
LengthPercentageOrAuto::LengthPercentage(ref lp) => lp.maybe_to_used_value(None).is_none(),
};
self.bubble_inline_sizes_for_block(consult_children);
self.fragment
@ -2541,8 +2541,8 @@ impl Flow for BlockFlow {
.flags
.contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) &&
self.fragment.style().logical_position().inline_start ==
LengthOrPercentageOrAuto::Auto &&
self.fragment.style().logical_position().inline_end == LengthOrPercentageOrAuto::Auto
LengthPercentageOrAuto::Auto &&
self.fragment.style().logical_position().inline_end == LengthPercentageOrAuto::Auto
{
self.base.position.start.i = inline_position
}
@ -2554,8 +2554,8 @@ impl Flow for BlockFlow {
.flags
.contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) &&
self.fragment.style().logical_position().block_start ==
LengthOrPercentageOrAuto::Auto &&
self.fragment.style().logical_position().block_end == LengthOrPercentageOrAuto::Auto
LengthPercentageOrAuto::Auto &&
self.fragment.style().logical_position().block_end == LengthPercentageOrAuto::Auto
{
self.base.position.start.b = block_position
}

6
components/layout/display_list/background.rs
View file

@ -12,7 +12,7 @@ use style::computed_values::background_attachment::single_value::T as Background
use style::computed_values::background_clip::single_value::T as BackgroundClip;
use style::computed_values::background_origin::single_value::T as BackgroundOrigin;
use style::properties::style_structs::Background;
use style::values::computed::{BackgroundSize, LengthOrPercentageOrAuto};
use style::values::computed::{BackgroundSize, LengthPercentageOrAuto};
use style::values::generics::background::BackgroundSize as GenericBackgroundSize;
use style::values::generics::NonNegative;
use style::values::specified::background::BackgroundRepeatKeyword;
@ -88,7 +88,7 @@ fn compute_background_image_size(
(
GenericBackgroundSize::Explicit {
width,
height: NonNegative(LengthOrPercentageOrAuto::Auto),
height: NonNegative(LengthPercentageOrAuto::Auto),
},
_,
) => {
@ -98,7 +98,7 @@ fn compute_background_image_size(
},
(
GenericBackgroundSize::Explicit {
width: NonNegative(LengthOrPercentageOrAuto::Auto),
width: NonNegative(LengthPercentageOrAuto::Auto),
height,
},
_,

8
components/layout/display_list/gradient.rs
View file

@ -9,7 +9,7 @@ use app_units::Au;
use euclid::{Point2D, Size2D, Vector2D};
use style::properties::ComputedValues;
use style::values::computed::image::{EndingShape, LineDirection};
use style::values::computed::{Angle, GradientItem, LengthOrPercentage, Percentage, Position};
use style::values::computed::{Angle, GradientItem, LengthPercentage, Percentage, Position};
use style::values::generics::image::EndingShape as GenericEndingShape;
use style::values::generics::image::GradientItem as GenericGradientItem;
use style::values::generics::image::{Circle, Ellipse, ShapeExtent};
@ -107,14 +107,14 @@ fn convert_gradient_stops(
{
let first = stop_items.first_mut().unwrap();
if first.position.is_none() {
first.position = Some(LengthOrPercentage::new_percent(Percentage(0.)));
first.position = Some(LengthPercentage::new_percent(Percentage(0.)));
}
}
// If the last color stop does not have a position, set its position to 100%.
{
let last = stop_items.last_mut().unwrap();
if last.position.is_none() {
last.position = Some(LengthOrPercentage::new_percent(Percentage(1.0)));
last.position = Some(LengthPercentage::new_percent(Percentage(1.0)));
}
}
@ -210,7 +210,7 @@ where
Size2D::new(cmp(left_side, right_side), cmp(top_side, bottom_side))
}
fn position_to_offset(position: LengthOrPercentage, total_length: Au) -> f32 {
fn position_to_offset(position: LengthPercentage, total_length: Au) -> f32 {
if total_length == Au(0) {
return 0.0;
}

30
components/layout/flex.rs
View file

@ -29,7 +29,7 @@ use style::properties::ComputedValues;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::values::computed::flex::FlexBasis;
use style::values::computed::{
LengthOrPercentage, LengthOrPercentageOrAuto, LengthOrPercentageOrNone,
LengthPercentage, LengthPercentageOrAuto, LengthPercentageOrNone,
};
use style::values::generics::flex::FlexBasis as GenericFlexBasis;
@ -46,16 +46,16 @@ impl AxisSize {
/// Generate a new available cross or main axis size from the specified size of the container,
/// containing block size, min constraint, and max constraint
pub fn new(
size: LengthOrPercentageOrAuto,
size: LengthPercentageOrAuto,
content_size: Option<Au>,
min: LengthOrPercentage,
max: LengthOrPercentageOrNone,
min: LengthPercentage,
max: LengthPercentageOrNone,
) -> AxisSize {
match size {
LengthOrPercentageOrAuto::Auto => {
LengthPercentageOrAuto::Auto => {
AxisSize::MinMax(SizeConstraint::new(content_size, min, max, None))
}
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
match lp.maybe_to_used_value(content_size) {
Some(length) => AxisSize::Definite(length),
None => AxisSize::Infinite,
@ -71,7 +71,7 @@ impl AxisSize {
/// is definite after flex size resolving.
fn from_flex_basis(
flex_basis: FlexBasis,
main_length: LengthOrPercentageOrAuto,
main_length: LengthPercentageOrAuto,
containing_length: Au,
) -> MaybeAuto {
let width = match flex_basis {
@ -80,7 +80,7 @@ fn from_flex_basis(
};
match width.0 {
LengthOrPercentageOrAuto::Auto => MaybeAuto::from_style(main_length, containing_length),
LengthPercentageOrAuto::Auto => MaybeAuto::from_style(main_length, containing_length),
other => MaybeAuto::from_style(other, containing_length),
}
}
@ -141,7 +141,7 @@ impl FlexItem {
let block = flow.as_mut_block();
match direction {
// TODO(stshine): the definition of min-{width, height} in style component
// should change to LengthOrPercentageOrAuto for automatic implied minimal size.
// should change to LengthPercentageOrAuto for automatic implied minimal size.
// https://drafts.csswg.org/css-flexbox-1/#min-size-auto
Direction::Inline => {
let basis = from_flex_basis(
@ -225,18 +225,18 @@ impl FlexItem {
let mut margin_count = 0;
match direction {
Direction::Inline => {
if margin.inline_start == LengthOrPercentageOrAuto::Auto {
if margin.inline_start == LengthPercentageOrAuto::Auto {
margin_count += 1;
}
if margin.inline_end == LengthOrPercentageOrAuto::Auto {
if margin.inline_end == LengthPercentageOrAuto::Auto {
margin_count += 1;
}
},
Direction::Block => {
if margin.block_start == LengthOrPercentageOrAuto::Auto {
if margin.block_start == LengthPercentageOrAuto::Auto {
margin_count += 1;
}
if margin.block_end == LengthOrPercentageOrAuto::Auto {
if margin.block_end == LengthPercentageOrAuto::Auto {
margin_count += 1;
}
},
@ -819,7 +819,7 @@ impl FlexFlow {
// cross size of item should equal to the line size if any auto margin exists.
// https://drafts.csswg.org/css-flexbox/#algo-cross-margins
if auto_margin_count > 0 {
if margin.block_start == LengthOrPercentageOrAuto::Auto {
if margin.block_start == LengthPercentageOrAuto::Auto {
margin_block_start = if free_space < Au(0) {
Au(0)
} else {
@ -833,7 +833,7 @@ impl FlexFlow {
let self_align = block.fragment.style().get_position().align_self;
if self_align == AlignSelf::Stretch &&
block.fragment.style().content_block_size() == LengthOrPercentageOrAuto::Auto
block.fragment.style().content_block_size() == LengthPercentageOrAuto::Auto
{
free_space = Au(0);
block.base.block_container_explicit_block_size = Some(line.cross_size);

6
components/layout/floats.rs
View file

@ -10,7 +10,7 @@ use std::cmp::{max, min};
use std::fmt;
use style::computed_values::float::T as StyleFloat;
use style::logical_geometry::{LogicalRect, LogicalSize, WritingMode};
use style::values::computed::LengthOrPercentageOrAuto;
use style::values::computed::LengthPercentageOrAuto;
/// The kind of float: left or right.
#[derive(Clone, Copy, Debug, Serialize)]
@ -550,8 +550,8 @@ impl SpeculatedFloatPlacement {
let inline_size =
flow.as_block().fragment.style.content_inline_size();
let fixed = match inline_size {
LengthOrPercentageOrAuto::Auto => false,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => false,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.is_definitely_zero() || lp.maybe_to_used_value(None).is_some()
}
};

18
components/layout/flow.rs
View file

@ -67,7 +67,7 @@ use style::logical_geometry::{LogicalRect, LogicalSize, WritingMode};
use style::properties::ComputedValues;
use style::selector_parser::RestyleDamage;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::values::computed::LengthOrPercentageOrAuto;
use style::values::computed::LengthPercentageOrAuto;
use webrender_api::LayoutTransform;
/// This marker trait indicates that a type is a struct with `#[repr(C)]` whose first field
@ -1068,13 +1068,13 @@ impl BaseFlow {
flags.insert(FlowFlags::IS_ABSOLUTELY_POSITIONED);
let logical_position = style.logical_position();
if logical_position.inline_start == LengthOrPercentageOrAuto::Auto &&
logical_position.inline_end == LengthOrPercentageOrAuto::Auto
if logical_position.inline_start == LengthPercentageOrAuto::Auto &&
logical_position.inline_end == LengthPercentageOrAuto::Auto
{
flags.insert(FlowFlags::INLINE_POSITION_IS_STATIC);
}
if logical_position.block_start == LengthOrPercentageOrAuto::Auto &&
logical_position.block_end == LengthOrPercentageOrAuto::Auto
if logical_position.block_start == LengthPercentageOrAuto::Auto &&
logical_position.block_end == LengthPercentageOrAuto::Auto
{
flags.insert(FlowFlags::BLOCK_POSITION_IS_STATIC);
}
@ -1161,13 +1161,13 @@ impl BaseFlow {
let logical_position = style.logical_position();
self.flags.set(
FlowFlags::INLINE_POSITION_IS_STATIC,
logical_position.inline_start == LengthOrPercentageOrAuto::Auto &&
logical_position.inline_end == LengthOrPercentageOrAuto::Auto,
logical_position.inline_start == LengthPercentageOrAuto::Auto &&
logical_position.inline_end == LengthPercentageOrAuto::Auto,
);
self.flags.set(
FlowFlags::BLOCK_POSITION_IS_STATIC,
logical_position.block_start == LengthOrPercentageOrAuto::Auto &&
logical_position.block_end == LengthOrPercentageOrAuto::Auto,
logical_position.block_start == LengthPercentageOrAuto::Auto &&
logical_position.block_end == LengthPercentageOrAuto::Auto,
);
}
}

18
components/layout/fragment.rs
View file

@ -61,7 +61,7 @@ use style::selector_parser::RestyleDamage;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::str::char_is_whitespace;
use style::values::computed::counters::ContentItem;
use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto};
use style::values::computed::{LengthPercentage, LengthPercentageOrAuto};
use style::values::generics::box_::{Perspective, VerticalAlign};
use style::values::generics::transform;
use webrender_api::{self, LayoutTransform};
@ -1448,14 +1448,14 @@ impl Fragment {
pub fn relative_position(&self, containing_block_size: &LogicalSize<Au>) -> LogicalSize<Au> {
fn from_style(style: &ComputedValues, container_size: &LogicalSize<Au>) -> LogicalSize<Au> {
let offsets = style.logical_position();
let offset_i = if offsets.inline_start != LengthOrPercentageOrAuto::Auto {
let offset_i = if offsets.inline_start != LengthPercentageOrAuto::Auto {
MaybeAuto::from_style(offsets.inline_start, container_size.inline)
.specified_or_zero()
} else {
-MaybeAuto::from_style(offsets.inline_end, container_size.inline)
.specified_or_zero()
};
let offset_b = if offsets.block_start != LengthOrPercentageOrAuto::Auto {
let offset_b = if offsets.block_start != LengthPercentageOrAuto::Auto {
MaybeAuto::from_style(offsets.block_start, container_size.block).specified_or_zero()
} else {
-MaybeAuto::from_style(offsets.block_end, container_size.block).specified_or_zero()
@ -1611,8 +1611,8 @@ impl Fragment {
SpecificFragmentInfo::Iframe(_) |
SpecificFragmentInfo::Svg(_) => {
let inline_size = match self.style.content_inline_size() {
LengthOrPercentageOrAuto::Auto => None,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => None,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(None)
}
};
@ -2510,12 +2510,12 @@ impl Fragment {
continue;
}
if inline_context_node.style.logical_margin().inline_end !=
LengthOrPercentageOrAuto::zero()
LengthPercentageOrAuto::zero()
{
return false;
}
if inline_context_node.style.logical_padding().inline_end !=
LengthOrPercentage::zero()
LengthPercentage::zero()
{
return false;
}
@ -2536,12 +2536,12 @@ impl Fragment {
continue;
}
if inline_context_node.style.logical_margin().inline_start !=
LengthOrPercentageOrAuto::zero()
LengthPercentageOrAuto::zero()
{
return false;
}
if inline_context_node.style.logical_padding().inline_start !=
LengthOrPercentage::zero()
LengthPercentage::zero()
{
return false;
}

28
components/layout/model.rs
View file

@ -11,8 +11,8 @@ use std::cmp::{max, min};
use std::fmt;
use style::logical_geometry::{LogicalMargin, WritingMode};
use style::properties::ComputedValues;
use style::values::computed::LengthOrPercentageOrNone;
use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto};
use style::values::computed::LengthPercentageOrNone;
use style::values::computed::{LengthPercentage, LengthPercentageOrAuto};
/// A collapsible margin. See CSS 2.1 § 8.3.1.
#[derive(Clone, Copy, Debug)]
@ -135,8 +135,8 @@ impl MarginCollapseInfo {
MarginCollapseState::AccumulatingCollapsibleTopMargin => {
may_collapse_through = may_collapse_through &&
match fragment.style().content_block_size() {
LengthOrPercentageOrAuto::Auto => true,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => true,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.is_definitely_zero() ||
lp.maybe_to_used_value(containing_block_size).is_none()
},
@ -435,10 +435,10 @@ pub enum MaybeAuto {
impl MaybeAuto {
#[inline]
pub fn from_style(length: LengthOrPercentageOrAuto, containing_length: Au) -> MaybeAuto {
pub fn from_style(length: LengthPercentageOrAuto, containing_length: Au) -> MaybeAuto {
match length {
LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
MaybeAuto::Specified(lp.to_used_value(containing_length))
},
}
@ -498,12 +498,12 @@ impl MaybeAuto {
///
/// `style_length`: content size as given in the CSS.
pub fn style_length(
style_length: LengthOrPercentageOrAuto,
style_length: LengthPercentageOrAuto,
container_size: Option<Au>,
) -> MaybeAuto {
match style_length {
LengthOrPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => MaybeAuto::Auto,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
MaybeAuto::from_option(lp.maybe_to_used_value(container_size))
}
}
@ -570,16 +570,16 @@ impl SizeConstraint {
/// Create a `SizeConstraint` for an axis.
pub fn new(
container_size: Option<Au>,
min_size: LengthOrPercentage,
max_size: LengthOrPercentageOrNone,
min_size: LengthPercentage,
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 max_size = match max_size {
LengthOrPercentageOrNone::None => None,
LengthOrPercentageOrNone::LengthOrPercentage(ref lp) => {
LengthPercentageOrNone::None => None,
LengthPercentageOrNone::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(container_size)
},
};

10
components/layout/multicol.rs
View file

@ -19,7 +19,7 @@ use std::fmt;
use std::sync::Arc;
use style::logical_geometry::LogicalSize;
use style::properties::ComputedValues;
use style::values::computed::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone};
use style::values::computed::{LengthPercentageOrAuto, LengthPercentageOrNone};
use style::values::generics::column::ColumnCount;
use style::values::Either;
@ -155,15 +155,15 @@ impl Flow for MulticolFlow {
available_block_size: {
let style = &self.block_flow.fragment.style;
let size = match style.content_block_size() {
LengthOrPercentageOrAuto::Auto => None,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => None,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(None)
}
};
let size = size.or_else(|| {
match style.max_block_size() {
LengthOrPercentageOrNone::None => None,
LengthOrPercentageOrNone::LengthOrPercentage(ref lp) => {
LengthPercentageOrNone::None => None,
LengthPercentageOrNone::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(None)
}
}

10
components/layout/table.rs
View file

@ -33,7 +33,7 @@ use style::logical_geometry::LogicalSize;
use style::properties::style_structs::Background;
use style::properties::ComputedValues;
use style::servo::restyle_damage::ServoRestyleDamage;
use style::values::computed::LengthOrPercentageOrAuto;
use style::values::computed::LengthPercentageOrAuto;
use style::values::CSSFloat;
#[allow(unsafe_code)]
@ -301,14 +301,14 @@ impl Flow for TableFlow {
self.column_intrinsic_inline_sizes
.push(ColumnIntrinsicInlineSize {
minimum_length: match *specified_inline_size {
LengthOrPercentageOrAuto::Auto => Au(0),
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => Au(0),
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(None).unwrap_or(Au(0))
},
},
percentage: match *specified_inline_size {
LengthOrPercentageOrAuto::Auto => 0.0,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => 0.0,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.as_percentage().map_or(0.0, |p| p.0)
},
},

6
components/layout/table_colgroup.rs
View file

@ -14,7 +14,7 @@ use euclid::Point2D;
use std::fmt;
use style::logical_geometry::LogicalSize;
use style::properties::ComputedValues;
use style::values::computed::LengthOrPercentageOrAuto;
use style::values::computed::LengthPercentageOrAuto;
#[allow(unsafe_code)]
unsafe impl crate::flow::HasBaseFlow for TableColGroupFlow {}
@ -31,10 +31,10 @@ pub struct TableColGroupFlow {
/// The table column fragments
pub cols: Vec<Fragment>,
/// The specified inline-sizes of table columns. (We use `LengthOrPercentageOrAuto` here in
/// The specified inline-sizes of table columns. (We use `LengthPercentageOrAuto` here in
/// lieu of `ColumnInlineSize` because column groups do not establish minimum or preferred
/// inline sizes.)
pub inline_sizes: Vec<LengthOrPercentageOrAuto>,
pub inline_sizes: Vec<LengthPercentageOrAuto>,
}
impl TableColGroupFlow {

14
components/layout/table_row.rs
View file

@ -29,7 +29,7 @@ use style::computed_values::border_spacing::T as BorderSpacing;
use style::computed_values::border_top_style::T as BorderStyle;
use style::logical_geometry::{LogicalSize, PhysicalSide, WritingMode};
use style::properties::ComputedValues;
use style::values::computed::{Color, LengthOrPercentageOrAuto};
use style::values::computed::{Color, LengthPercentageOrAuto};
#[allow(unsafe_code)]
unsafe impl crate::flow::HasBaseFlow for TableRowFlow {}
@ -430,22 +430,22 @@ impl Flow for TableRowFlow {
let child_base = kid.mut_base();
let child_column_inline_size = ColumnIntrinsicInlineSize {
minimum_length: match child_specified_inline_size {
LengthOrPercentageOrAuto::Auto => None,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => None,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(None)
},
}
.unwrap_or(child_base.intrinsic_inline_sizes.minimum_inline_size),
percentage: match child_specified_inline_size {
LengthOrPercentageOrAuto::Auto => 0.0,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => 0.0,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.as_percentage().map_or(0.0, |p| p.0)
},
},
preferred: child_base.intrinsic_inline_sizes.preferred_inline_size,
constrained: match child_specified_inline_size {
LengthOrPercentageOrAuto::Auto => false,
LengthOrPercentageOrAuto::LengthOrPercentage(ref lp) => {
LengthPercentageOrAuto::Auto => false,
LengthPercentageOrAuto::LengthPercentage(ref lp) => {
lp.maybe_to_used_value(None).is_some()
},
},

4
components/layout/table_wrapper.rs
View file

@ -35,7 +35,7 @@ use style::computed_values::{position, table_layout};
use style::context::SharedStyleContext;
use style::logical_geometry::{LogicalRect, LogicalSize};
use style::properties::ComputedValues;
use style::values::computed::LengthOrPercentageOrAuto;
use style::values::computed::LengthPercentageOrAuto;
use style::values::CSSFloat;
#[derive(Clone, Copy, Debug, Serialize)]
@ -203,7 +203,7 @@ impl TableWrapperFlow {
// says "the basic idea is the same as the shrink-to-fit width that CSS2.1 defines". So we
// just use the shrink-to-fit inline size.
let available_inline_size = match self.block_flow.fragment.style().content_inline_size() {
LengthOrPercentageOrAuto::Auto => {
LengthPercentageOrAuto::Auto => {
self.block_flow
.get_shrink_to_fit_inline_size(available_inline_size) -
table_border_padding

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

@ -718,8 +718,8 @@ impl LayoutElementHelpers for LayoutDom<Element> {
specified::NoCalcLength::ServoCharacterWidth(specified::CharacterWidth(size));
hints.push(from_declaration(
shared_lock,
PropertyDeclaration::Width(specified::LengthOrPercentageOrAuto::LengthOrPercentage(
specified::LengthOrPercentage::Length(value)
PropertyDeclaration::Width(specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Length(value)
)),
));
}
@ -745,8 +745,8 @@ impl LayoutElementHelpers for LayoutDom<Element> {
match width {
LengthOrPercentageOrAuto::Auto => {},
LengthOrPercentageOrAuto::Percentage(percentage) => {
let width_value = specified::LengthOrPercentageOrAuto::LengthOrPercentage(
specified::LengthOrPercentage::Percentage(
let width_value = specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Percentage(
computed::Percentage(percentage),
),
);
@ -757,8 +757,8 @@ impl LayoutElementHelpers for LayoutDom<Element> {
},
LengthOrPercentageOrAuto::Length(length) => {
let width_value =
specified::LengthOrPercentageOrAuto::LengthOrPercentage(
specified::LengthOrPercentage::Length(
specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Length(
specified::NoCalcLength::Absolute(
specified::AbsoluteLength::Px(length.to_f32_px()),
),
@ -784,8 +784,8 @@ impl LayoutElementHelpers for LayoutDom<Element> {
match height {
LengthOrPercentageOrAuto::Auto => {},
LengthOrPercentageOrAuto::Percentage(percentage) => {
let height_value = specified::LengthOrPercentageOrAuto::LengthOrPercentage(
specified::LengthOrPercentage::Percentage(
let height_value = specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Percentage(
computed::Percentage(percentage),
)
);
@ -796,8 +796,8 @@ impl LayoutElementHelpers for LayoutDom<Element> {
},
LengthOrPercentageOrAuto::Length(length) => {
let height_value =
specified::LengthOrPercentageOrAuto::LengthOrPercentage(
specified::LengthOrPercentage::Length(
specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Length(
specified::NoCalcLength::Absolute(
specified::AbsoluteLength::Px(length.to_f32_px()),
)
@ -829,8 +829,8 @@ impl LayoutElementHelpers for LayoutDom<Element> {
specified::NoCalcLength::ServoCharacterWidth(specified::CharacterWidth(cols));
hints.push(from_declaration(
shared_lock,
PropertyDeclaration::Width(specified::LengthOrPercentageOrAuto::LengthOrPercentage(
specified::LengthOrPercentage::Length(value)
PropertyDeclaration::Width(specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Length(value)
)),
));
}
@ -853,8 +853,8 @@ impl LayoutElementHelpers for LayoutDom<Element> {
));
hints.push(from_declaration(
shared_lock,
PropertyDeclaration::Height(specified::LengthOrPercentageOrAuto::LengthOrPercentage(
specified::LengthOrPercentage::Length(value)
PropertyDeclaration::Height(specified::LengthPercentageOrAuto::LengthPercentage(
specified::LengthPercentage::Length(value)
)),
));
}

4
tests/unit/style/parsing/inherited_text.rs
View file

@ -20,10 +20,10 @@ fn negative_letter_spacing_should_parse_properly() {
#[test]
fn negative_word_spacing_should_parse_properly() {
use style::properties::longhands::word_spacing;
use style::values::specified::length::{FontRelativeLength, LengthOrPercentage, NoCalcLength};
use style::values::specified::length::{FontRelativeLength, LengthPercentage, NoCalcLength};
let negative_value = parse_longhand!(word_spacing, "-0.5em");
let expected = Spacing::Value(LengthOrPercentage::Length(NoCalcLength::FontRelative(
let expected = Spacing::Value(LengthPercentage::Length(NoCalcLength::FontRelative(
FontRelativeLength::Em(-0.5),
)));
assert_eq!(negative_value, expected);

8
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::LengthOrPercentageOrAuto::{self, Auto};
use style::values::specified::LengthPercentageOrAuto::{self, Auto};
use style::values::specified::NoCalcLength::{self, ViewportPercentage};
use style::values::specified::ViewportPercentageLength::Vw;
use style::values::specified::LengthOrPercentage;
use style::values::specified::LengthPercentage;
use style_traits::viewport::*;
use style_traits::{ParsingMode, PinchZoomFactor};
@ -97,12 +97,12 @@ macro_rules! assert_decl_len {
macro_rules! viewport_length {
($value:expr, px) => {
ViewportLength::Specified(LengthOrPercentageOrAuto::LengthOrPercentage(LengthOrPercentage::Length(NoCalcLength::from_px(
ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::Length(NoCalcLength::from_px(
$value,
))))
};
($value:expr, vw) => {
ViewportLength::Specified(LengthOrPercentageOrAuto::LengthOrPercentage(LengthOrPercentage::Length(ViewportPercentage(Vw(
ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(LengthPercentage::Length(ViewportPercentage(Vw(
$value,
)))))
};