Cargoify servo

1 files changed, 0 insertions, 1138 deletions

diff --git a/src/components/layout/flow.rs b/src/components/layout/flow.rs
deleted file mode 100644
index 2759ebbe74b..00000000000
--- a/src/components/layout/flow.rs
+++ /dev/null
@@ -1,1138 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-//! Servo's experimental layout system builds a tree of `Flow` and `Fragment` objects and solves
-//! layout constraints to obtain positions and display attributes of tree nodes. Positions are
-//! computed in several tree traversals driven by the fundamental data dependencies required by
-/// inline and block layout.
-///
-/// Flows are interior nodes in the layout tree and correspond closely to *flow contexts* in the
-/// CSS specification. Flows are responsible for positioning their child flow contexts and fragments.
-/// Flows have purpose-specific fields, such as auxiliary line structs, out-of-flow child
-/// lists, and so on.
-///
-/// Currently, the important types of flows are:
-///
-/// * `BlockFlow`: A flow that establishes a block context. It has several child flows, each of
-///   which are positioned according to block formatting context rules (CSS block boxes). Block
-///   flows also contain a single box to represent their rendered borders, padding, etc.
-///   The BlockFlow at the root of the tree has special behavior: it stretches to the boundaries of
-///   the viewport.
-///
-/// * `InlineFlow`: A flow that establishes an inline context. It has a flat list of child
-///   fragments/flows that are subject to inline layout and line breaking and structs to represent
-///   line breaks and mapping to CSS boxes, for the purpose of handling `getClientRects()` and
-///   similar methods.
-
-use css::node_style::StyledNode;
-use block::BlockFlow;
-use context::LayoutContext;
-use floats::Floats;
-use flow_list::{FlowList, Link, FlowListIterator, MutFlowListIterator};
-use flow_ref::FlowRef;
-use fragment::{Fragment, TableRowFragment, TableCellFragment};
-use incremental::RestyleDamage;
-use inline::InlineFlow;
-use model::{CollapsibleMargins, IntrinsicISizes, MarginCollapseInfo};
-use parallel::FlowParallelInfo;
-use table_wrapper::TableWrapperFlow;
-use table::TableFlow;
-use table_colgroup::TableColGroupFlow;
-use table_rowgroup::TableRowGroupFlow;
-use table_row::TableRowFlow;
-use table_caption::TableCaptionFlow;
-use table_cell::TableCellFlow;
-use wrapper::ThreadSafeLayoutNode;
-
-use collections::dlist::DList;
-use geom::Point2D;
-use gfx::display_list::DisplayList;
-use gfx::render_task::RenderLayer;
-use serialize::{Encoder, Encodable};
-use servo_msg::compositor_msg::LayerId;
-use servo_util::geometry::Au;
-use servo_util::logical_geometry::WritingMode;
-use servo_util::logical_geometry::{LogicalRect, LogicalSize};
-use std::mem;
-use std::num::Zero;
-use std::fmt;
-use std::iter::Zip;
-use std::raw;
-use std::sync::atomics::{AtomicUint, Relaxed, SeqCst};
-use std::slice::MutItems;
-use style::computed_values::{clear, position, text_align};
-
-/// Virtual methods that make up a float context.
-///
-/// Note that virtual methods have a cost; we should not overuse them in Servo. Consider adding
-/// methods to `ImmutableFlowUtils` or `MutableFlowUtils` before adding more methods here.
-pub trait Flow: fmt::Show + ToString + Share {
-    // RTTI
-    //
-    // TODO(pcwalton): Use Rust's RTTI, once that works.
-
-    /// Returns the class of flow that this is.
-    fn class(&self) -> FlowClass;
-
-    /// If this is a block flow, returns the underlying object, borrowed immutably. Fails
-    /// otherwise.
-    fn as_immutable_block<'a>(&'a self) -> &'a BlockFlow {
-        fail!("called as_immutable_block() on a non-block flow")
-    }
-
-    /// If this is a block flow, returns the underlying object. Fails otherwise.
-    fn as_block<'a>(&'a mut self) -> &'a mut BlockFlow {
-        debug!("called as_block() on a flow of type {}", self.class());
-        fail!("called as_block() on a non-block flow")
-    }
-
-    /// If this is an inline flow, returns the underlying object, borrowed immutably. Fails
-    /// otherwise.
-    fn as_immutable_inline<'a>(&'a self) -> &'a InlineFlow {
-        fail!("called as_immutable_inline() on a non-inline flow")
-    }
-
-    /// If this is an inline flow, returns the underlying object. Fails otherwise.
-    fn as_inline<'a>(&'a mut self) -> &'a mut InlineFlow {
-        fail!("called as_inline() on a non-inline flow")
-    }
-
-    /// If this is a table wrapper flow, returns the underlying object. Fails otherwise.
-    fn as_table_wrapper<'a>(&'a mut self) -> &'a mut TableWrapperFlow {
-        fail!("called as_table_wrapper() on a non-tablewrapper flow")
-    }
-
-    /// If this is a table flow, returns the underlying object. Fails otherwise.
-    fn as_table<'a>(&'a mut self) -> &'a mut TableFlow {
-        fail!("called as_table() on a non-table flow")
-    }
-
-    /// If this is a table colgroup flow, returns the underlying object. Fails otherwise.
-    fn as_table_colgroup<'a>(&'a mut self) -> &'a mut TableColGroupFlow {
-        fail!("called as_table_colgroup() on a non-tablecolgroup flow")
-    }
-
-    /// If this is a table rowgroup flow, returns the underlying object. Fails otherwise.
-    fn as_table_rowgroup<'a>(&'a mut self) -> &'a mut TableRowGroupFlow {
-        fail!("called as_table_rowgroup() on a non-tablerowgroup flow")
-    }
-
-    /// If this is a table row flow, returns the underlying object. Fails otherwise.
-    fn as_table_row<'a>(&'a mut self) -> &'a mut TableRowFlow {
-        fail!("called as_table_row() on a non-tablerow flow")
-    }
-
-    /// If this is a table cell flow, returns the underlying object. Fails otherwise.
-    fn as_table_caption<'a>(&'a mut self) -> &'a mut TableCaptionFlow {
-        fail!("called as_table_caption() on a non-tablecaption flow")
-    }
-
-    /// If this is a table cell flow, returns the underlying object. Fails otherwise.
-    fn as_table_cell<'a>(&'a mut self) -> &'a mut TableCellFlow {
-        fail!("called as_table_cell() on a non-tablecell flow")
-    }
-
-    /// If this is a table row or table rowgroup or table flow, returns column inline-sizes.
-    /// Fails otherwise.
-    fn col_inline_sizes<'a>(&'a mut self) -> &'a mut Vec<Au> {
-        fail!("called col_inline_sizes() on an other flow than table-row/table-rowgroup/table")
-    }
-
-    /// If this is a table row flow or table rowgroup flow or table flow, returns column min inline-sizes.
-    /// Fails otherwise.
-    fn col_min_inline_sizes<'a>(&'a self) -> &'a Vec<Au> {
-        fail!("called col_min_inline_sizes() on an other flow than table-row/table-rowgroup/table")
-    }
-
-    /// If this is a table row flow or table rowgroup flow or table flow, returns column min inline-sizes.
-    /// Fails otherwise.
-    fn col_pref_inline_sizes<'a>(&'a self) -> &'a Vec<Au> {
-        fail!("called col_pref_inline_sizes() on an other flow than table-row/table-rowgroup/table")
-    }
-
-    // Main methods
-
-    /// Pass 1 of reflow: computes minimum and preferred inline-sizes.
-    ///
-    /// Recursively (bottom-up) determine the flow's minimum and preferred inline-sizes. When called on
-    /// this flow, all child flows have had their minimum and preferred inline-sizes set. This function
-    /// must decide minimum/preferred inline-sizes based on its children's inline-sizes and the dimensions of
-    /// any boxes it is responsible for flowing.
-    fn bubble_inline_sizes(&mut self, _ctx: &LayoutContext) {
-        fail!("bubble_inline_sizes not yet implemented")
-    }
-
-    /// Pass 2 of reflow: computes inline-size.
-    fn assign_inline_sizes(&mut self, _ctx: &LayoutContext) {
-        fail!("assign_inline_sizes not yet implemented")
-    }
-
-    /// Pass 3a of reflow: computes block-size.
-    fn assign_block_size<'a>(&mut self, _ctx: &'a LayoutContext<'a>) {
-        fail!("assign_block_size not yet implemented")
-    }
-
-    /// Assigns block-sizes in-order; or, if this is a float, places the float. The default
-    /// implementation simply assigns block-sizes if this flow is impacted by floats. Returns true if
-    /// this child was impacted by floats or false otherwise.
-    fn assign_block_size_for_inorder_child_if_necessary<'a>(&mut self, layout_context: &'a LayoutContext<'a>)
-                                                    -> bool {
-        let impacted = base(&*self).flags.impacted_by_floats();
-        if impacted {
-            self.assign_block_size(layout_context);
-        }
-        impacted
-    }
-
-    /// Phase 4 of reflow: computes absolute positions.
-    fn compute_absolute_position(&mut self) {
-        // The default implementation is a no-op.
-    }
-
-    /// Returns the direction that this flow clears floats in, if any.
-    fn float_clearance(&self) -> clear::T {
-        clear::none
-    }
-
-    /// Returns true if this float is a block formatting context and false otherwise. The default
-    /// implementation returns false.
-    fn is_block_formatting_context(&self, _only_impactable_by_floats: bool) -> bool {
-        false
-    }
-
-    fn compute_collapsible_block_start_margin(&mut self,
-                                      _layout_context: &mut LayoutContext,
-                                      _margin_collapse_info: &mut MarginCollapseInfo) {
-        // The default implementation is a no-op.
-    }
-
-    /// Marks this flow as the root flow. The default implementation is a no-op.
-    fn mark_as_root(&mut self) {}
-
-    // Note that the following functions are mostly called using static method
-    // dispatch, so it's ok to have them in this trait. Plus, they have
-    // different behaviour for different types of Flow, so they can't go into
-    // the Immutable / Mutable Flow Utils traits without additional casts.
-
-    /// Return true if store overflow is delayed for this flow.
-    ///
-    /// Currently happens only for absolutely positioned flows.
-    fn is_store_overflow_delayed(&mut self) -> bool {
-        false
-    }
-
-    fn is_root(&self) -> bool {
-        false
-    }
-
-    fn is_float(&self) -> bool {
-        false
-    }
-
-    /// The 'position' property of this flow.
-    fn positioning(&self) -> position::T {
-        position::static_
-    }
-
-    /// Return true if this flow has position 'fixed'.
-    fn is_fixed(&self) -> bool {
-        self.positioning() == position::fixed
-    }
-
-    fn is_positioned(&self) -> bool {
-        self.is_relatively_positioned() || self.is_absolutely_positioned()
-    }
-
-    fn is_relatively_positioned(&self) -> bool {
-        self.positioning() == position::relative
-    }
-
-    fn is_absolutely_positioned(&self) -> bool {
-        self.positioning() == position::absolute || self.is_fixed()
-    }
-
-    /// Return true if this is the root of an Absolute flow tree.
-    fn is_root_of_absolute_flow_tree(&self) -> bool {
-        false
-    }
-
-    /// Returns true if this is an absolute containing block.
-    fn is_absolute_containing_block(&self) -> bool {
-        false
-    }
-
-    /// Return the dimensions of the containing block generated by this flow for absolutely-
-    /// positioned descendants. For block flows, this is the padding box.
-    fn generated_containing_block_rect(&self) -> LogicalRect<Au> {
-        fail!("generated_containing_block_position not yet implemented for this flow")
-    }
-
-    /// Returns a layer ID for the given fragment.
-    fn layer_id(&self, fragment_id: uint) -> LayerId {
-        unsafe {
-            let pointer: uint = mem::transmute(self);
-            LayerId(pointer, fragment_id)
-        }
-    }
-}
-
-impl<'a, E, S: Encoder<E>> Encodable<S, E> for &'a Flow {
-    fn encode(&self, e: &mut S) -> Result<(), E> {
-        e.emit_struct("flow", 0, |e| {
-            try!(e.emit_struct_field("class", 0, |e| self.class().encode(e)))
-            e.emit_struct_field("data", 1, |e| {
-                match self.class() {
-                    BlockFlowClass => self.as_immutable_block().encode(e),
-                    InlineFlowClass => self.as_immutable_inline().encode(e),
-                    _ => { Ok(()) } // TODO: Support tables
-                }
-            })
-        })
-    }
-}
-
-// Base access
-
-#[inline(always)]
-pub fn base<'a>(this: &'a Flow) -> &'a BaseFlow {
-    unsafe {
-        let obj = mem::transmute::<&'a Flow, raw::TraitObject>(this);
-        mem::transmute::<*mut (), &'a BaseFlow>(obj.data)
-    }
-}
-
-/// Iterates over the children of this immutable flow.
-pub fn imm_child_iter<'a>(flow: &'a Flow) -> FlowListIterator<'a> {
-    base(flow).children.iter()
-}
-
-#[inline(always)]
-pub fn mut_base<'a>(this: &'a mut Flow) -> &'a mut BaseFlow {
-    unsafe {
-        let obj = mem::transmute::<&'a mut Flow, raw::TraitObject>(this);
-        mem::transmute::<*mut (), &'a mut BaseFlow>(obj.data)
-    }
-}
-
-/// Iterates over the children of this flow.
-pub fn child_iter<'a>(flow: &'a mut Flow) -> MutFlowListIterator<'a> {
-    mut_base(flow).children.mut_iter()
-}
-
-pub trait ImmutableFlowUtils {
-    // Convenience functions
-
-    /// Returns true if this flow is a block or a float flow.
-    fn is_block_like(self) -> bool;
-
-    /// Returns true if this flow is a table flow.
-    fn is_table(self) -> bool;
-
-    /// Returns true if this flow is a table caption flow.
-    fn is_table_caption(self) -> bool;
-
-    /// Returns true if this flow is a proper table child.
-    fn is_proper_table_child(self) -> bool;
-
-    /// Returns true if this flow is a table row flow.
-    fn is_table_row(self) -> bool;
-
-    /// Returns true if this flow is a table cell flow.
-    fn is_table_cell(self) -> bool;
-
-    /// Returns true if this flow is a table colgroup flow.
-    fn is_table_colgroup(self) -> bool;
-
-    /// Returns true if this flow is a table rowgroup flow.
-    fn is_table_rowgroup(self) -> bool;
-
-    /// Returns true if this flow is one of table-related flows.
-    fn is_table_kind(self) -> bool;
-
-    /// Returns true if anonymous flow is needed between this flow and child flow.
-    fn need_anonymous_flow(self, child: &Flow) -> bool;
-
-    /// Generates missing child flow of this flow.
-    fn generate_missing_child_flow(self, node: &ThreadSafeLayoutNode) -> FlowRef;
-
-    /// Returns true if this flow has no children.
-    fn is_leaf(self) -> bool;
-
-    /// Returns the number of children that this flow possesses.
-    fn child_count(self) -> uint;
-
-    /// Return true if this flow is a Block Container.
-    fn is_block_container(self) -> bool;
-
-    /// Returns true if this flow is a block flow.
-    fn is_block_flow(self) -> bool;
-
-    /// Returns true if this flow is an inline flow.
-    fn is_inline_flow(self) -> bool;
-
-    /// Dumps the flow tree for debugging.
-    fn dump(self);
-
-    /// Dumps the flow tree for debugging, with a prefix to indicate that we're at the given level.
-    fn dump_with_level(self, level: uint);
-}
-
-pub trait MutableFlowUtils {
-    // Traversals
-
-    /// Traverses the tree in preorder.
-    fn traverse_preorder<T:PreorderFlowTraversal>(self, traversal: &mut T) -> bool;
-
-    /// Traverses the tree in postorder.
-    fn traverse_postorder<T:PostorderFlowTraversal>(self, traversal: &mut T) -> bool;
-
-    // Mutators
-
-    /// Computes the overflow region for this flow.
-    fn store_overflow(self, _: &LayoutContext);
-
-    /// Builds the display lists for this flow.
-    fn build_display_list(self, layout_context: &LayoutContext);
-}
-
-pub trait MutableOwnedFlowUtils {
-    /// Set absolute descendants for this flow.
-    ///
-    /// Set this flow as the Containing Block for all the absolute descendants.
-    fn set_abs_descendants(&mut self, abs_descendants: AbsDescendants);
-}
-
-#[deriving(Encodable, PartialEq, Show)]
-pub enum FlowClass {
-    BlockFlowClass,
-    InlineFlowClass,
-    TableWrapperFlowClass,
-    TableFlowClass,
-    TableColGroupFlowClass,
-    TableRowGroupFlowClass,
-    TableRowFlowClass,
-    TableCaptionFlowClass,
-    TableCellFlowClass,
-}
-
-/// A top-down traversal.
-pub trait PreorderFlowTraversal {
-    /// The operation to perform. Return true to continue or false to stop.
-    fn process(&mut self, flow: &mut Flow) -> bool;
-
-    /// Returns true if this node should be pruned. If this returns true, we skip the operation
-    /// entirely and do not process any descendant nodes. This is called *before* child nodes are
-    /// visited. The default implementation never prunes any nodes.
-    fn should_prune(&mut self, _flow: &mut Flow) -> bool {
-        false
-    }
-}
-
-/// A bottom-up traversal, with a optional in-order pass.
-pub trait PostorderFlowTraversal {
-    /// The operation to perform. Return true to continue or false to stop.
-    fn process(&mut self, flow: &mut Flow) -> bool;
-
-    /// Returns false if this node must be processed in-order. If this returns false, we skip the
-    /// operation for this node, but continue processing the ancestors. This is called *after*
-    /// child nodes are visited.
-    fn should_process(&mut self, _flow: &mut Flow) -> bool {
-        true
-    }
-
-    /// Returns true if this node should be pruned. If this returns true, we skip the operation
-    /// entirely and do not process any descendant nodes. This is called *before* child nodes are
-    /// visited. The default implementation never prunes any nodes.
-    fn should_prune(&mut self, _flow: &mut Flow) -> bool {
-        false
-    }
-}
-
-/// Flags used in flows, tightly packed to save space.
-#[deriving(Clone, Encodable)]
-pub struct FlowFlags(pub u8);
-
-/// The bitmask of flags that represent the `has_left_floated_descendants` and
-/// `has_right_floated_descendants` fields.
-///
-/// NB: If you update this field, you must update the bitfields below.
-static HAS_FLOATED_DESCENDANTS_BITMASK: u8 = 0b0000_0011;
-
-// Whether this flow has descendants that float left in the same block formatting context.
-bitfield!(FlowFlags, has_left_floated_descendants, set_has_left_floated_descendants, 0b0000_0001)
-
-// Whether this flow has descendants that float right in the same block formatting context.
-bitfield!(FlowFlags, has_right_floated_descendants, set_has_right_floated_descendants, 0b0000_0010)
-
-// Whether this flow is impacted by floats to the left in the same block formatting context (i.e.
-// its block-size depends on some prior flows with `float: left`).
-bitfield!(FlowFlags, impacted_by_left_floats, set_impacted_by_left_floats, 0b0000_0100)
-
-// Whether this flow is impacted by floats to the right in the same block formatting context (i.e.
-// its block-size depends on some prior flows with `float: right`).
-bitfield!(FlowFlags, impacted_by_right_floats, set_impacted_by_right_floats, 0b0000_1000)
-
-/// The bitmask of flags that represent the text alignment field.
-///
-/// NB: If you update this field, you must update the bitfields below.
-static TEXT_ALIGN_BITMASK: u8 = 0b0011_0000;
-
-/// The number of bits we must shift off to handle the text alignment field.
-///
-/// NB: If you update this field, you must update the bitfields below.
-static TEXT_ALIGN_SHIFT: u8 = 4;
-
-// Whether this flow contains a flow that has its own layer within the same absolute containing
-// block.
-bitfield!(FlowFlags,
-          layers_needed_for_descendants,
-          set_layers_needed_for_descendants,
-          0b0100_0000)
-
-// Whether this flow must have its own layer. Even if this flag is not set, it might get its own
-// layer if it's deemed to be likely to overlap flows with their own layer.
-bitfield!(FlowFlags, needs_layer, set_needs_layer, 0b1000_0000)
-
-impl FlowFlags {
-    /// Creates a new set of flow flags.
-    pub fn new() -> FlowFlags {
-        FlowFlags(0)
-    }
-
-    /// Propagates text alignment flags from an appropriate parent flow per CSS 2.1.
-    ///
-    /// FIXME(#2265, pcwalton): It would be cleaner and faster to make this a derived CSS property
-    /// `-servo-text-align-in-effect`.
-    pub fn propagate_text_alignment_from_parent(&mut self, parent_flags: FlowFlags) {
-        self.set_text_align_override(parent_flags);
-    }
-
-    #[inline]
-    pub fn text_align(self) -> text_align::T {
-        let FlowFlags(ff) = self;
-        FromPrimitive::from_u8((ff & TEXT_ALIGN_BITMASK) >> TEXT_ALIGN_SHIFT as uint).unwrap()
-    }
-
-    #[inline]
-    pub fn set_text_align(&mut self, value: text_align::T) {
-        let FlowFlags(ff) = *self;
-        *self = FlowFlags((ff & !TEXT_ALIGN_BITMASK) | ((value as u8) << TEXT_ALIGN_SHIFT as uint))
-    }
-
-    #[inline]
-    pub fn set_text_align_override(&mut self, parent: FlowFlags) {
-        let FlowFlags(ff) = *self;
-        let FlowFlags(pff) = parent;
-        *self = FlowFlags(ff | (pff & TEXT_ALIGN_BITMASK))
-    }
-
-    #[inline]
-    pub fn union_floated_descendants_flags(&mut self, other: FlowFlags) {
-        let FlowFlags(my_flags) = *self;
-        let FlowFlags(other_flags) = other;
-        *self = FlowFlags(my_flags | (other_flags & HAS_FLOATED_DESCENDANTS_BITMASK))
-    }
-
-    #[inline]
-    pub fn impacted_by_floats(&self) -> bool {
-        self.impacted_by_left_floats() || self.impacted_by_right_floats()
-    }
-}
-
-/// The Descendants of a flow.
-///
-/// Also, details about their position wrt this flow.
-pub struct Descendants {
-    /// Links to every descendant. This must be private because it is unsafe to leak `FlowRef`s to
-    /// layout.
-    descendant_links: Vec<FlowRef>,
-
-    /// Static y offsets of all descendants from the start of this flow box.
-    pub static_b_offsets: Vec<Au>,
-}
-
-impl Descendants {
-    pub fn new() -> Descendants {
-        Descendants {
-            descendant_links: Vec::new(),
-            static_b_offsets: Vec::new(),
-        }
-    }
-
-    pub fn len(&self) -> uint {
-        self.descendant_links.len()
-    }
-
-    pub fn push(&mut self, given_descendant: FlowRef) {
-        self.descendant_links.push(given_descendant);
-    }
-
-    /// Push the given descendants on to the existing descendants.
-    ///
-    /// Ignore any static y offsets, because they are None before layout.
-    pub fn push_descendants(&mut self, given_descendants: Descendants) {
-        for elem in given_descendants.descendant_links.move_iter() {
-            self.descendant_links.push(elem);
-        }
-    }
-
-    /// Return an iterator over the descendant flows.
-    pub fn iter<'a>(&'a mut self) -> DescendantIter<'a> {
-        DescendantIter {
-            iter: self.descendant_links.mut_slice_from(0).mut_iter(),
-        }
-    }
-
-    /// Return an iterator over (descendant, static y offset).
-    pub fn iter_with_offset<'a>(&'a mut self) -> DescendantOffsetIter<'a> {
-        let descendant_iter = DescendantIter {
-            iter: self.descendant_links.mut_slice_from(0).mut_iter(),
-        };
-        descendant_iter.zip(self.static_b_offsets.mut_slice_from(0).mut_iter())
-    }
-}
-
-pub type AbsDescendants = Descendants;
-
-pub struct DescendantIter<'a> {
-    iter: MutItems<'a, FlowRef>,
-}
-
-impl<'a> Iterator<&'a mut Flow> for DescendantIter<'a> {
-    fn next(&mut self) -> Option<&'a mut Flow> {
-        match self.iter.next() {
-            None => None,
-            Some(ref mut flow) => {
-                unsafe {
-                    let result: &'a mut Flow = mem::transmute(flow.get_mut());
-                    Some(result)
-                }
-            }
-        }
-    }
-}
-
-pub type DescendantOffsetIter<'a> = Zip<DescendantIter<'a>, MutItems<'a, Au>>;
-
-/// Information needed to compute absolute (i.e. viewport-relative) flow positions (not to be
-/// confused with absolutely-positioned flows).
-#[deriving(Encodable)]
-pub struct AbsolutePositionInfo {
-    /// The size of the containing block for relatively-positioned descendants.
-    pub relative_containing_block_size: LogicalSize<Au>,
-    /// The position of the absolute containing block.
-    pub absolute_containing_block_position: Point2D<Au>,
-    /// Whether the absolute containing block forces positioned descendants to be layerized.
-    ///
-    /// FIXME(pcwalton): Move into `FlowFlags`.
-    pub layers_needed_for_positioned_flows: bool,
-}
-
-impl AbsolutePositionInfo {
-    pub fn new(writing_mode: WritingMode) -> AbsolutePositionInfo {
-        // FIXME(pcwalton): The initial relative containing block-size should be equal to the size
-        // of the root layer.
-        AbsolutePositionInfo {
-            relative_containing_block_size: LogicalSize::zero(writing_mode),
-            absolute_containing_block_position: Zero::zero(),
-            layers_needed_for_positioned_flows: false,
-        }
-    }
-}
-
-/// Data common to all flows.
-pub struct BaseFlow {
-    /// NB: Must be the first element.
-    ///
-    /// The necessity of this will disappear once we have dynamically-sized types.
-    ref_count: AtomicUint,
-
-    pub restyle_damage: RestyleDamage,
-
-    /// The children of this flow.
-    pub children: FlowList,
-    pub next_sibling: Link,
-    pub prev_sibling: Link,
-
-    /* layout computations */
-    // TODO: min/pref and position are used during disjoint phases of
-    // layout; maybe combine into a single enum to save space.
-    pub intrinsic_inline_sizes: IntrinsicISizes,
-
-    /// The upper left corner of the box representing this flow, relative to the box representing
-    /// its parent flow.
-    ///
-    /// For absolute flows, this represents the position with respect to its *containing block*.
-    ///
-    /// This does not include margins in the block flow direction, because those can collapse. So
-    /// for the block direction (usually vertical), this represents the *border box*. For the
-    /// inline direction (usually horizontal), this represents the *margin box*.
-    pub position: LogicalRect<Au>,
-
-    /// The amount of overflow of this flow, relative to the containing block. Must include all the
-    /// pixels of all the display list items for correct invalidation.
-    pub overflow: LogicalRect<Au>,
-
-    /// Data used during parallel traversals.
-    ///
-    /// TODO(pcwalton): Group with other transient data to save space.
-    pub parallel: FlowParallelInfo,
-
-    /// The floats next to this flow.
-    pub floats: Floats,
-
-    /// The collapsible margins for this flow, if any.
-    pub collapsible_margins: CollapsibleMargins,
-
-    /// The position of this flow in page coordinates, computed during display list construction.
-    pub abs_position: Point2D<Au>,
-
-    /// Details about descendants with position 'absolute' or 'fixed' for which we are the
-    /// containing block. This is in tree order. This includes any direct children.
-    pub abs_descendants: AbsDescendants,
-
-    /// Offset wrt the nearest positioned ancestor - aka the Containing Block
-    /// for any absolutely positioned elements.
-    pub absolute_static_i_offset: Au,
-
-    /// Offset wrt the Initial Containing Block.
-    pub fixed_static_i_offset: Au,
-
-    /// Reference to the Containing Block, if this flow is absolutely positioned.
-    pub absolute_cb: ContainingBlockLink,
-
-    /// Information needed to compute absolute (i.e. viewport-relative) flow positions (not to be
-    /// confused with absolutely-positioned flows).
-    ///
-    /// FIXME(pcwalton): Merge with `absolute_static_i_offset` and `fixed_static_i_offset` above?
-    pub absolute_position_info: AbsolutePositionInfo,
-
-    /// The unflattened display items for this flow.
-    pub display_list: DisplayList,
-
-    /// Any layers that we're bubbling up, in a linked list.
-    pub layers: DList<RenderLayer>,
-
-    /// Various flags for flows, tightly packed to save space.
-    pub flags: FlowFlags,
-
-    pub writing_mode: WritingMode,
-}
-
-impl<E, S: Encoder<E>> Encodable<S, E> for BaseFlow {
-    fn encode(&self, e: &mut S) -> Result<(), E> {
-        e.emit_struct("base", 0, |e| {
-            try!(e.emit_struct_field("id", 0, |e| self.debug_id().encode(e)))
-            try!(e.emit_struct_field("abs_position", 1, |e| self.abs_position.encode(e)))
-            try!(e.emit_struct_field("intrinsic_inline_sizes", 2, |e| self.intrinsic_inline_sizes.encode(e)))
-            try!(e.emit_struct_field("position", 3, |e| self.position.encode(e)))
-            e.emit_struct_field("children", 4, |e| {
-                e.emit_seq(self.children.len(), |e| {
-                    for (i, c) in self.children.iter().enumerate() {
-                        try!(e.emit_seq_elt(i, |e| c.encode(e)))
-                    }
-                    Ok(())
-                })
-
-            })
-        })
-    }
-}
-
-#[unsafe_destructor]
-impl Drop for BaseFlow {
-    fn drop(&mut self) {
-        if self.ref_count.load(SeqCst) != 0 {
-            fail!("Flow destroyed before its ref count hit zero—this is unsafe!")
-        }
-    }
-}
-
-impl BaseFlow {
-    #[inline]
-    pub fn new(node: ThreadSafeLayoutNode) -> BaseFlow {
-        let writing_mode = node.style().writing_mode;
-        BaseFlow {
-            ref_count: AtomicUint::new(1),
-
-            restyle_damage: node.restyle_damage(),
-
-            children: FlowList::new(),
-            next_sibling: None,
-            prev_sibling: None,
-
-            intrinsic_inline_sizes: IntrinsicISizes::new(),
-            position: LogicalRect::zero(writing_mode),
-            overflow: LogicalRect::zero(writing_mode),
-
-            parallel: FlowParallelInfo::new(),
-
-            floats: Floats::new(writing_mode),
-            collapsible_margins: CollapsibleMargins::new(),
-            abs_position: Zero::zero(),
-            abs_descendants: Descendants::new(),
-            absolute_static_i_offset: Au::new(0),
-            fixed_static_i_offset: Au::new(0),
-            absolute_cb: ContainingBlockLink::new(),
-            display_list: DisplayList::new(),
-            layers: DList::new(),
-            absolute_position_info: AbsolutePositionInfo::new(writing_mode),
-
-            flags: FlowFlags::new(),
-            writing_mode: writing_mode,
-        }
-    }
-
-    pub fn child_iter<'a>(&'a mut self) -> MutFlowListIterator<'a> {
-        self.children.mut_iter()
-    }
-
-    pub unsafe fn ref_count<'a>(&'a self) -> &'a AtomicUint {
-        &self.ref_count
-    }
-
-    pub fn debug_id(&self) -> String {
-        format!("{:p}", self as *const _)
-    }
-}
-
-impl<'a> ImmutableFlowUtils for &'a Flow {
-    /// Returns true if this flow is a block or a float flow.
-    fn is_block_like(self) -> bool {
-        match self.class() {
-            BlockFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is a proper table child.
-    /// 'Proper table child' is defined as table-row flow, table-rowgroup flow,
-    /// table-column-group flow, or table-caption flow.
-    fn is_proper_table_child(self) -> bool {
-        match self.class() {
-            TableRowFlowClass | TableRowGroupFlowClass |
-                TableColGroupFlowClass | TableCaptionFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is a table row flow.
-    fn is_table_row(self) -> bool {
-        match self.class() {
-            TableRowFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is a table cell flow.
-    fn is_table_cell(self) -> bool {
-        match self.class() {
-            TableCellFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is a table colgroup flow.
-    fn is_table_colgroup(self) -> bool {
-        match self.class() {
-            TableColGroupFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is a table flow.
-    fn is_table(self) -> bool {
-        match self.class() {
-            TableFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is a table caption flow.
-    fn is_table_caption(self) -> bool {
-        match self.class() {
-            TableCaptionFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is a table rowgroup flow.
-    fn is_table_rowgroup(self) -> bool {
-        match self.class() {
-            TableRowGroupFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is one of table-related flows.
-    fn is_table_kind(self) -> bool {
-        match self.class() {
-            TableWrapperFlowClass | TableFlowClass |
-                TableColGroupFlowClass | TableRowGroupFlowClass |
-                TableRowFlowClass | TableCaptionFlowClass | TableCellFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if anonymous flow is needed between this flow and child flow.
-    /// Spec: http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
-    fn need_anonymous_flow(self, child: &Flow) -> bool {
-        match self.class() {
-            TableFlowClass => !child.is_proper_table_child(),
-            TableRowGroupFlowClass => !child.is_table_row(),
-            TableRowFlowClass => !child.is_table_cell(),
-            _ => false
-        }
-    }
-
-    /// Generates missing child flow of this flow.
-    fn generate_missing_child_flow(self, node: &ThreadSafeLayoutNode) -> FlowRef {
-        let flow = match self.class() {
-            TableFlowClass | TableRowGroupFlowClass => {
-                let fragment = Fragment::new_anonymous_table_fragment(node, TableRowFragment);
-                box TableRowFlow::from_node_and_fragment(node, fragment) as Box<Flow>
-            },
-            TableRowFlowClass => {
-                let fragment = Fragment::new_anonymous_table_fragment(node, TableCellFragment);
-                box TableCellFlow::from_node_and_fragment(node, fragment) as Box<Flow>
-            },
-            _ => {
-                fail!("no need to generate a missing child")
-            }
-        };
-        FlowRef::new(flow)
-    }
-
-    /// Returns true if this flow has no children.
-    fn is_leaf(self) -> bool {
-        base(self).children.len() == 0
-    }
-
-    /// Returns the number of children that this flow possesses.
-    fn child_count(self) -> uint {
-        base(self).children.len()
-    }
-
-    /// Return true if this flow is a Block Container.
-    ///
-    /// Except for table fragments and replaced elements, block-level fragments (`BlockFlow`) are
-    /// also block container fragments.
-    /// Non-replaced inline blocks and non-replaced table cells are also block
-    /// containers.
-    fn is_block_container(self) -> bool {
-        match self.class() {
-            // TODO: Change this when inline-blocks are supported.
-            BlockFlowClass | TableCaptionFlowClass | TableCellFlowClass => {
-                // FIXME: Actually check the type of the node
-                self.child_count() != 0
-            }
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is a block flow.
-    fn is_block_flow(self) -> bool {
-        match self.class() {
-            BlockFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if this flow is an inline flow.
-    fn is_inline_flow(self) -> bool {
-        match self.class() {
-            InlineFlowClass => true,
-            _ => false,
-        }
-    }
-
-    /// Dumps the flow tree for debugging.
-    fn dump(self) {
-        self.dump_with_level(0)
-    }
-
-    /// Dumps the flow tree for debugging, with a prefix to indicate that we're at the given level.
-    fn dump_with_level(self, level: uint) {
-        let mut indent = String::new();
-        for _ in range(0, level) {
-            indent.push_str("| ")
-        }
-        debug!("{}+ {}", indent, self.to_string());
-        for kid in imm_child_iter(self) {
-            kid.dump_with_level(level + 1)
-        }
-    }
-}
-
-impl<'a> MutableFlowUtils for &'a mut Flow {
-    /// Traverses the tree in preorder.
-    fn traverse_preorder<T:PreorderFlowTraversal>(self, traversal: &mut T) -> bool {
-        if traversal.should_prune(self) {
-            return true
-        }
-
-        if !traversal.process(self) {
-            return false
-        }
-
-        for kid in child_iter(self) {
-            if !kid.traverse_preorder(traversal) {
-                return false
-            }
-        }
-
-        true
-    }
-
-    /// Traverses the tree in postorder.
-    fn traverse_postorder<T:PostorderFlowTraversal>(self, traversal: &mut T) -> bool {
-        if traversal.should_prune(self) {
-            return true
-        }
-
-        for kid in child_iter(self) {
-            if !kid.traverse_postorder(traversal) {
-                return false
-            }
-        }
-
-        if !traversal.should_process(self) {
-            return true
-        }
-
-        traversal.process(self)
-    }
-
-    /// Calculate and set overflow for current flow.
-    ///
-    /// CSS Section 11.1
-    /// This is the union of rectangles of the flows for which we define the
-    /// Containing Block.
-    ///
-    /// Assumption: This is called in a bottom-up traversal, so kids' overflows have
-    /// already been set.
-    /// Assumption: Absolute descendants have had their overflow calculated.
-    fn store_overflow(self, _: &LayoutContext) {
-        let my_position = mut_base(self).position;
-        let mut overflow = my_position;
-
-        if self.is_block_container() {
-            for kid in child_iter(self) {
-                if kid.is_store_overflow_delayed() {
-                    // Absolute flows will be handled by their CB. If we are
-                    // their CB, they will show up in `abs_descendants`.
-                    continue;
-                }
-                let mut kid_overflow = base(kid).overflow;
-                kid_overflow = kid_overflow.translate(&my_position.start);
-                overflow = overflow.union(&kid_overflow)
-            }
-
-            // FIXME(#2004, pcwalton): This is wrong for `position: fixed`.
-            for descendant_link in mut_base(self).abs_descendants.iter() {
-                let mut kid_overflow = base(descendant_link).overflow;
-                kid_overflow = kid_overflow.translate(&my_position.start);
-                overflow = overflow.union(&kid_overflow)
-            }
-        }
-        mut_base(self).overflow = overflow;
-    }
-
-    /// Push display items for current flow and its descendants onto the appropriate display lists
-    /// of the given stacking context.
-    ///
-    /// Arguments:
-    ///
-    /// * `builder`: The display list builder, which contains information used during the entire
-    ///   display list building pass.
-    ///
-    /// * `info`: Per-flow display list building information.
-    fn build_display_list(self, layout_context: &LayoutContext) {
-        debug!("Flow: building display list");
-        match self.class() {
-            BlockFlowClass => self.as_block().build_display_list_block(layout_context),
-            InlineFlowClass => self.as_inline().build_display_list_inline(layout_context),
-            TableWrapperFlowClass => {
-                self.as_table_wrapper().build_display_list_table_wrapper(layout_context)
-            }
-            TableFlowClass => self.as_table().build_display_list_table(layout_context),
-            TableRowGroupFlowClass => {
-                self.as_table_rowgroup().build_display_list_table_rowgroup(layout_context)
-            }
-            TableRowFlowClass => self.as_table_row().build_display_list_table_row(layout_context),
-            TableCaptionFlowClass => {
-                self.as_table_caption().build_display_list_table_caption(layout_context)
-            }
-            TableCellFlowClass => {
-                self.as_table_cell().build_display_list_table_cell(layout_context)
-            }
-            TableColGroupFlowClass => {
-                // Nothing to do here, as column groups don't render.
-            }
-        }
-    }
-}
-
-impl MutableOwnedFlowUtils for FlowRef {
-    /// Set absolute descendants for this flow.
-    ///
-    /// Set yourself as the Containing Block for all the absolute descendants.
-    ///
-    /// This is called during flow construction, so nothing else can be accessing the descendant
-    /// flows. This is enforced by the fact that we have a mutable `FlowRef`, which only flow
-    /// construction is allowed to possess.
-    fn set_abs_descendants(&mut self, abs_descendants: AbsDescendants) {
-        let this = self.clone();
-
-        let block = self.get_mut().as_block();
-        block.base.abs_descendants = abs_descendants;
-        block.base
-             .parallel
-             .children_and_absolute_descendant_count
-             .fetch_add(block.base.abs_descendants.len() as int, Relaxed);
-
-        for descendant_link in block.base.abs_descendants.iter() {
-            let base = mut_base(descendant_link);
-            base.absolute_cb.set(this.clone());
-        }
-    }
-}
-
-/// A link to a flow's containing block.
-///
-/// This cannot safely be a `Flow` pointer because this is a pointer *up* the tree, not *down* the
-/// tree. A pointer up the tree is unsafe during layout because it can be used to access a node
-/// with an immutable reference while that same node is being laid out, causing possible iterator
-/// invalidation and use-after-free.
-///
-/// FIXME(pcwalton): I think this would be better with a borrow flag instead of `unsafe`.
-pub struct ContainingBlockLink {
-    /// The pointer up to the containing block.
-    link: Option<FlowRef>,
-}
-
-impl ContainingBlockLink {
-    fn new() -> ContainingBlockLink {
-        ContainingBlockLink {
-            link: None,
-        }
-    }
-
-    fn set(&mut self, link: FlowRef) {
-        self.link = Some(link)
-    }
-
-    pub unsafe fn get<'a>(&'a mut self) -> &'a mut Option<FlowRef> {
-        &mut self.link
-    }
-
-    #[inline]
-    pub fn generated_containing_block_rect(&mut self) -> LogicalRect<Au> {
-        match self.link {
-            None => fail!("haven't done it"),
-            Some(ref mut link) => link.get_mut().generated_containing_block_rect(),
-        }
-    }
-}
-