From c7f30ad0df187d72a5630fe0cdc48592b8db8930 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Mon, 7 Jan 2019 16:55:29 +0100 Subject: [PATCH] style: Fix servo build. --- components/layout/block.rs | 36 ++++++++++---------- components/layout/display_list/background.rs | 6 ++-- components/layout/display_list/gradient.rs | 8 ++--- components/layout/flex.rs | 30 ++++++++-------- components/layout/floats.rs | 6 ++-- components/layout/flow.rs | 18 +++++----- components/layout/fragment.rs | 18 +++++----- components/layout/model.rs | 28 +++++++-------- components/layout/multicol.rs | 10 +++--- components/layout/table.rs | 10 +++--- components/layout/table_colgroup.rs | 6 ++-- components/layout/table_row.rs | 14 ++++---- components/layout/table_wrapper.rs | 4 +-- components/script/dom/element.rs | 28 +++++++-------- tests/unit/style/parsing/inherited_text.rs | 4 +-- tests/unit/style/viewport.rs | 8 ++--- 16 files changed, 117 insertions(+), 117 deletions(-) diff --git a/components/layout/block.rs b/components/layout/block.rs index 5cf6597654f..db60a1ed579 100644 --- a/components/layout/block.rs +++ b/components/layout/block.rs @@ -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 } diff --git a/components/layout/display_list/background.rs b/components/layout/display_list/background.rs index 89d6aebb0db..d914a97e1bf 100644 --- a/components/layout/display_list/background.rs +++ b/components/layout/display_list/background.rs @@ -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, }, _, diff --git a/components/layout/display_list/gradient.rs b/components/layout/display_list/gradient.rs index f7fc834e8d8..db5208eadac 100644 --- a/components/layout/display_list/gradient.rs +++ b/components/layout/display_list/gradient.rs @@ -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; } diff --git a/components/layout/flex.rs b/components/layout/flex.rs index fbd01c14dca..807e3595265 100644 --- a/components/layout/flex.rs +++ b/components/layout/flex.rs @@ -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, - 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); diff --git a/components/layout/floats.rs b/components/layout/floats.rs index 9aa25f4e9b6..32aaccc9834 100644 --- a/components/layout/floats.rs +++ b/components/layout/floats.rs @@ -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() } }; diff --git a/components/layout/flow.rs b/components/layout/flow.rs index 2059fe35525..86bd6b74edf 100644 --- a/components/layout/flow.rs +++ b/components/layout/flow.rs @@ -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, ); } } diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs index 5560941aaa8..40f3c3f41b2 100644 --- a/components/layout/fragment.rs +++ b/components/layout/fragment.rs @@ -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) -> LogicalSize { fn from_style(style: &ComputedValues, container_size: &LogicalSize) -> LogicalSize { 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; } diff --git a/components/layout/model.rs b/components/layout/model.rs index a54e3a9b76e..3c7441d9282 100644 --- a/components/layout/model.rs +++ b/components/layout/model.rs @@ -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, ) -> 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, - min_size: LengthOrPercentage, - max_size: LengthOrPercentageOrNone, + min_size: LengthPercentage, + max_size: LengthPercentageOrNone, border: Option, ) -> 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) }, }; diff --git a/components/layout/multicol.rs b/components/layout/multicol.rs index e0234454b27..3f80055e9aa 100644 --- a/components/layout/multicol.rs +++ b/components/layout/multicol.rs @@ -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) } } diff --git a/components/layout/table.rs b/components/layout/table.rs index f492e9056ff..83d3552a988 100644 --- a/components/layout/table.rs +++ b/components/layout/table.rs @@ -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) }, }, diff --git a/components/layout/table_colgroup.rs b/components/layout/table_colgroup.rs index 28cdafea7ec..6bb5cbe620b 100644 --- a/components/layout/table_colgroup.rs +++ b/components/layout/table_colgroup.rs @@ -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, - /// 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, + pub inline_sizes: Vec, } impl TableColGroupFlow { diff --git a/components/layout/table_row.rs b/components/layout/table_row.rs index 52412d9a2d1..ca33eb2584e 100644 --- a/components/layout/table_row.rs +++ b/components/layout/table_row.rs @@ -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() }, }, diff --git a/components/layout/table_wrapper.rs b/components/layout/table_wrapper.rs index 94d7d2d32a0..f63cf3f28f0 100644 --- a/components/layout/table_wrapper.rs +++ b/components/layout/table_wrapper.rs @@ -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 diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs index 6feb6381b77..df00142a67d 100644 --- a/components/script/dom/element.rs +++ b/components/script/dom/element.rs @@ -718,8 +718,8 @@ impl LayoutElementHelpers for LayoutDom { 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 { 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 { }, 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 { 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 { }, 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 { 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 { )); hints.push(from_declaration( shared_lock, - PropertyDeclaration::Height(specified::LengthOrPercentageOrAuto::LengthOrPercentage( - specified::LengthOrPercentage::Length(value) + PropertyDeclaration::Height(specified::LengthPercentageOrAuto::LengthPercentage( + specified::LengthPercentage::Length(value) )), )); } diff --git a/tests/unit/style/parsing/inherited_text.rs b/tests/unit/style/parsing/inherited_text.rs index f7eea44e4f5..985e9ddf60c 100644 --- a/tests/unit/style/parsing/inherited_text.rs +++ b/tests/unit/style/parsing/inherited_text.rs @@ -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); diff --git a/tests/unit/style/viewport.rs b/tests/unit/style/viewport.rs index 41fc2539f39..219eb0e3723 100644 --- a/tests/unit/style/viewport.rs +++ b/tests/unit/style/viewport.rs @@ -14,10 +14,10 @@ use style::parser::ParserContext; use style::shared_lock::{SharedRwLock, StylesheetGuards}; use style::stylesheets::viewport_rule::*; use style::stylesheets::{CssRuleType, Origin, Stylesheet, StylesheetInDocument}; -use style::values::specified::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, ))))) };