diff options
13 files changed, 417 insertions, 127 deletions
diff --git a/components/layout_2020/flow/float.rs b/components/layout_2020/flow/float.rs index 031ff1883e4..841fc2e19b7 100644 --- a/components/layout_2020/flow/float.rs +++ b/components/layout_2020/flow/float.rs @@ -17,6 +17,7 @@ use crate::style_ext::{ComputedValuesExt, DisplayInside}; use crate::ContainingBlock; use euclid::num::Zero; use servo_arc::Arc; +use std::collections::VecDeque; use std::fmt::{Debug, Formatter, Result as FmtResult}; use std::ops::Range; use std::{f32, mem}; @@ -70,6 +71,113 @@ impl ContainingBlockPositionInfo { } } +/// This data strucure is used to try to place non-floating content among float content. +/// This is used primarily to place replaced content and independent formatting contexts +/// next to floats, as the specifcation dictates. +pub(crate) struct PlacementAmongFloats<'a> { + /// The [FloatContext] to use for this placement. + float_context: &'a FloatContext, + /// The current bands we are considering for this placement. + current_bands: VecDeque<FloatBand>, + /// The next band, needed to know the height of the last band in current_bands. + next_band: FloatBand, + /// The size of the object to place. + object_size: Vec2<Length>, + /// The minimum position in the block direction for the placement. Objects should not + /// be placed before this point. + ceiling: Length, +} + +impl<'a> PlacementAmongFloats<'a> { + pub(crate) fn new( + float_context: &'a FloatContext, + ceiling: Length, + object_size: Vec2<Length>, + ) -> Self { + assert!(!ceiling.px().is_infinite()); + let current_band = float_context.bands.find(ceiling).unwrap(); + let current_bands = VecDeque::from([current_band]); + let next_band = float_context.bands.find_next(current_band.top).unwrap(); + PlacementAmongFloats { + float_context, + current_bands, + next_band, + object_size, + ceiling, + } + } + + fn top_of_placement_for_current_bands(&self) -> Length { + self.ceiling.max(self.current_bands.front().unwrap().top) + } + + fn current_bands_height(&self) -> Length { + assert!(!self.current_bands.is_empty()); + self.next_band.top - self.top_of_placement_for_current_bands() + } + + fn accumulate_enough_bands_for_block_size(&mut self) { + while self.current_bands_height() < self.object_size.block { + assert!(!self.next_band.top.px().is_infinite()); + self.current_bands.push_back(self.next_band); + self.next_band = self + .float_context + .bands + .find_next(self.next_band.top) + .unwrap(); + } + } + + fn calculate_viable_inline_space(&self) -> (Length, Length) { + let mut max_inline_start = self.float_context.containing_block_info.inline_start; + let mut min_inline_end = self.float_context.containing_block_info.inline_end; + assert!(!self.current_bands.is_empty()); + + for band in self.current_bands.iter() { + if let Some(left) = band.left { + max_inline_start = max_inline_start.max(left); + } + if let Some(right) = band.right { + min_inline_end = min_inline_end.min(right); + } + } + return (max_inline_start, min_inline_end); + } + + pub(crate) fn try_place_once(&mut self) -> Option<Vec2<Length>> { + self.accumulate_enough_bands_for_block_size(); + let (inline_start, inline_end) = self.calculate_viable_inline_space(); + if inline_end - inline_start >= self.object_size.inline { + return Some(Vec2 { + inline: inline_start, + block: self.top_of_placement_for_current_bands(), + }); + } + + self.current_bands.pop_front(); + None + } + + /// Run the placement algorithm for this [PlacementAmongFloats]. + pub(crate) fn place(&mut self) -> Vec2<Length> { + while self.current_bands.len() > 0 { + if let Some(result) = self.try_place_once() { + return result; + } + } + + // We could not fit the object in among the floats, so we place it as if it + // cleared all floats. + return Vec2 { + inline: self.float_context.containing_block_info.inline_start, + block: self + .ceiling + .max(self.float_context.clear_left_position) + .max(self.float_context.clear_right_position), + }; + } +} + /// Data kept during layout about the floats in a given block formatting context. /// /// This is a persistent data structure. Each float has its own private copy of the float context, @@ -133,13 +241,12 @@ impl FloatContext { /// /// This should be used for placing inline elements and block formatting contexts so that they /// don't collide with floats. - pub fn place_object(&self, object: &PlacementInfo) -> Vec2<Length> { + pub(crate) fn place_object(&self, object: &PlacementInfo, ceiling: Length) -> Vec2<Length> { let ceiling = match object.clear { - ClearSide::None => self.ceiling, - ClearSide::Left => self.ceiling.max(self.clear_left_position), - ClearSide::Right => self.ceiling.max(self.clear_right_position), - ClearSide::Both => self - .ceiling + ClearSide::None => ceiling, + ClearSide::Left => ceiling.max(self.clear_left_position), + ClearSide::Right => ceiling.max(self.clear_right_position), + ClearSide::Both => ceiling .max(self.clear_left_position) .max(self.clear_right_position), }; @@ -163,7 +270,7 @@ impl FloatContext { }; Vec2 { inline: left_object_edge, - block: first_band.top.max(self.ceiling), + block: first_band.top.max(ceiling), } }, FloatSide::Right => { @@ -173,16 +280,16 @@ impl FloatContext { }; Vec2 { inline: right_object_edge - object.size.inline, - block: first_band.top.max(self.ceiling), + block: first_band.top.max(ceiling), } }, } } /// Places a new float and adds it to the list. Returns the start corner of its margin box. - pub fn add_float(&mut self, new_float: &PlacementInfo) -> Vec2<Length> { + pub(crate) fn add_float(&mut self, new_float: &PlacementInfo) -> Vec2<Length> { // Place the float. - let new_float_origin = self.place_object(&new_float); + let new_float_origin = self.place_object(&new_float, self.ceiling); let new_float_extent = match new_float.side { FloatSide::Left => new_float_origin.inline + new_float.size.inline, FloatSide::Right => new_float_origin.inline, @@ -242,7 +349,7 @@ impl FloatContext { /// Information needed to place an object so that it doesn't collide with existing floats. #[derive(Clone, Debug)] -pub struct PlacementInfo { +pub(crate) struct PlacementInfo { /// The *margin* box size of the object. pub size: Vec2<Length>, /// Whether the object is (logically) aligned to the left or right. @@ -909,7 +1016,7 @@ impl SequentialLayoutState { &mut self, box_fragment: &mut BoxFragment, margins_collapsing_with_parent_containing_block: CollapsedMargin, - block_offset_from_containining_block_top: CSSPixelLength, + block_offset_from_containing_block_top: Length, ) { let block_start_of_containing_block_in_bfc = self.floats.containing_block_info.block_start + self.floats @@ -919,7 +1026,7 @@ impl SequentialLayoutState { .solve(); self.floats.lower_ceiling( - block_start_of_containing_block_in_bfc + block_offset_from_containining_block_top, + block_start_of_containing_block_in_bfc + block_offset_from_containing_block_top, ); let pbm_sums = &(&box_fragment.padding + &box_fragment.border) + &box_fragment.margin; diff --git a/components/layout_2020/flow/mod.rs b/components/layout_2020/flow/mod.rs index 00e6670343d..ca28f4318ff 100644 --- a/components/layout_2020/flow/mod.rs +++ b/components/layout_2020/flow/mod.rs @@ -4,6 +4,7 @@ //! Flow layout, also known as block-and-inline layout. +use self::float::PlacementAmongFloats; use crate::cell::ArcRefCell; use crate::context::LayoutContext; use crate::flow::float::{ClearSide, ContainingBlockPositionInfo, FloatBox, SequentialLayoutState}; @@ -521,13 +522,10 @@ impl BlockLevelBox { containing_block, &non_replaced.style, |positioning_context| { - layout_in_flow_non_replaced_block_level_independent_formatting_context( + non_replaced.layout_in_flow_block_level( layout_context, positioning_context, containing_block, - non_replaced.base_fragment_info, - &non_replaced.style, - non_replaced, sequential_layout_state, ) }, @@ -766,82 +764,230 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context( ) } -/// Lay out a normal flow non-replaced block that establishes and independent formatting -/// context in its containing formatting context. -/// -/// - https://drafts.csswg.org/css2/visudet.html#blockwidth -/// - https://drafts.csswg.org/css2/visudet.html#normal-block -fn layout_in_flow_non_replaced_block_level_independent_formatting_context( - layout_context: &LayoutContext, - positioning_context: &mut PositioningContext, - containing_block: &ContainingBlock, - base_fragment_info: BaseFragmentInfo, - style: &Arc<ComputedValues>, - independent_formatting_context: &NonReplacedFormattingContext, - mut sequential_layout_state: Option<&mut SequentialLayoutState>, -) -> BoxFragment { - let ContainingBlockPaddingBorderAndMargin { - containing_block: containing_block_for_children, - pbm, - min_box_size, - max_box_size, - margin, - } = solve_containing_block_padding_border_and_margin_for_in_flow_box(containing_block, style); +impl NonReplacedFormattingContext { + /// Lay out a normal in flow non-replaced block that establishes an independent + /// formatting context in its containing formatting context. + /// + /// - https://drafts.csswg.org/css2/visudet.html#blockwidth + /// - https://drafts.csswg.org/css2/visudet.html#normal-block + fn layout_in_flow_block_level( + &self, + layout_context: &LayoutContext, + positioning_context: &mut PositioningContext, + containing_block: &ContainingBlock, + sequential_layout_state: Option<&mut SequentialLayoutState>, + ) -> BoxFragment { + let ContainingBlockPaddingBorderAndMargin { + containing_block: containing_block_for_children, + pbm, + min_box_size, + max_box_size, + margin, + } = solve_containing_block_padding_border_and_margin_for_in_flow_box( + containing_block, + &self.style, + ); - let layout = independent_formatting_context.layout( - layout_context, - positioning_context, - &containing_block_for_children, - ); + if let Some(sequential_layout_state) = sequential_layout_state { + return self.layout_in_flow_block_level_sequentially( + layout_context, + positioning_context, + containing_block, + sequential_layout_state, + ); + } - let content_block_size = layout.content_block_size; - let block_size = containing_block_for_children.block_size.auto_is(|| { - content_block_size.clamp_between_extremums(min_box_size.block, max_box_size.block) - }); + let layout = self.layout( + layout_context, + positioning_context, + &containing_block_for_children, + ); - let mut clearance = None; - if let Some(ref mut sequential_layout_state) = sequential_layout_state { - clearance = sequential_layout_state.calculate_clearance_and_adjoin_margin( - style, - &CollapsedMargin::new(margin.block_start), + let block_size = containing_block_for_children.block_size.auto_is(|| { + layout + .content_block_size + .clamp_between_extremums(min_box_size.block, max_box_size.block) + }); + + let content_rect = Rect { + start_corner: Vec2 { + block: pbm.padding.block_start + pbm.border.block_start, + inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, + }, + size: Vec2 { + block: block_size, + inline: containing_block_for_children.inline_size, + }, + }; + + let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); + BoxFragment::new( + self.base_fragment_info, + self.style.clone(), + layout.fragments, + content_rect, + pbm.padding, + pbm.border, + margin, + None, /* clearance */ + block_margins_collapsed_with_children, + ) + } + + /// Lay out a normal in flow non-replaced block that establishes an independent + /// formatting context in its containing formatting context but handling sequential + /// layout concerns, such clearing and placing the content next to floats. + fn layout_in_flow_block_level_sequentially( + &self, + layout_context: &LayoutContext<'_>, + positioning_context: &mut PositioningContext, + containing_block: &ContainingBlock<'_>, + sequential_layout_state: &mut SequentialLayoutState, + ) -> BoxFragment { + let ContainingBlockPaddingBorderAndMargin { + containing_block: containing_block_for_children, + pbm, + min_box_size, + max_box_size, + margin, + } = solve_containing_block_padding_border_and_margin_for_in_flow_box( + containing_block, + &self.style, ); - sequential_layout_state.collapse_margins(); - // Account for padding and border. We also might have to readjust the - // `bfc_relative_block_position` if it was different from the content size (i.e. was - // non-`auto` and/or was affected by min/max block size). - sequential_layout_state.advance_block_position( - (block_size - content_block_size) + pbm.padding.block_sum() + pbm.border.block_sum(), + let block_start_margin = CollapsedMargin::new(margin.block_start); + let clearance = sequential_layout_state + .calculate_clearance(ClearSide::from_style(&self.style), &block_start_margin); + + let layout = self.layout( + layout_context, + positioning_context, + &containing_block_for_children, ); + let block_size = containing_block_for_children.block_size.auto_is(|| { + layout + .content_block_size + .clamp_between_extremums(min_box_size.block, max_box_size.block) + }); - sequential_layout_state.adjoin_assign(&CollapsedMargin::new(margin.block_end)); - } + // From https://drafts.csswg.org/css2/#floats: + // "The border box of a table, a block-level replaced element, or an element in + // the normal flow that establishes a new block formatting context (such as an + // element with overflow other than visible) must not overlap the margin box of + // any floats in the same block formatting context as the element itself. If + // necessary, implementations should clear the said element by placing it below + // any preceding floats, but may place it adjacent to such floats if there is + // sufficient space. They may even make the border box of said element narrower + // than defined by section 10.3.3. CSS 2 does not define when a UA may put said + // element next to the float or by how much said element may become narrower." + let mut adjustment_from_floats = Vec2::zero(); + adjustment_from_floats.block = clearance.unwrap_or_else(Length::zero); + + let inline_size_is_auto = self + .style + .box_size(containing_block.style.writing_mode) + .inline + .is_auto(); + if !inline_size_is_auto { + // We calculate a hypothetical value for `bfc_relative_block_position`, + // assuming that there was no adjustment from floats. The real value will + // depend on whether or not there was adjustment. + let hypothetical_bfc_relative_block_position = if clearance.is_some() { + sequential_layout_state.bfc_relative_block_position + + sequential_layout_state.current_margin.solve() + + block_start_margin.solve() + } else { + sequential_layout_state.bfc_relative_block_position + + sequential_layout_state + .current_margin + .adjoin(&block_start_margin) + .solve() + }; - let content_rect = Rect { - start_corner: Vec2 { - block: pbm.padding.block_start + - pbm.border.block_start + - clearance.unwrap_or_else(Length::zero), - inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, - }, - size: Vec2 { - block: block_size, - inline: containing_block_for_children.inline_size, - }, - }; + let size = &Vec2 { + inline: containing_block_for_children.inline_size, + block: block_size, + } + &pbm.padding_border_sums; + let placement = PlacementAmongFloats::new( + &sequential_layout_state.floats, + hypothetical_bfc_relative_block_position + clearance.unwrap_or_else(Length::zero), + size.clone(), + ) + .place(); + + // This placement is in the coordinates of the float-containing block formatting + // context, but we need to calculate an offset to use for placing this replaced + // element. + adjustment_from_floats = &placement - + &Vec2 { + inline: sequential_layout_state + .floats + .containing_block_info + .inline_start, + block: hypothetical_bfc_relative_block_position, + }; + } - let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); - BoxFragment::new( - base_fragment_info, - style.clone(), - layout.fragments, - content_rect, - pbm.padding, - pbm.border, - margin, - clearance, - block_margins_collapsed_with_children, - ) + // Clearance and any adjustment from float should prevent margin collapse, so it's + // important to make sure that it is non-None even when it is zero. Yet, when we + // didn't have clearance or any adjustment from placing next to floats, we want the + // value of clearance on the Fragment to be None, so margin collapse still works + // properly. + let effective_clearance = if clearance.is_some() || !adjustment_from_floats.block.is_zero() + { + Some(adjustment_from_floats.block) + } else { + None + }; + + // If there was effective clearance, it prevent margins collapse between this + // block and previous ones, so in that case collapse margins before adjoining + // them below. + if effective_clearance.is_some() { + sequential_layout_state.collapse_margins(); + } + sequential_layout_state.adjoin_assign(&block_start_margin); + + // Margins can never collapse into independent formatting contexts. + sequential_layout_state.collapse_margins(); + sequential_layout_state.advance_block_position( + pbm.padding_border_sums.block + adjustment_from_floats.block + block_size, + ); + sequential_layout_state.adjoin_assign(&CollapsedMargin::new(margin.block_end)); + + let block_size = containing_block_for_children.block_size.auto_is(|| { + layout + .content_block_size + .clamp_between_extremums(min_box_size.block, max_box_size.block) + }); + let content_rect = Rect { + start_corner: Vec2 { + block: pbm.padding.block_start + + pbm.border.block_start + + adjustment_from_floats.block, + inline: pbm.padding.inline_start + + pbm.border.inline_start + + margin.inline_start + + adjustment_from_floats.inline, + }, + size: Vec2 { + block: block_size, + inline: containing_block_for_children.inline_size, + }, + }; + let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); + BoxFragment::new( + self.base_fragment_info, + self.style.clone(), + layout.fragments, + content_rect, + pbm.padding, + pbm.border, + margin, + effective_clearance, + block_margins_collapsed_with_children, + ) + } } /// https://drafts.csswg.org/css2/visudet.html#block-replaced-width @@ -867,33 +1013,94 @@ fn layout_in_flow_replaced_block_level<'a>( }; let fragments = replaced.make_fragments(style, size.clone()); - let mut clearance = None; + let mut effective_clearance = None; + let mut adjustment_from_floats = Vec2::zero(); if let Some(ref mut sequential_layout_state) = sequential_layout_state { - clearance = sequential_layout_state.calculate_clearance_and_adjoin_margin( - style, - &CollapsedMargin::new(margin.block_start), - ); + let block_start_margin = CollapsedMargin::new(margin.block_start); + let clearance = sequential_layout_state + .calculate_clearance(ClearSide::from_style(style), &block_start_margin); + + // We calculate a hypothetical value for `bfc_relative_block_position`, + // assuming that there was no adjustment from floats. The real value will + // depend on whether or not there was adjustment. + let hypothetical_bfc_relative_block_position = if clearance.is_some() { + sequential_layout_state.bfc_relative_block_position + + sequential_layout_state.current_margin.solve() + + block_start_margin.solve() + } else { + sequential_layout_state.bfc_relative_block_position + + sequential_layout_state + .current_margin + .adjoin(&block_start_margin) + .solve() + }; + + // From https://drafts.csswg.org/css2/#floats: + // "The border box of a table, a block-level replaced element, or an element in + // the normal flow that establishes a new block formatting context (such as an + // element with overflow other than visible) must not overlap the margin box of + // any floats in the same block formatting context as the element itself. If + // necessary, implementations should clear the said element by placing it below + // any preceding floats, but may place it adjacent to such floats if there is + // sufficient space. They may even make the border box of said element narrower + // than defined by section 10.3.3. CSS 2 does not define when a UA may put said + // element next to the float or by how much said element may become narrower." + let placement_among_floats = PlacementAmongFloats::new( + &sequential_layout_state.floats, + hypothetical_bfc_relative_block_position + clearance.unwrap_or_else(Length::zero), + &size + &pbm.padding_border_sums, + ) + .place(); + + // This placement is in the coordinates of the float-containing block formatting + // context, but we need to calculate an offset to use for placing this replaced + // element. + adjustment_from_floats = &placement_among_floats - + &Vec2 { + inline: sequential_layout_state + .floats + .containing_block_info + .inline_start, + block: hypothetical_bfc_relative_block_position, + }; + + // Clearance and any adjustment from float should prevent margin collapse, so it's + // important to make sure that it is non-None even when it is zero. Yet, when we + // didn't have clearance or any adjustment from placing next to floats, we want the + // value of clearance on the Fragment to be None, so margin collapse still works + // properly. + effective_clearance = if clearance.is_some() || !adjustment_from_floats.block.is_zero() { + Some(adjustment_from_floats.block) + } else { + None + }; + + // If there was effective clearance, it prevent margins collapse between this + // block and previous ones, so in that case collapse margins before adjoining + // them below. + if effective_clearance.is_some() { + sequential_layout_state.collapse_margins(); + } + sequential_layout_state.adjoin_assign(&block_start_margin); + + // Margins can never collapse into replaced elements. sequential_layout_state.collapse_margins(); sequential_layout_state.advance_block_position( - pbm.border.block_sum() + - pbm.padding.block_sum() + - size.block + - clearance.unwrap_or_else(Length::zero), + pbm.padding_border_sums.block + size.block + adjustment_from_floats.block, ); sequential_layout_state.adjoin_assign(&CollapsedMargin::new(margin.block_end)); }; - let content_rect = Rect { - start_corner: Vec2 { - block: pbm.padding.block_start + - pbm.border.block_start + - clearance.unwrap_or_else(Length::zero), - inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, - }, - size, + let start_corner = Vec2 { + block: pbm.padding.block_start + pbm.border.block_start + adjustment_from_floats.block, + inline: pbm.padding.inline_start + + pbm.border.inline_start + + margin.inline_start + + adjustment_from_floats.inline, }; - let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); + let content_rect = Rect { start_corner, size }; + let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); BoxFragment::new( base_fragment_info, style.clone(), @@ -902,7 +1109,7 @@ fn layout_in_flow_replaced_block_level<'a>( pbm.padding, pbm.border, margin, - clearance, + effective_clearance, block_margins_collapsed_with_children, ) } diff --git a/tests/wpt/meta/css/CSS2/floats-clear/floats-039.xht.ini b/tests/wpt/meta/css/CSS2/floats-clear/floats-039.xht.ini deleted file mode 100644 index d99141cd3b6..00000000000 --- a/tests/wpt/meta/css/CSS2/floats-clear/floats-039.xht.ini +++ /dev/null @@ -1,2 +0,0 @@ -[floats-039.xht] - expected: FAIL diff --git a/tests/wpt/meta/css/CSS2/floats-clear/floats-bfc-001.xht.ini b/tests/wpt/meta/css/CSS2/floats-clear/floats-bfc-001.xht.ini deleted file mode 100644 index fe8adde8fbd..00000000000 --- a/tests/wpt/meta/css/CSS2/floats-clear/floats-bfc-001.xht.ini +++ /dev/null @@ -1,2 +0,0 @@ -[floats-bfc-001.xht] - expected: FAIL diff --git a/tests/wpt/meta/css/CSS2/floats-clear/floats-bfc-002.xht.ini b/tests/wpt/meta/css/CSS2/floats-clear/floats-bfc-002.xht.ini deleted file mode 100644 index 4c5d30ada12..00000000000 --- a/tests/wpt/meta/css/CSS2/floats-clear/floats-bfc-002.xht.ini +++ /dev/null @@ -1,2 +0,0 @@ -[floats-bfc-002.xht] - expected: FAIL diff --git a/tests/wpt/meta/css/CSS2/floats/floats-wrap-top-below-bfc-002r.xht.ini b/tests/wpt/meta/css/CSS2/floats/floats-wrap-top-below-bfc-002r.xht.ini deleted file mode 100644 index 6932dd5c0d7..00000000000 --- a/tests/wpt/meta/css/CSS2/floats/floats-wrap-top-below-bfc-002r.xht.ini +++ /dev/null @@ -1,2 +0,0 @@ -[floats-wrap-top-below-bfc-002r.xht] - expected: FAIL diff --git a/tests/wpt/meta/css/CSS2/floats/floats-wrap-top-below-bfc-003r.xht.ini b/tests/wpt/meta/css/CSS2/floats/floats-wrap-top-below-bfc-003r.xht.ini deleted file mode 100644 index c8d275af695..00000000000 --- a/tests/wpt/meta/css/CSS2/floats/floats-wrap-top-below-bfc-003r.xht.ini +++ /dev/null @@ -1,2 +0,0 @@ -[floats-wrap-top-below-bfc-003r.xht] - expected: FAIL diff --git a/tests/wpt/meta/css/CSS2/floats/new-fc-beside-adjoining-float-2.html.ini b/tests/wpt/meta/css/CSS2/floats/new-fc-beside-adjoining-float-2.html.ini deleted file mode 100644 index 068736c5062..00000000000 --- a/tests/wpt/meta/css/CSS2/floats/new-fc-beside-adjoining-float-2.html.ini +++ /dev/null @@ -1,2 +0,0 @@ -[new-fc-beside-adjoining-float-2.html] - expected: FAIL diff --git a/tests/wpt/meta/css/CSS2/floats/new-fc-beside-float-with-margin.html.ini b/tests/wpt/meta/css/CSS2/floats/new-fc-beside-float-with-margin.html.ini deleted file mode 100644 index bc826f00b21..00000000000 --- a/tests/wpt/meta/css/CSS2/floats/new-fc-beside-float-with-margin.html.ini +++ /dev/null @@ -1,2 +0,0 @@ -[new-fc-beside-float-with-margin.html] - expected: FAIL diff --git a/tests/wpt/meta/css/CSS2/floats/zero-space-between-floats-001.html.ini b/tests/wpt/meta/css/CSS2/floats/zero-space-between-floats-001.html.ini deleted file mode 100644 index 0cf8aeeef3e..00000000000 --- a/tests/wpt/meta/css/CSS2/floats/zero-space-between-floats-001.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[zero-space-between-floats-001.html] - [#container 1] - expected: FAIL diff --git a/tests/wpt/meta/css/CSS2/floats/zero-space-between-floats-002.html.ini b/tests/wpt/meta/css/CSS2/floats/zero-space-between-floats-002.html.ini deleted file mode 100644 index 74be952f9ae..00000000000 --- a/tests/wpt/meta/css/CSS2/floats/zero-space-between-floats-002.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[zero-space-between-floats-002.html] - [#container 1] - expected: FAIL diff --git a/tests/wpt/meta/css/CSS2/normal-flow/block-formatting-contexts-015.xht.ini b/tests/wpt/meta/css/CSS2/normal-flow/block-formatting-contexts-015.xht.ini deleted file mode 100644 index 27d98f802fc..00000000000 --- a/tests/wpt/meta/css/CSS2/normal-flow/block-formatting-contexts-015.xht.ini +++ /dev/null @@ -1,2 +0,0 @@ -[block-formatting-contexts-015.xht] - expected: FAIL diff --git a/tests/wpt/meta/css/css-flexbox/flexbox-paint-ordering-001.xhtml.ini b/tests/wpt/meta/css/css-flexbox/flexbox-paint-ordering-001.xhtml.ini deleted file mode 100644 index f940711d2e5..00000000000 --- a/tests/wpt/meta/css/css-flexbox/flexbox-paint-ordering-001.xhtml.ini +++ /dev/null @@ -1,2 +0,0 @@ -[flexbox-paint-ordering-001.xhtml] - expected: FAIL |