From 6daebcc5dfc4e57d2f9e9450aa01b8c67dd34986 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Sun, 10 Feb 2019 06:48:00 +0100 Subject: [PATCH] Fix servo build. --- components/layout/block.rs | 47 ++++++++------- components/layout/display_list/background.rs | 38 +++++++------ components/layout/display_list/builder.rs | 10 ++-- components/layout/flex.rs | 41 +++++++------ components/layout/floats.rs | 8 +-- components/layout/fragment.rs | 14 +++-- components/layout/lib.rs | 1 + components/layout/model.rs | 31 +++++----- components/layout/multicol.rs | 12 ++-- components/layout/table.rs | 12 ++-- components/layout/table_cell.rs | 20 ++++--- components/layout/table_colgroup.rs | 4 +- components/layout/table_row.rs | 38 ++++++------- components/layout/table_wrapper.rs | 23 ++++---- components/script/devtools.rs | 9 ++- components/script/dom/element.rs | 60 ++++++++++++-------- components/script/lib.rs | 1 + tests/unit/style/viewport.rs | 11 ++-- 18 files changed, 210 insertions(+), 170 deletions(-) diff --git a/components/layout/block.rs b/components/layout/block.rs index 0e4bf140d42..3d19ed1072a 100644 --- a/components/layout/block.rs +++ b/components/layout/block.rs @@ -67,7 +67,9 @@ 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::{LengthPercentageOrAuto, LengthPercentageOrNone}; +use style::values::computed::{ + LengthPercentageOrAuto, MaxLength, NonNegativeLengthPercentageOrAuto, +}; /// Information specific to floated blocks. #[derive(Clone, Serialize)] @@ -419,15 +421,15 @@ impl CandidateBSizeIterator { // `min-height` and `max-height`, percentage values are ignored. let block_size = match fragment.style.content_block_size() { - LengthPercentageOrAuto::Auto => MaybeAuto::Auto, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { + NonNegativeLengthPercentageOrAuto::Auto => MaybeAuto::Auto, + NonNegativeLengthPercentageOrAuto::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() { - LengthPercentageOrNone::None => None, - LengthPercentageOrNone::LengthPercentage(ref lp) => { + MaxLength::None => None, + MaxLength::LengthPercentage(ref lp) => { lp.maybe_to_used_value(block_container_block_size) }, }; @@ -1400,7 +1402,7 @@ impl BlockFlow { let content_block_size = self.fragment.style().content_block_size(); match content_block_size { - LengthPercentageOrAuto::Auto => { + NonNegativeLengthPercentageOrAuto::Auto => { let container_size = containing_block_size?; let (block_start, block_end) = { let position = self.fragment.style().logical_position(); @@ -1435,7 +1437,7 @@ impl BlockFlow { (_, _) => None, } }, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { lp.maybe_to_used_value(containing_block_size) }, } @@ -1797,15 +1799,12 @@ impl BlockFlow { .to_used_value(self.base.block_container_inline_size); let specified_inline_size = self.fragment.style().content_inline_size(); let container_size = self.base.block_container_inline_size; - let inline_size = if let MaybeAuto::Specified(size) = - MaybeAuto::from_style(specified_inline_size, container_size) - { - match self.fragment.style().get_position().box_sizing { + let inline_size = match specified_inline_size.to_used_value(container_size) { + Some(size) => match self.fragment.style().get_position().box_sizing { BoxSizing::BorderBox => size, BoxSizing::ContentBox => size + self.fragment.border_padding.inline_start_end(), - } - } else { - max(min_inline_size, min(available_inline_size, max_inline_size)) + }, + None => max(min_inline_size, min(available_inline_size, max_inline_size)), }; self.base.position.size.inline = inline_size + self.fragment.margin.inline_start_end(); @@ -2026,7 +2025,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() != LengthPercentageOrNone::None { + if self.fragment.style.max_inline_size() != MaxLength::None { return; } @@ -2156,9 +2155,10 @@ impl Flow for BlockFlow { fn bubble_inline_sizes(&mut self) { // If this block has a fixed width, just use that for the minimum and preferred width, // rather than bubbling up children inline width. + // FIXME(emilio): This should probably be writing-mode-aware. let consult_children = match self.fragment.style().get_position().width { - LengthPercentageOrAuto::Auto => true, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { + NonNegativeLengthPercentageOrAuto::Auto => true, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { lp.maybe_to_used_value(None).is_none() }, }; @@ -2846,9 +2846,16 @@ pub trait ISizeAndMarginsComputer { parent_flow_inline_size: Au, shared_context: &SharedStyleContext, ) -> MaybeAuto { - MaybeAuto::from_style( - block.fragment().style().content_inline_size(), - self.containing_block_inline_size(block, parent_flow_inline_size, shared_context), + MaybeAuto::from_option( + block + .fragment() + .style() + .content_inline_size() + .to_used_value(self.containing_block_inline_size( + block, + parent_flow_inline_size, + shared_context, + )), ) } diff --git a/components/layout/display_list/background.rs b/components/layout/display_list/background.rs index d914a97e1bf..368818471d5 100644 --- a/components/layout/display_list/background.rs +++ b/components/layout/display_list/background.rs @@ -5,16 +5,14 @@ // FIXME(rust-lang/rust#26264): Remove GenericBackgroundSize. use crate::display_list::border; -use crate::model::MaybeAuto; use app_units::Au; use euclid::{Point2D, Rect, SideOffsets2D, Size2D}; use style::computed_values::background_attachment::single_value::T as BackgroundAttachment; 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, LengthPercentageOrAuto}; +use style::values::computed::{BackgroundSize, NonNegativeLengthPercentageOrAuto}; use style::values::generics::background::BackgroundSize as GenericBackgroundSize; -use style::values::generics::NonNegative; use style::values::specified::background::BackgroundRepeatKeyword; use webrender_api::BorderRadius; @@ -60,10 +58,12 @@ fn compute_background_image_size( None => match bg_size { GenericBackgroundSize::Cover | GenericBackgroundSize::Contain => bounds_size, GenericBackgroundSize::Explicit { width, height } => Size2D::new( - MaybeAuto::from_style(width.0, bounds_size.width) - .specified_or_default(bounds_size.width), - MaybeAuto::from_style(height.0, bounds_size.height) - .specified_or_default(bounds_size.height), + width + .to_used_value(bounds_size.width) + .unwrap_or(bounds_size.width), + height + .to_used_value(bounds_size.height) + .unwrap_or(bounds_size.height), ), }, Some(own_size) => { @@ -88,30 +88,34 @@ fn compute_background_image_size( ( GenericBackgroundSize::Explicit { width, - height: NonNegative(LengthPercentageOrAuto::Auto), + height: NonNegativeLengthPercentageOrAuto::Auto, }, _, ) => { - let width = MaybeAuto::from_style(width.0, bounds_size.width) - .specified_or_default(own_size.width); + let width = width + .to_used_value(bounds_size.width) + .unwrap_or(own_size.width); Size2D::new(width, width.scale_by(image_aspect_ratio.recip())) }, ( GenericBackgroundSize::Explicit { - width: NonNegative(LengthPercentageOrAuto::Auto), + width: NonNegativeLengthPercentageOrAuto::Auto, height, }, _, ) => { - let height = MaybeAuto::from_style(height.0, bounds_size.height) - .specified_or_default(own_size.height); + let height = height + .to_used_value(bounds_size.height) + .unwrap_or(own_size.height); Size2D::new(height.scale_by(image_aspect_ratio), height) }, (GenericBackgroundSize::Explicit { width, height }, _) => Size2D::new( - MaybeAuto::from_style(width.0, bounds_size.width) - .specified_or_default(own_size.width), - MaybeAuto::from_style(height.0, bounds_size.height) - .specified_or_default(own_size.height), + width + .to_used_value(bounds_size.width) + .unwrap_or(own_size.width), + height + .to_used_value(bounds_size.height) + .unwrap_or(own_size.height), ), } }, diff --git a/components/layout/display_list/builder.rs b/components/layout/display_list/builder.rs index e348086e39a..6de5ac8498c 100644 --- a/components/layout/display_list/builder.rs +++ b/components/layout/display_list/builder.rs @@ -764,10 +764,12 @@ impl Fragment { get_cyclic(&style.get_background().background_size.0, i).clone(); let size = match background_size { BackgroundSize::Explicit { width, height } => Size2D::new( - MaybeAuto::from_style(width.0, bounding_box_size.width) - .specified_or_default(bounding_box_size.width), - MaybeAuto::from_style(height.0, bounding_box_size.height) - .specified_or_default(bounding_box_size.height), + width + .to_used_value(bounding_box_size.width) + .unwrap_or(bounding_box_size.width), + height + .to_used_value(bounding_box_size.height) + .unwrap_or(bounding_box_size.height), ), _ => bounding_box_size, }; diff --git a/components/layout/flex.rs b/components/layout/flex.rs index fd85b0c24c1..770a02c594b 100644 --- a/components/layout/flex.rs +++ b/components/layout/flex.rs @@ -29,7 +29,9 @@ use style::logical_geometry::{Direction, LogicalSize}; use style::properties::ComputedValues; use style::servo::restyle_damage::ServoRestyleDamage; use style::values::computed::flex::FlexBasis; -use style::values::computed::{LengthPercentage, LengthPercentageOrAuto, LengthPercentageOrNone}; +use style::values::computed::{ + MaxLength, NonNegativeLengthPercentage, NonNegativeLengthPercentageOrAuto, +}; use style::values::generics::flex::FlexBasis as GenericFlexBasis; /// The size of an axis. May be a specified size, a min/max @@ -45,16 +47,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: LengthPercentageOrAuto, + size: NonNegativeLengthPercentageOrAuto, content_size: Option, - min: LengthPercentage, - max: LengthPercentageOrNone, + min: NonNegativeLengthPercentage, + max: MaxLength, ) -> AxisSize { match size { - LengthPercentageOrAuto::Auto => { + NonNegativeLengthPercentageOrAuto::Auto => { AxisSize::MinMax(SizeConstraint::new(content_size, min, max, None)) }, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { match lp.maybe_to_used_value(content_size) { Some(length) => AxisSize::Definite(length), None => AxisSize::Infinite, @@ -70,7 +72,7 @@ impl AxisSize { /// is definite after flex size resolving. fn from_flex_basis( flex_basis: FlexBasis, - main_length: LengthPercentageOrAuto, + main_length: NonNegativeLengthPercentageOrAuto, containing_length: Au, ) -> MaybeAuto { let width = match flex_basis { @@ -78,9 +80,16 @@ fn from_flex_basis( GenericFlexBasis::Width(width) => width, }; - match width.0 { - LengthPercentageOrAuto::Auto => MaybeAuto::from_style(main_length, containing_length), - other => MaybeAuto::from_style(other, containing_length), + let width = match width { + NonNegativeLengthPercentageOrAuto::Auto => main_length, + _ => width, + }; + + match width { + NonNegativeLengthPercentageOrAuto::Auto => MaybeAuto::Auto, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { + MaybeAuto::Specified(lp.to_used_value(containing_length)) + }, } } @@ -224,18 +233,18 @@ impl FlexItem { let mut margin_count = 0; match direction { Direction::Inline => { - if margin.inline_start == LengthPercentageOrAuto::Auto { + if margin.inline_start.is_auto() { margin_count += 1; } - if margin.inline_end == LengthPercentageOrAuto::Auto { + if margin.inline_end.is_auto() { margin_count += 1; } }, Direction::Block => { - if margin.block_start == LengthPercentageOrAuto::Auto { + if margin.block_start.is_auto() { margin_count += 1; } - if margin.block_end == LengthPercentageOrAuto::Auto { + if margin.block_end.is_auto() { margin_count += 1; } }, @@ -816,7 +825,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 == LengthPercentageOrAuto::Auto { + if margin.block_start.is_auto() { margin_block_start = if free_space < Au(0) { Au(0) } else { @@ -830,7 +839,7 @@ impl FlexFlow { let self_align = block.fragment.style().get_position().align_self; if self_align == AlignSelf::Stretch && - block.fragment.style().content_block_size() == LengthPercentageOrAuto::Auto + block.fragment.style().content_block_size().is_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 5a58e27f9d1..e3274c1ed91 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::LengthPercentageOrAuto; +use style::values::computed::NonNegativeLengthPercentageOrAuto; /// The kind of float: left or right. #[derive(Clone, Copy, Debug, Serialize)] @@ -549,9 +549,9 @@ impl SpeculatedFloatPlacement { // might flow around this float. let inline_size = flow.as_block().fragment.style.content_inline_size(); let fixed = match inline_size { - LengthPercentageOrAuto::Auto => false, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { - lp.is_definitely_zero() || lp.maybe_to_used_value(None).is_some() + NonNegativeLengthPercentageOrAuto::Auto => false, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { + lp.0.is_definitely_zero() || lp.0.maybe_to_used_value(None).is_some() }, }; if !fixed { diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs index db4fd8f4625..1efd40003e6 100644 --- a/components/layout/fragment.rs +++ b/components/layout/fragment.rs @@ -61,7 +61,9 @@ 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::{LengthPercentage, LengthPercentageOrAuto}; +use style::values::computed::{ + LengthPercentage, LengthPercentageOrAuto, NonNegativeLengthPercentageOrAuto, +}; use style::values::generics::box_::{Perspective, VerticalAlign}; use style::values::generics::transform; use webrender_api::{self, LayoutTransform}; @@ -985,8 +987,10 @@ impl Fragment { if flags.contains( QuantitiesIncludedInIntrinsicInlineSizes::INTRINSIC_INLINE_SIZE_INCLUDES_SPECIFIED, ) { - specified = - MaybeAuto::from_style(style.content_inline_size(), Au(0)).specified_or_zero(); + specified = style + .content_inline_size() + .to_used_value(Au(0)) + .unwrap_or(Au(0)); specified = max(style.min_inline_size().to_used_value(Au(0)), specified); if let Some(max) = style.max_inline_size().to_used_value(Au(0)) { specified = min(specified, max) @@ -1611,8 +1615,8 @@ impl Fragment { SpecificFragmentInfo::Iframe(_) | SpecificFragmentInfo::Svg(_) => { let inline_size = match self.style.content_inline_size() { - LengthPercentageOrAuto::Auto => None, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { + NonNegativeLengthPercentageOrAuto::Auto => None, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { lp.maybe_to_used_value(None) }, }; diff --git a/components/layout/lib.rs b/components/layout/lib.rs index f8afdc79190..974ef7c803b 100644 --- a/components/layout/lib.rs +++ b/components/layout/lib.rs @@ -3,6 +3,7 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ #![deny(unsafe_code)] +#![feature(type_alias_enum_variants)] #[macro_use] extern crate bitflags; diff --git a/components/layout/model.rs b/components/layout/model.rs index 0650c8887a1..b5a79d8a383 100644 --- a/components/layout/model.rs +++ b/components/layout/model.rs @@ -11,8 +11,10 @@ use std::cmp::{max, min}; use std::fmt; use style::logical_geometry::{LogicalMargin, WritingMode}; use style::properties::ComputedValues; -use style::values::computed::LengthPercentageOrNone; -use style::values::computed::{LengthPercentage, LengthPercentageOrAuto}; +use style::values::computed::MaxLength; +use style::values::computed::{ + LengthPercentageOrAuto, NonNegativeLengthPercentage, NonNegativeLengthPercentageOrAuto, +}; /// A collapsible margin. See CSS 2.1 ยง 8.3.1. #[derive(Clone, Copy, Debug)] @@ -135,8 +137,8 @@ impl MarginCollapseInfo { MarginCollapseState::AccumulatingCollapsibleTopMargin => { may_collapse_through = may_collapse_through && match fragment.style().content_block_size() { - LengthPercentageOrAuto::Auto => true, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { + NonNegativeLengthPercentageOrAuto::Auto => true, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { lp.is_definitely_zero() || lp.maybe_to_used_value(containing_block_size).is_none() }, @@ -496,11 +498,14 @@ impl MaybeAuto { /// Receive an optional container size and return used value for width or height. /// /// `style_length`: content size as given in the CSS. -pub fn style_length(style_length: LengthPercentageOrAuto, container_size: Option) -> MaybeAuto { +pub fn style_length( + style_length: NonNegativeLengthPercentageOrAuto, + container_size: Option, +) -> MaybeAuto { match style_length { - LengthPercentageOrAuto::Auto => MaybeAuto::Auto, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { - MaybeAuto::from_option(lp.maybe_to_used_value(container_size)) + NonNegativeLengthPercentageOrAuto::Auto => MaybeAuto::Auto, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { + MaybeAuto::from_option(lp.0.maybe_to_used_value(container_size)) }, } } @@ -566,8 +571,8 @@ impl SizeConstraint { /// Create a `SizeConstraint` for an axis. pub fn new( container_size: Option, - min_size: LengthPercentage, - max_size: LengthPercentageOrNone, + min_size: NonNegativeLengthPercentage, + max_size: MaxLength, border: Option, ) -> SizeConstraint { let mut min_size = min_size @@ -575,10 +580,8 @@ impl SizeConstraint { .unwrap_or(Au(0)); let mut max_size = match max_size { - LengthPercentageOrNone::None => None, - LengthPercentageOrNone::LengthPercentage(ref lp) => { - lp.maybe_to_used_value(container_size) - }, + MaxLength::None => None, + MaxLength::LengthPercentage(ref lp) => lp.maybe_to_used_value(container_size), }; // Make sure max size is not smaller than min size. diff --git a/components/layout/multicol.rs b/components/layout/multicol.rs index 14ea36626f9..feb267103b0 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::{LengthPercentageOrAuto, LengthPercentageOrNone}; +use style::values::computed::{MaxLength, NonNegativeLengthPercentageOrAuto}; use style::values::generics::column::ColumnCount; use style::values::Either; @@ -155,16 +155,14 @@ impl Flow for MulticolFlow { available_block_size: { let style = &self.block_flow.fragment.style; let size = match style.content_block_size() { - LengthPercentageOrAuto::Auto => None, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { + NonNegativeLengthPercentageOrAuto::Auto => None, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { lp.maybe_to_used_value(None) }, }; let size = size.or_else(|| match style.max_block_size() { - LengthPercentageOrNone::None => None, - LengthPercentageOrNone::LengthPercentage(ref lp) => { - lp.maybe_to_used_value(None) - }, + MaxLength::None => None, + MaxLength::LengthPercentage(ref lp) => lp.maybe_to_used_value(None), }); size.unwrap_or_else(|| { diff --git a/components/layout/table.rs b/components/layout/table.rs index f7bf902e452..7aa8f2a89d4 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::LengthPercentageOrAuto; +use style::values::computed::NonNegativeLengthPercentageOrAuto; use style::values::CSSFloat; #[allow(unsafe_code)] @@ -301,15 +301,15 @@ impl Flow for TableFlow { self.column_intrinsic_inline_sizes .push(ColumnIntrinsicInlineSize { minimum_length: match *specified_inline_size { - LengthPercentageOrAuto::Auto => Au(0), - LengthPercentageOrAuto::LengthPercentage(ref lp) => { + NonNegativeLengthPercentageOrAuto::Auto => Au(0), + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { lp.maybe_to_used_value(None).unwrap_or(Au(0)) }, }, percentage: match *specified_inline_size { - LengthPercentageOrAuto::Auto => 0.0, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { - lp.as_percentage().map_or(0.0, |p| p.0) + NonNegativeLengthPercentageOrAuto::Auto => 0.0, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { + lp.0.as_percentage().map_or(0.0, |p| p.0) }, }, preferred: Au(0), diff --git a/components/layout/table_cell.rs b/components/layout/table_cell.rs index d72a6670576..3bcc39f0193 100644 --- a/components/layout/table_cell.rs +++ b/components/layout/table_cell.rs @@ -12,7 +12,6 @@ use crate::display_list::{ use crate::flow::{Flow, FlowClass, FlowFlags, GetBaseFlow, OpaqueFlow}; use crate::fragment::{Fragment, FragmentBorderBoxIterator, Overflow}; use crate::layout_debug; -use crate::model::MaybeAuto; use crate::table::InternalTable; use crate::table_row::{CollapsedBorder, CollapsedBorderProvenance}; use app_units::Au; @@ -22,6 +21,7 @@ use script_layout_interface::wrapper_traits::ThreadSafeLayoutNode; use std::fmt; use style::logical_geometry::{LogicalMargin, LogicalRect, LogicalSize, WritingMode}; use style::properties::ComputedValues; +use style::values::computed::length::NonNegativeLengthPercentageOrAuto; use style::values::computed::Color; use style::values::generics::box_::VerticalAlign; use style::values::specified::BorderStyle; @@ -162,8 +162,12 @@ impl TableCellFlow { // Call after block size calculation pub fn total_block_size(&mut self) -> Au { // TODO: Percentage block-size - let specified = MaybeAuto::from_style(self.fragment().style().content_block_size(), Au(0)) - .specified_or_zero(); + let specified = self + .fragment() + .style() + .content_block_size() + .to_used_value(Au(0)) + .unwrap_or(Au(0)); specified + self.fragment().border_padding.block_start_end() } } @@ -198,11 +202,11 @@ impl Flow for TableCellFlow { ); self.block_flow.bubble_inline_sizes_for_block(true); - let specified_inline_size = MaybeAuto::from_style( - self.block_flow.fragment.style().content_inline_size(), - Au(0), - ) - .specified_or_zero(); + let specified_inline_size = match self.block_flow.fragment.style().content_inline_size() { + NonNegativeLengthPercentageOrAuto::Auto => Au(0), + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => lp.to_used_value(Au(0)), + }; + if self .block_flow .base diff --git a/components/layout/table_colgroup.rs b/components/layout/table_colgroup.rs index 6bb5cbe620b..1097d6dae38 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::LengthPercentageOrAuto; +use style::values::computed::NonNegativeLengthPercentageOrAuto; #[allow(unsafe_code)] unsafe impl crate::flow::HasBaseFlow for TableColGroupFlow {} @@ -34,7 +34,7 @@ pub struct TableColGroupFlow { /// 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 22db572c166..78768f5a1ab 100644 --- a/components/layout/table_row.rs +++ b/components/layout/table_row.rs @@ -15,7 +15,6 @@ use crate::flow::{ use crate::flow_list::MutFlowListIterator; use crate::fragment::{Fragment, FragmentBorderBoxIterator, Overflow}; use crate::layout_debug; -use crate::model::MaybeAuto; use crate::table::{ColumnComputedInlineSize, ColumnIntrinsicInlineSize, InternalTable, VecExt}; use crate::table_cell::{CollapsedBordersForCell, TableCellFlow}; use app_units::Au; @@ -30,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, LengthPercentageOrAuto}; +use style::values::computed::{Color, NonNegativeLengthPercentageOrAuto}; #[allow(unsafe_code)] unsafe impl crate::flow::HasBaseFlow for TableRowFlow {} @@ -208,16 +207,15 @@ impl TableRowFlow { &mut max_block_size, ); - let mut block_size = max_block_size; // TODO: Percentage block-size - block_size = match MaybeAuto::from_style( - self.block_flow.fragment.style().content_block_size(), - Au(0), - ) { - MaybeAuto::Auto => block_size, - MaybeAuto::Specified(value) => max(value, block_size), - }; - block_size + let block_size = self + .block_flow + .fragment + .style() + .content_block_size() + .to_used_value(Au(0)) + .unwrap_or(max_block_size); + max(block_size, max_block_size) } pub fn assign_block_size_to_self_and_children( @@ -431,23 +429,23 @@ impl Flow for TableRowFlow { let child_base = kid.mut_base(); let child_column_inline_size = ColumnIntrinsicInlineSize { minimum_length: match child_specified_inline_size { - LengthPercentageOrAuto::Auto => None, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { - lp.maybe_to_used_value(None) + NonNegativeLengthPercentageOrAuto::Auto => None, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { + lp.0.maybe_to_used_value(None) }, } .unwrap_or(child_base.intrinsic_inline_sizes.minimum_inline_size), percentage: match child_specified_inline_size { - LengthPercentageOrAuto::Auto => 0.0, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { - lp.as_percentage().map_or(0.0, |p| p.0) + NonNegativeLengthPercentageOrAuto::Auto => 0.0, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { + lp.0.as_percentage().map_or(0.0, |p| p.0) }, }, preferred: child_base.intrinsic_inline_sizes.preferred_inline_size, constrained: match child_specified_inline_size { - LengthPercentageOrAuto::Auto => false, - LengthPercentageOrAuto::LengthPercentage(ref lp) => { - lp.maybe_to_used_value(None).is_some() + NonNegativeLengthPercentageOrAuto::Auto => false, + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { + lp.0.maybe_to_used_value(None).is_some() }, }, }; diff --git a/components/layout/table_wrapper.rs b/components/layout/table_wrapper.rs index 9e8f137e70a..b63da7d56e5 100644 --- a/components/layout/table_wrapper.rs +++ b/components/layout/table_wrapper.rs @@ -33,7 +33,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::LengthPercentageOrAuto; +use style::values::computed::NonNegativeLengthPercentageOrAuto; use style::values::CSSFloat; #[derive(Clone, Copy, Debug, Serialize)] @@ -201,7 +201,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() { - LengthPercentageOrAuto::Auto => { + NonNegativeLengthPercentageOrAuto::Auto => { self.block_flow .get_shrink_to_fit_inline_size(available_inline_size) - table_border_padding @@ -840,12 +840,8 @@ fn initial_computed_inline_size( preferred_width_of_all_columns: Au, table_border_padding: Au, ) -> MaybeAuto { - let inline_size_from_style = MaybeAuto::from_style( - block.fragment.style.content_inline_size(), - containing_block_inline_size, - ); - match inline_size_from_style { - MaybeAuto::Auto => { + match block.fragment.style.content_inline_size() { + NonNegativeLengthPercentageOrAuto::Auto => { if preferred_width_of_all_columns + table_border_padding <= containing_block_inline_size { MaybeAuto::Specified(preferred_width_of_all_columns + table_border_padding) @@ -855,10 +851,13 @@ fn initial_computed_inline_size( MaybeAuto::Auto } }, - MaybeAuto::Specified(inline_size_from_style) => MaybeAuto::Specified(max( - inline_size_from_style - table_border_padding, - minimum_width_of_all_columns, - )), + NonNegativeLengthPercentageOrAuto::LengthPercentage(ref lp) => { + let used = lp.to_used_value(containing_block_inline_size); + MaybeAuto::Specified(max( + used - table_border_padding, + minimum_width_of_all_columns, + )) + }, } } diff --git a/components/script/devtools.rs b/components/script/devtools.rs index 58b0a7d20a7..7a24d959980 100644 --- a/components/script/devtools.rs +++ b/components/script/devtools.rs @@ -29,7 +29,6 @@ use js::rust::wrappers::ObjectClassName; use msg::constellation_msg::PipelineId; use std::ffi::CStr; use std::str; -use style::properties::longhands::{margin_bottom, margin_left, margin_right, margin_top}; use uuid::Uuid; #[allow(unsafe_code)] @@ -178,10 +177,10 @@ fn determine_auto_margins(window: &Window, node: &Node) -> AutoMargins { let style = window.style_query(node.to_trusted_node_address()).unwrap(); let margin = style.get_margin(); AutoMargins { - top: margin.margin_top == margin_top::computed_value::T::Auto, - right: margin.margin_right == margin_right::computed_value::T::Auto, - bottom: margin.margin_bottom == margin_bottom::computed_value::T::Auto, - left: margin.margin_left == margin_left::computed_value::T::Auto, + top: margin.margin_top.is_auto(), + right: margin.margin_right.is_auto(), + bottom: margin.margin_bottom.is_auto(), + left: margin.margin_left.is_auto(), } } diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs index 234a10f9448..dbcab42f11f 100644 --- a/components/script/dom/element.rs +++ b/components/script/dom/element.rs @@ -718,9 +718,11 @@ impl LayoutElementHelpers for LayoutDom { specified::NoCalcLength::ServoCharacterWidth(specified::CharacterWidth(size)); hints.push(from_declaration( shared_lock, - PropertyDeclaration::Width(specified::LengthPercentageOrAuto::LengthPercentage( - specified::LengthPercentage::Length(value), - )), + PropertyDeclaration::Width( + specified::NonNegativeLengthPercentageOrAuto::LengthPercentage(NonNegative( + specified::LengthPercentage::Length(value), + )), + ), )); } @@ -745,20 +747,22 @@ impl LayoutElementHelpers for LayoutDom { match width { LengthOrPercentageOrAuto::Auto => {}, LengthOrPercentageOrAuto::Percentage(percentage) => { - let width_value = specified::LengthPercentageOrAuto::LengthPercentage( - specified::LengthPercentage::Percentage(computed::Percentage(percentage)), - ); + let width_value = + specified::NonNegativeLengthPercentageOrAuto::LengthPercentage(NonNegative( + specified::LengthPercentage::Percentage(computed::Percentage(percentage)), + )); hints.push(from_declaration( shared_lock, PropertyDeclaration::Width(width_value), )); }, LengthOrPercentageOrAuto::Length(length) => { - let width_value = specified::LengthPercentageOrAuto::LengthPercentage( - specified::LengthPercentage::Length(specified::NoCalcLength::Absolute( - specified::AbsoluteLength::Px(length.to_f32_px()), - )), - ); + let width_value = + specified::NonNegativeLengthPercentageOrAuto::LengthPercentage(NonNegative( + specified::LengthPercentage::Length(specified::NoCalcLength::Absolute( + specified::AbsoluteLength::Px(length.to_f32_px()), + )), + )); hints.push(from_declaration( shared_lock, PropertyDeclaration::Width(width_value), @@ -779,20 +783,22 @@ impl LayoutElementHelpers for LayoutDom { match height { LengthOrPercentageOrAuto::Auto => {}, LengthOrPercentageOrAuto::Percentage(percentage) => { - let height_value = specified::LengthPercentageOrAuto::LengthPercentage( - specified::LengthPercentage::Percentage(computed::Percentage(percentage)), - ); + let height_value = + specified::NonNegativeLengthPercentageOrAuto::LengthPercentage(NonNegative( + specified::LengthPercentage::Percentage(computed::Percentage(percentage)), + )); hints.push(from_declaration( shared_lock, PropertyDeclaration::Height(height_value), )); }, LengthOrPercentageOrAuto::Length(length) => { - let height_value = specified::LengthPercentageOrAuto::LengthPercentage( - specified::LengthPercentage::Length(specified::NoCalcLength::Absolute( - specified::AbsoluteLength::Px(length.to_f32_px()), - )), - ); + let height_value = + specified::NonNegativeLengthPercentageOrAuto::LengthPercentage(NonNegative( + specified::LengthPercentage::Length(specified::NoCalcLength::Absolute( + specified::AbsoluteLength::Px(length.to_f32_px()), + )), + )); hints.push(from_declaration( shared_lock, PropertyDeclaration::Height(height_value), @@ -819,9 +825,11 @@ impl LayoutElementHelpers for LayoutDom { specified::NoCalcLength::ServoCharacterWidth(specified::CharacterWidth(cols)); hints.push(from_declaration( shared_lock, - PropertyDeclaration::Width(specified::LengthPercentageOrAuto::LengthPercentage( - specified::LengthPercentage::Length(value), - )), + PropertyDeclaration::Width( + specified::NonNegativeLengthPercentageOrAuto::LengthPercentage(NonNegative( + specified::LengthPercentage::Length(value), + )), + ), )); } @@ -843,9 +851,11 @@ impl LayoutElementHelpers for LayoutDom { )); hints.push(from_declaration( shared_lock, - PropertyDeclaration::Height(specified::LengthPercentageOrAuto::LengthPercentage( - specified::LengthPercentage::Length(value), - )), + PropertyDeclaration::Height( + specified::NonNegativeLengthPercentageOrAuto::LengthPercentage(NonNegative( + specified::LengthPercentage::Length(value), + )), + ), )); } diff --git a/components/script/lib.rs b/components/script/lib.rs index ce427aa3a56..1332e604fdb 100644 --- a/components/script/lib.rs +++ b/components/script/lib.rs @@ -8,6 +8,7 @@ #![feature(drain_filter)] #![feature(plugin)] #![feature(try_from)] +#![feature(type_alias_enum_variants)] #![deny(unsafe_code)] #![allow(non_snake_case)] #![doc = "The script crate contains all matters DOM."] diff --git a/tests/unit/style/viewport.rs b/tests/unit/style/viewport.rs index 89f708643b9..b4043038b83 100644 --- a/tests/unit/style/viewport.rs +++ b/tests/unit/style/viewport.rs @@ -14,8 +14,9 @@ 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::generics::length::LengthPercentageOrAuto::{self, Auto}; +use style::values::generics::NonNegative; use style::values::specified::LengthPercentage; -use style::values::specified::LengthPercentageOrAuto::{self, Auto}; use style::values::specified::NoCalcLength::{self, ViewportPercentage}; use style::values::specified::ViewportPercentageLength::Vw; use style_traits::viewport::*; @@ -97,14 +98,14 @@ macro_rules! assert_decl_len { macro_rules! viewport_length { ($value:expr, px) => { - ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage( + ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(NonNegative( LengthPercentage::Length(NoCalcLength::from_px($value)), - )) + ))) }; ($value:expr, vw) => { - ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage( + ViewportLength::Specified(LengthPercentageOrAuto::LengthPercentage(NonNegative( LengthPercentage::Length(ViewportPercentage(Vw($value))), - )) + ))) }; }