Merge branch 'master' into calc

components/layout/block.rs

@@ -570,7 +570,7 @@ pub struct BlockFlow {
 
 bitflags! {
     flags BlockFlowFlags: u8 {
-        #[doc="If this is set, then this block flow is the root flow."]
+        #[doc = "If this is set, then this block flow is the root flow."]
         const IS_ROOT = 0x01,
     }
 }

components/layout/data.rs

@@ -54,7 +54,7 @@ impl PrivateLayoutData {
 
 bitflags! {
     flags LayoutDataFlags: u8 {
-        #[doc="Whether a flow has been newly constructed."]
+        #[doc = "Whether a flow has been newly constructed."]
         const HAS_NEWLY_CONSTRUCTED_FLOW = 0x01
     }
 }

components/layout/flex.rs

@@ -313,6 +313,10 @@ impl Flow for FlexFlow {
         &mut self.block_flow
     }
 
+    fn mark_as_root(&mut self) {
+        self.block_flow.mark_as_root();
+    }
+
     fn bubble_inline_sizes(&mut self) {
         let _scope = layout_debug_scope!("flex::bubble_inline_sizes {:x}",
                                          self.block_flow.base.debug_id());

components/layout/fragment.rs

@@ -2309,10 +2309,10 @@ bitflags! {
     // Various flags we can use when splitting fragments. See
     // `calculate_split_position_using_breaking_strategy()`.
     flags SplitOptions: u8 {
-        #[doc="True if this is the first fragment on the line."]
+        #[doc = "True if this is the first fragment on the line."]
         const STARTS_LINE = 0x01,
-        #[doc="True if we should attempt to split at character boundaries if this split fails. \
-               This is used to implement `overflow-wrap: break-word`."]
+        #[doc = "True if we should attempt to split at character boundaries if this split fails. \
+                 This is used to implement `overflow-wrap: break-word`."]
         const RETRY_AT_CHARACTER_BOUNDARIES = 0x02,
     }
 }

components/layout/incremental.rs

@@ -42,8 +42,8 @@ bitflags! {
 
 bitflags! {
     flags SpecialRestyleDamage: u8 {
-        #[doc="If this flag is set, we need to reflow the entire document. This is more or less a \
-               temporary hack to deal with cases that we don't handle incrementally yet."]
+        #[doc = "If this flag is set, we need to reflow the entire document. This is more or less a \
+                 temporary hack to deal with cases that we don't handle incrementally yet."]
         const REFLOW_ENTIRE_DOCUMENT = 0x01,
     }
 }

components/layout/inline.rs

@@ -183,9 +183,9 @@ int_range_index! {
 
 bitflags! {
     flags InlineReflowFlags: u8 {
-        #[doc="The `white-space: nowrap` property from CSS 2.1 § 16.6 is in effect."]
+        #[doc = "The `white-space: nowrap` property from CSS 2.1 § 16.6 is in effect."]
         const NO_WRAP_INLINE_REFLOW_FLAG = 0x01,
-        #[doc="The `white-space: pre` property from CSS 2.1 § 16.6 is in effect."]
+        #[doc = "The `white-space: pre` property from CSS 2.1 § 16.6 is in effect."]
         const WRAP_ON_NEWLINE_INLINE_REFLOW_FLAG = 0x02
     }
 }

components/layout/table_wrapper.rs

@@ -13,12 +13,12 @@
 
 #![deny(unsafe_code)]
 
-use block::{BlockFlow, FloatNonReplaced, ISizeAndMarginsComputer, ISizeConstraintInput};
+use block::{BlockFlow, FloatNonReplaced, AbsoluteNonReplaced, ISizeAndMarginsComputer, ISizeConstraintInput};
 use block::{ISizeConstraintSolution, MarginsMayCollapseFlag};
 use context::LayoutContext;
 use floats::FloatKind;
 use flow::{FlowClass, Flow, ImmutableFlowUtils};
-use flow::{IMPACTED_BY_LEFT_FLOATS, IMPACTED_BY_RIGHT_FLOATS, OpaqueFlow};
+use flow::{IMPACTED_BY_LEFT_FLOATS, IMPACTED_BY_RIGHT_FLOATS, INLINE_POSITION_IS_STATIC, OpaqueFlow};
 use fragment::{Fragment, FragmentBorderBoxIterator};
 use model::MaybeAuto;
 use table::{ColumnComputedInlineSize, ColumnIntrinsicInlineSize};
@@ -242,6 +242,26 @@ impl TableWrapperFlow {
             return
         }
 
+        if !self.block_flow.base.flags.contains(INLINE_POSITION_IS_STATIC) {
+            let inline_size_computer = AbsoluteTable {
+                minimum_width_of_all_columns: minimum_width_of_all_columns,
+                preferred_width_of_all_columns: preferred_width_of_all_columns,
+                border_collapse: border_collapse,
+            };
+            let input =
+                inline_size_computer.compute_inline_size_constraint_inputs(&mut self.block_flow,
+                                                                           parent_flow_inline_size,
+                                                                           layout_context);
+
+            let solution = inline_size_computer.solve_inline_size_constraints(&mut self.block_flow,
+                                                                              &input);
+            inline_size_computer.set_inline_size_constraint_solutions(&mut self.block_flow,
+                                                                      solution);
+            inline_size_computer.set_inline_position_of_flow_if_necessary(&mut self.block_flow,
+                                                                          solution);
+            return
+        }
+
         let inline_size_computer = Table {
             minimum_width_of_all_columns: minimum_width_of_all_columns,
             preferred_width_of_all_columns: preferred_width_of_all_columns,
@@ -791,3 +811,54 @@ impl ISizeAndMarginsComputer for FloatedTable {
         FloatNonReplaced.solve_inline_size_constraints(block, input)
     }
 }
+
+struct AbsoluteTable {
+    minimum_width_of_all_columns: Au,
+    preferred_width_of_all_columns: Au,
+    border_collapse: border_collapse::T,
+}
+
+impl ISizeAndMarginsComputer for AbsoluteTable {
+    fn compute_border_and_padding(&self, block: &mut BlockFlow, containing_block_inline_size: Au) {
+        block.fragment.compute_border_and_padding(containing_block_inline_size,
+                                                  self.border_collapse)
+    }
+
+    fn initial_computed_inline_size(&self,
+                                    block: &mut BlockFlow,
+                                    parent_flow_inline_size: Au,
+                                    layout_context: &LayoutContext)
+                                    -> MaybeAuto {
+        let containing_block_inline_size =
+            self.containing_block_inline_size(block,
+                                              parent_flow_inline_size,
+                                              layout_context);
+        initial_computed_inline_size(block,
+                                     containing_block_inline_size,
+                                     self.minimum_width_of_all_columns,
+                                     self.preferred_width_of_all_columns)
+    }
+
+    fn containing_block_inline_size(&self,
+                                    block: &mut BlockFlow,
+                                    parent_flow_inline_size: Au,
+                                    layout_context: &LayoutContext)
+                                    -> Au {
+        AbsoluteNonReplaced.containing_block_inline_size(block, parent_flow_inline_size, layout_context)
+    }
+
+    fn solve_inline_size_constraints(&self,
+                                     block: &mut BlockFlow,
+                                     input: &ISizeConstraintInput)
+                                     -> ISizeConstraintSolution {
+        AbsoluteNonReplaced.solve_inline_size_constraints(block, input)
+    }
+
+    fn set_inline_position_of_flow_if_necessary(&self,
+                                                block: &mut BlockFlow,
+                                                solution: ISizeConstraintSolution) {
+        AbsoluteNonReplaced.set_inline_position_of_flow_if_necessary(block, solution);
+    }
+
+}
+