author Shing Lyu <>
Mon, 07 Nov 2016 02:15:03 -0600
changeset 340083 bbb0c815f4132fdaa2aaafdf95a55337ee959ef2
parent 340021 707064d4a4abef1616ed2c3aa135d930b9aa6868
child 340259 f8b490f82c8b008a3eb6e54ea8fad6a28cc378ce
permissions -rw-r--r--
servo: Merge #13740 - Migrated -Z trace-layout to serde_json (from shinglyu:layout_serde); r=jdm <!-- Please describe your changes on the following line: --> Migrated the trace-layout code from old `rustc-serialize` to `serde_json`. This will help us iterate faster on the layout viewer (#13432), #13436, #12675 and fix #12936. --- <!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `__` with appropriate data: --> - [x] `./mach build -d` does not report any errors - [x] `./mach test-tidy` does not report any errors - [x] These changes fix #12936 (github issue number if applicable). <!-- Either: --> - [ ] There are tests for these changes OR - [x] These changes do not require tests because it's a relatively low risk debug tool <!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. --> Source-Repo: Source-Revision: 1c26f44cbb23e7da3b9d63f0223c8d5d43eec958

/* 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 */

//! CSS table formatting contexts.


use app_units::Au;
use block::{BlockFlow, ISizeAndMarginsComputer};
use context::{LayoutContext, SharedLayoutContext};
use display_list_builder::DisplayListBuildState;
use euclid::Point2D;
use flow::{Flow, FlowClass, OpaqueFlow};
use fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
use gfx::display_list::StackingContext;
use gfx_traits::ScrollRootId;
use gfx_traits::print_tree::PrintTree;
use layout_debug;
use serde::{Serialize, Serializer};
use std::fmt;
use std::iter::{IntoIterator, Iterator, Peekable};
use std::sync::Arc;
use style::computed_values::{border_collapse, border_spacing};
use style::context::SharedStyleContext;
use style::logical_geometry::{LogicalSize, WritingMode};
use style::properties::ServoComputedValues;
use table::{ColumnComputedInlineSize, ColumnIntrinsicInlineSize, InternalTable, TableLikeFlow};
use table_row;

/// A table formatting context.
pub struct TableRowGroupFlow {
    /// Fields common to all block flows.
    pub block_flow: BlockFlow,

    /// Information about the intrinsic inline-sizes of each column.
    pub column_intrinsic_inline_sizes: Vec<ColumnIntrinsicInlineSize>,

    /// Information about the actual inline sizes of each column.
    pub column_computed_inline_sizes: Vec<ColumnComputedInlineSize>,

    /// The spacing for this rowgroup.
    pub spacing: border_spacing::T,

    /// The direction of the columns, propagated down from the table during the inline-size
    /// assignment phase.
    pub table_writing_mode: WritingMode,

    /// The final width of the borders in the inline direction for each cell, computed by the
    /// entire table and pushed down into each row during inline size computation.
    pub collapsed_inline_direction_border_widths_for_table: Vec<Au>,

    /// The final width of the borders in the block direction for each cell, computed by the
    /// entire table and pushed down into each row during inline size computation.
    pub collapsed_block_direction_border_widths_for_table: Vec<Au>,

impl Serialize for TableRowGroupFlow {
    fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {

impl TableRowGroupFlow {
    pub fn from_fragment(fragment: Fragment) -> TableRowGroupFlow {
        let writing_mode =;
        TableRowGroupFlow {
            block_flow: BlockFlow::from_fragment(fragment),
            column_intrinsic_inline_sizes: Vec::new(),
            column_computed_inline_sizes: Vec::new(),
            spacing: border_spacing::T {
                horizontal: Au(0),
                vertical: Au(0),
            table_writing_mode: writing_mode,
            collapsed_inline_direction_border_widths_for_table: Vec::new(),
            collapsed_block_direction_border_widths_for_table: Vec::new(),

    pub fn populate_collapsed_border_spacing<'a, I>(
            &mut self,
            collapsed_inline_direction_border_widths_for_table: &[Au],
            collapsed_block_direction_border_widths_for_table: &mut Peekable<I>)
            where I: Iterator<Item=&'a Au> {
            .extend(collapsed_inline_direction_border_widths_for_table.into_iter().map(|x| *x));

        for _ in 0..self.block_flow.base.children.len() {
            if let Some(collapsed_block_direction_border_width_for_table) =
        if let Some(collapsed_block_direction_border_width_for_table) =
                collapsed_block_direction_border_widths_for_table.peek() {

impl Flow for TableRowGroupFlow {
    fn class(&self) -> FlowClass {

    fn as_mut_table_rowgroup(&mut self) -> &mut TableRowGroupFlow {

    fn as_table_rowgroup(&self) -> &TableRowGroupFlow {

    fn as_mut_block(&mut self) -> &mut BlockFlow {
        &mut self.block_flow

    fn as_block(&self) -> &BlockFlow {

    fn column_intrinsic_inline_sizes(&mut self) -> &mut Vec<ColumnIntrinsicInlineSize> {
        &mut self.column_intrinsic_inline_sizes

    fn column_computed_inline_sizes(&mut self) -> &mut Vec<ColumnComputedInlineSize> {
        &mut self.column_computed_inline_sizes

    fn bubble_inline_sizes(&mut self) {
        let _scope = layout_debug_scope!("table_rowgroup::bubble_inline_sizes {:x}",
        // Proper calculation of intrinsic sizes in table layout requires access to the entire
        // table, which we don't have yet. Defer to our parent.

    /// Recursively (top-down) determines the actual inline-size of child contexts and fragments.
    /// When called on this context, the context has had its inline-size set by the parent context.
    fn assign_inline_sizes(&mut self, shared_context: &SharedStyleContext) {
        let _scope = layout_debug_scope!("table_rowgroup::assign_inline_sizes {:x}",
        debug!("assign_inline_sizes({}): assigning inline_size for flow", "table_rowgroup");

        // The position was set to the containing block by the flow's parent.
        let containing_block_inline_size = self.block_flow.base.block_container_inline_size;
        let (inline_start_content_edge, inline_end_content_edge) = (Au(0), Au(0));
        let content_inline_size = containing_block_inline_size;

        let border_collapse =;
        let inline_size_computer = InternalTable {
            border_collapse: border_collapse,
        inline_size_computer.compute_used_inline_size(&mut self.block_flow,

        let column_computed_inline_sizes = &self.column_computed_inline_sizes;
        let border_spacing = self.spacing;
        let table_writing_mode = self.table_writing_mode;
        let collapsed_inline_direction_border_widths_for_table =
        let mut collapsed_block_direction_border_widths_for_table =
                                                                    _inline_end_margin_edge| {

            if border_collapse == border_collapse::T::collapse {
                let child_table_row = child_flow.as_mut_table_row();
                    &mut collapsed_block_direction_border_widths_for_table);

    fn assign_block_size<'a>(&mut self, _: &'a LayoutContext<'a>) {
        debug!("assign_block_size: assigning block_size for table_rowgroup");

    fn compute_absolute_position(&mut self, layout_context: &SharedLayoutContext) {

    fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) {

    fn update_late_computed_block_position_if_necessary(&mut self, block_position: Au) {

    fn build_display_list(&mut self, state: &mut DisplayListBuildState) {
        debug!("build_display_list_table_rowgroup: same process as block flow");

    fn collect_stacking_contexts(&mut self,
                                 parent: &mut StackingContext,
                                 parent_scroll_root_id: ScrollRootId) {
        self.block_flow.collect_stacking_contexts(parent, parent_scroll_root_id);

    fn repair_style(&mut self, new_style: &Arc<ServoComputedValues>) {

    fn compute_overflow(&self) -> Overflow {

    fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> {

    fn iterate_through_fragment_border_boxes(&self,
                                             iterator: &mut FragmentBorderBoxIterator,
                                             level: i32,
                                             stacking_context_position: &Point2D<Au>) {
        self.block_flow.iterate_through_fragment_border_boxes(iterator, level, stacking_context_position)

    fn mutate_fragments(&mut self, mutator: &mut FnMut(&mut Fragment)) {

    fn print_extra_flow_children(&self, print_tree: &mut PrintTree) {

impl fmt::Debug for TableRowGroupFlow {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "TableRowGroupFlow: {:?}", self.block_flow)