Remove border collapse argument from compute_border_and_padding

components/layout/block.rs

@@ -51,7 +51,7 @@ use servo_geometry::max_rect;
 use std::cmp::{max, min};
 use std::fmt;
 use std::sync::Arc;
-use style::computed_values::{border_collapse, box_sizing, display, float, overflow_x};
+use style::computed_values::{box_sizing, display, float, overflow_x};
 use style::computed_values::{position, text_align};
 use style::context::SharedStyleContext;
 use style::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize, WritingMode};
@@ -2268,8 +2268,7 @@ impl ISizeConstraintSolution {
 pub trait ISizeAndMarginsComputer {
     /// Instructs the fragment to compute its border and padding.
     fn compute_border_and_padding(&self, block: &mut BlockFlow, containing_block_inline_size: Au) {
-        block.fragment.compute_border_and_padding(containing_block_inline_size,
-                                                  border_collapse::T::separate);
+        block.fragment.compute_border_and_padding(containing_block_inline_size);
     }
 
     /// Compute the inputs for the ISize constraint equation.

components/layout/flex.rs

@@ -21,7 +21,6 @@ use model::{IntrinsicISizes, MaybeAuto, SizeConstraint};
 use std::cmp::{max, min};
 use std::ops::Range;
 use style::computed_values::{align_content, align_self, flex_direction, flex_wrap, justify_content};
-use style::computed_values::border_collapse;
 use style::logical_geometry::{Direction, LogicalSize};
 use style::properties::ComputedValues;
 use style::servo::restyle_damage::{REFLOW, REFLOW_OUT_OF_FLOW};
@@ -160,8 +159,7 @@ impl FlexItem {
                                             Some(containing_length));
 
                 // These methods compute auto margins to zero length, which is exactly what we want.
-                block.fragment.compute_border_and_padding(containing_length,
-                                                          border_collapse::T::separate);
+                block.fragment.compute_border_and_padding(containing_length);
                 block.fragment.compute_inline_direction_margins(containing_length);
                 block.fragment.compute_block_direction_margins(containing_length);
 

components/layout/fragment.rs

@@ -1305,14 +1305,10 @@ impl Fragment {
     /// Computes the border and padding in both inline and block directions from the containing
     /// block inline-size and the style. After this call, the `border_padding` field will be
     /// correct.
-    ///
-    /// TODO(pcwalton): Remove `border_collapse`; we can figure it out from our style and specific
-    /// fragment info.
     pub fn compute_border_and_padding(&mut self,
-                                      containing_block_inline_size: Au,
-                                      border_collapse: border_collapse::T) {
+                                      containing_block_inline_size: Au) {
         // Compute border.
-        let border = match border_collapse {
+        let border = match self.style.get_inheritedtable().border_collapse {
             border_collapse::T::separate => self.border_width(),
             border_collapse::T::collapse => LogicalMargin::zero(self.style.writing_mode),
         };

components/layout/inline.rs

@@ -1399,8 +1399,7 @@ impl Flow for InlineFlow {
         {
             let this = &mut *self;
             for fragment in this.fragments.fragments.iter_mut() {
-                let border_collapse = fragment.style.get_inheritedtable().border_collapse;
-                fragment.compute_border_and_padding(inline_size, border_collapse);
+                fragment.compute_border_and_padding(inline_size);
                 fragment.compute_block_direction_margins(inline_size);
                 fragment.compute_inline_direction_margins(inline_size);
                 fragment.assign_replaced_inline_size_if_necessary(inline_size, container_block_size);

components/layout/table.rs

@@ -545,8 +545,7 @@ pub struct InternalTable {
 
 impl ISizeAndMarginsComputer for InternalTable {
     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)
+        block.fragment.compute_border_and_padding(containing_block_inline_size)
     }
 
     /// Compute the used value of inline-size, taking care of min-inline-size and max-inline-size.

components/layout/table_wrapper.rs

@@ -27,7 +27,7 @@ use model::MaybeAuto;
 use std::cmp::{max, min};
 use std::fmt;
 use std::ops::Add;
-use style::computed_values::{border_collapse, position, table_layout};
+use style::computed_values::{position, table_layout};
 use style::context::SharedStyleContext;
 use style::logical_geometry::{LogicalRect, LogicalSize};
 use style::properties::ComputedValues;
@@ -96,16 +96,14 @@ impl TableWrapperFlow {
     // tables are separated into table flows and table wrapper flows.
     fn compute_border_and_padding_of_table(&mut self) {
         let available_inline_size = self.block_flow.base.block_container_inline_size;
-        let border_collapse = self.block_flow.fragment.style.get_inheritedtable().border_collapse;
         for kid in self.block_flow.base.child_iter_mut() {
             if !kid.is_table() {
                 continue
             }
 
             let kid_table = kid.as_mut_table();
             let kid_block_flow = &mut kid_table.block_flow;
-            kid_block_flow.fragment.compute_border_and_padding(available_inline_size,
-                                                               border_collapse);
+            kid_block_flow.fragment.compute_border_and_padding(available_inline_size);
             kid_block_flow.fragment.compute_block_direction_margins(available_inline_size);
             kid_block_flow.fragment.compute_inline_direction_margins(available_inline_size);
             return
@@ -232,12 +230,10 @@ impl TableWrapperFlow {
 
         // Delegate to the appropriate inline size computer to find the constraint inputs and write
         // the constraint solutions in.
-        let border_collapse = self.block_flow.fragment.style.get_inheritedtable().border_collapse;
         if self.block_flow.base.flags.is_float() {
             let inline_size_computer = FloatedTable {
                 minimum_width_of_all_columns: minimum_width_of_all_columns,
                 preferred_width_of_all_columns: preferred_width_of_all_columns,
-                border_collapse: border_collapse,
                 table_border_padding: border_padding,
             };
             let input =
@@ -258,7 +254,6 @@ impl TableWrapperFlow {
             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,
                 table_border_padding: border_padding,
             };
             let input =
@@ -278,7 +273,6 @@ impl TableWrapperFlow {
         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,
-            border_collapse: border_collapse,
             table_border_padding: border_padding,
         };
         let input =
@@ -786,14 +780,12 @@ fn initial_computed_inline_size(block: &mut BlockFlow,
 struct Table {
     minimum_width_of_all_columns: Au,
     preferred_width_of_all_columns: Au,
-    border_collapse: border_collapse::T,
     table_border_padding: Au,
 }
 
 impl ISizeAndMarginsComputer for Table {
     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)
+        block.fragment.compute_border_and_padding(containing_block_inline_size)
     }
 
     fn initial_computed_inline_size(&self,
@@ -821,14 +813,12 @@ impl ISizeAndMarginsComputer for Table {
 struct FloatedTable {
     minimum_width_of_all_columns: Au,
     preferred_width_of_all_columns: Au,
-    border_collapse: border_collapse::T,
     table_border_padding: Au,
 }
 
 impl ISizeAndMarginsComputer for FloatedTable {
     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)
+        block.fragment.compute_border_and_padding(containing_block_inline_size)
     }
 
     fn initial_computed_inline_size(&self,
@@ -858,14 +848,12 @@ impl ISizeAndMarginsComputer for FloatedTable {
 struct AbsoluteTable {
     minimum_width_of_all_columns: Au,
     preferred_width_of_all_columns: Au,
-    border_collapse: border_collapse::T,
     table_border_padding: Au,
 }
 
 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)
+        block.fragment.compute_border_and_padding(containing_block_inline_size)
     }
 
     fn initial_computed_inline_size(&self,