From be36fcd3b1ee7da1c5a754132f5f95ac27b5c636 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Wed, 5 Nov 2014 10:06:28 -0800 Subject: [PATCH] layout: Eliminate the virtual `is_float()` in favor of the flow flags --- components/layout/block.rs | 18 +++++++----------- components/layout/flow.rs | 9 +++++---- components/layout/inline.rs | 3 ++- components/layout/table_wrapper.rs | 16 ++++++---------- 4 files changed, 20 insertions(+), 26 deletions(-) diff --git a/components/layout/block.rs b/components/layout/block.rs index 336dac78f5c..e3d03f22c0c 100644 --- a/components/layout/block.rs +++ b/components/layout/block.rs @@ -639,7 +639,7 @@ impl BlockFlow { } else { AbsoluteNonReplacedType } - } else if self.is_float() { + } else if self.base.flags.is_float() { if self.is_replaced_content() { FloatReplacedType } else { @@ -877,7 +877,7 @@ impl BlockFlow { // Assign block-size now for the child if it was impacted by floats and we couldn't // before. flow::mut_base(kid).floats = floats.clone(); - if kid.is_float() { + if flow::base(kid).flags.is_float() { flow::mut_base(kid).position.start.b = cur_b; { let kid_block = kid.as_block(); @@ -1225,7 +1225,7 @@ impl BlockFlow { pub fn propagate_and_compute_used_inline_size(&mut self, layout_context: &LayoutContext) { let containing_block_inline_size = self.base.block_container_inline_size; self.compute_used_inline_size(layout_context, containing_block_inline_size); - if self.is_float() { + if self.base.flags.is_float() { self.float.as_mut().unwrap().containing_inline_size = containing_block_inline_size; } } @@ -1547,7 +1547,7 @@ impl Flow for BlockFlow { } debug!("assign_inline_sizes({}): assigning inline_size for flow", - if self.is_float() { + if self.base.flags.is_float() { "float" } else { "block" @@ -1612,7 +1612,7 @@ impl Flow for BlockFlow { fn assign_block_size_for_inorder_child_if_necessary<'a>(&mut self, layout_context: &'a LayoutContext<'a>) -> bool { - if self.is_float() { + if self.base.flags.is_float() { self.place_float(); return true } @@ -1655,7 +1655,7 @@ impl Flow for BlockFlow { if !self.base.flags.contains(IS_ABSOLUTELY_POSITIONED) { self.base.position.size.block = self.fragment.border_box.size.block; } - } else if self.is_root() || self.is_float() || self.is_inline_block() { + } else if self.is_root() || self.base.flags.is_float() || self.is_inline_block() { // Root element margins should never be collapsed according to CSS ยง 8.3.1. debug!("assign_block_size: assigning block_size for root flow"); self.assign_block_size_block_base(ctx, MarginsMayNotCollapse); @@ -1772,10 +1772,6 @@ impl Flow for BlockFlow { self.flags.contains(IS_ROOT) } - fn is_float(&self) -> bool { - self.float.is_some() - } - /// The 'position' property of this flow. fn positioning(&self) -> position::T { self.fragment.style.get_box().position @@ -1822,7 +1818,7 @@ impl Flow for BlockFlow { } fn build_display_list(&mut self, layout_context: &LayoutContext) { - if self.is_float() { + if self.base.flags.is_float() { // TODO(#2009, pcwalton): This is a pseudo-stacking context. We need to merge `z-index: // auto` kids into the parent stacking context, when that is supported. self.build_display_list_for_floating_block(layout_context) diff --git a/components/layout/flow.rs b/components/layout/flow.rs index 64357ab90a6..0049d77eb8e 100644 --- a/components/layout/flow.rs +++ b/components/layout/flow.rs @@ -241,10 +241,6 @@ pub trait Flow: fmt::Show + ToString + Sync { false } - fn is_float(&self) -> bool { - false - } - /// The 'position' property of this flow. fn positioning(&self) -> position::T { position::static_ @@ -570,6 +566,11 @@ impl FlowFlags { } } + #[inline] + pub fn is_float(&self) -> bool { + self.floats_left() || self.floats_right() + } + #[inline] pub fn clears_floats(&self) -> bool { self.contains(CLEARS_LEFT) || self.contains(CLEARS_RIGHT) diff --git a/components/layout/inline.rs b/components/layout/inline.rs index 78e89b31b31..31ca89d3c75 100644 --- a/components/layout/inline.rs +++ b/components/layout/inline.rs @@ -1116,7 +1116,8 @@ impl Flow for InlineFlow { // Assign block sizes for any inline-block descendants. for kid in self.base.child_iter() { - if flow::base(kid).flags.contains(IS_ABSOLUTELY_POSITIONED) || kid.is_float() { + if flow::base(kid).flags.contains(IS_ABSOLUTELY_POSITIONED) || + flow::base(kid).flags.is_float() { continue } kid.assign_block_size_for_inorder_child_if_necessary(layout_context); diff --git a/components/layout/table_wrapper.rs b/components/layout/table_wrapper.rs index 57a34b2f216..78d050351bc 100644 --- a/components/layout/table_wrapper.rs +++ b/components/layout/table_wrapper.rs @@ -191,7 +191,7 @@ impl TableWrapperFlow { layout_context: &LayoutContext, parent_flow_inline_size: Au) { // Delegate to the appropriate inline size computer to find the constraint inputs. - let input = if self.is_float() { + let input = if self.block_flow.base.flags.is_float() { FloatNonReplaced.compute_inline_size_constraint_inputs(&mut self.block_flow, parent_flow_inline_size, layout_context) @@ -202,7 +202,7 @@ impl TableWrapperFlow { }; // Delegate to the appropriate inline size computer to write the constraint solutions in. - if self.is_float() { + if self.block_flow.base.flags.is_float() { let solution = FloatNonReplaced.solve_inline_size_constraints(&mut self.block_flow, &input); FloatNonReplaced.set_inline_size_constraint_solutions(&mut self.block_flow, solution); @@ -221,10 +221,6 @@ impl Flow for TableWrapperFlow { TableWrapperFlowClass } - fn is_float(&self) -> bool { - self.block_flow.is_float() - } - fn as_table_wrapper<'a>(&'a mut self) -> &'a mut TableWrapperFlow { self } @@ -251,7 +247,7 @@ impl Flow for TableWrapperFlow { fn assign_inline_sizes(&mut self, layout_context: &LayoutContext) { debug!("assign_inline_sizes({}): assigning inline_size for flow", - if self.is_float() { + if self.block_flow.base.flags.is_float() { "floated table_wrapper" } else { "table_wrapper" @@ -267,7 +263,7 @@ impl Flow for TableWrapperFlow { // Our inline-size was set to the inline-size of the containing block by the flow's parent. // Now compute the real value. let containing_block_inline_size = self.block_flow.base.block_container_inline_size; - if self.is_float() { + if self.block_flow.base.flags.is_float() { self.block_flow.float.as_mut().unwrap().containing_inline_size = containing_block_inline_size; } @@ -308,7 +304,7 @@ impl Flow for TableWrapperFlow { fn assign_block_size_for_inorder_child_if_necessary<'a>(&mut self, layout_context: &'a LayoutContext<'a>) -> bool { - if self.block_flow.is_float() { + if self.block_flow.base.flags.is_float() { self.block_flow.place_float(); return true } @@ -343,7 +339,7 @@ impl Flow for TableWrapperFlow { impl fmt::Show for TableWrapperFlow { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - if self.is_float() { + if self.block_flow.base.flags.is_float() { write!(f, "TableWrapperFlow(Float): {}", self.block_flow.fragment) } else { write!(f, "TableWrapperFlow: {}", self.block_flow.fragment)