Rustfmt layout crate

1 files changed, 135 insertions, 81 deletions

diff --git a/components/layout/table_cell.rs b/components/layout/table_cell.rs
index fe8d453cb0b..1af32166a5f 100644
--- a/components/layout/table_cell.rs
+++ b/components/layout/table_cell.rs
@@ -63,7 +63,10 @@ impl TableCellFlow {
     }
 
     pub fn from_node_fragment_and_visibility_flag<N: ThreadSafeLayoutNode>(
-            node: &N, fragment: Fragment, visible: bool) -> TableCellFlow {
+        node: &N,
+        fragment: Fragment,
+        visible: bool,
+    ) -> TableCellFlow {
         TableCellFlow {
             block_flow: BlockFlow::from_fragment(fragment),
             collapsed_borders: CollapsedBordersForCell::new(),
@@ -90,7 +93,8 @@ impl TableCellFlow {
         let remaining = self.block_flow.assign_block_size_block_base(
             layout_context,
             None,
-            MarginsMayCollapseFlag::MarginsMayNotCollapse);
+            MarginsMayCollapseFlag::MarginsMayNotCollapse,
+        );
         debug_assert!(remaining.is_none());
     }
 
@@ -102,12 +106,14 @@ impl TableCellFlow {
         for kid in self.base().children.iter() {
             let kid_base = kid.base();
             if kid_base.flags.contains(FlowFlags::IS_ABSOLUTELY_POSITIONED) {
-                continue
+                continue;
             }
-            let start = kid_base.position.start.b -
-                kid_base.collapsible_margins.block_start_margin_for_noncollapsible_context();
-            let end = kid_base.position.start.b + kid_base.position.size.block +
-                kid_base.collapsible_margins.block_end_margin_for_noncollapsible_context();
+            let start = kid_base.position.start.b - kid_base
+                .collapsible_margins
+                .block_start_margin_for_noncollapsible_context();
+            let end = kid_base.position.start.b + kid_base.position.size.block + kid_base
+                .collapsible_margins
+                .block_end_margin_for_noncollapsible_context();
             match extents {
                 Some((ref mut first_start, ref mut last_end)) => {
                     if start < *first_start {
@@ -116,7 +122,7 @@ impl TableCellFlow {
                     if end > *last_end {
                         *last_end = end
                     }
-                }
+                },
                 None => extents = Some((start, end)),
             }
         }
@@ -138,7 +144,7 @@ impl TableCellFlow {
             _ => Au(0),
         };
         if offset == Au(0) {
-            return
+            return;
         }
 
         for kid in self.mut_base().children.iter_mut() {
@@ -154,9 +160,8 @@ impl TableCellFlow {
     // Call after block size calculation
     pub fn total_block_size(&mut self) -> Au {
         // TODO: Percentage block-size
-        let specified = MaybeAuto::from_style(self.fragment().style()
-                                                  .content_block_size(),
-                                              Au(0)).specified_or_zero();
+        let specified = MaybeAuto::from_style(self.fragment().style().content_block_size(), Au(0))
+            .specified_or_zero();
         specified + self.fragment().border_padding.block_start_end()
     }
 }
@@ -185,23 +190,46 @@ impl Flow for TableCellFlow {
     /// Minimum/preferred inline-sizes set by this function are used in automatic table layout
     /// calculation.
     fn bubble_inline_sizes(&mut self) {
-        let _scope = layout_debug_scope!("table_cell::bubble_inline_sizes {:x}",
-                                         self.block_flow.base.debug_id());
+        let _scope = layout_debug_scope!(
+            "table_cell::bubble_inline_sizes {:x}",
+            self.block_flow.base.debug_id()
+        );
 
         self.block_flow.bubble_inline_sizes_for_block(true);
-        let specified_inline_size = MaybeAuto::from_style(self.block_flow
-                                                              .fragment
-                                                              .style()
-                                                              .content_inline_size(),
-                                                          Au(0)).specified_or_zero();
-        if self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size <
-                specified_inline_size {
-            self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = specified_inline_size
+        let specified_inline_size = MaybeAuto::from_style(
+            self.block_flow.fragment.style().content_inline_size(),
+            Au(0),
+        ).specified_or_zero();
+        if self
+            .block_flow
+            .base
+            .intrinsic_inline_sizes
+            .minimum_inline_size <
+            specified_inline_size
+        {
+            self.block_flow
+                .base
+                .intrinsic_inline_sizes
+                .minimum_inline_size = specified_inline_size
         }
-        if self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size <
-                self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size {
-            self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size =
-                self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size;
+        if self
+            .block_flow
+            .base
+            .intrinsic_inline_sizes
+            .preferred_inline_size <
+            self.block_flow
+                .base
+                .intrinsic_inline_sizes
+                .minimum_inline_size
+        {
+            self.block_flow
+                .base
+                .intrinsic_inline_sizes
+                .preferred_inline_size = self
+                .block_flow
+                .base
+                .intrinsic_inline_sizes
+                .minimum_inline_size;
         }
     }
 
@@ -209,35 +237,42 @@ impl Flow for TableCellFlow {
     /// When called on this context, the context has had its inline-size set by the parent table
     /// row.
     fn assign_inline_sizes(&mut self, layout_context: &LayoutContext) {
-        let _scope = layout_debug_scope!("table_cell::assign_inline_sizes {:x}",
-                                            self.block_flow.base.debug_id());
-        debug!("assign_inline_sizes({}): assigning inline_size for flow", "table_cell");
+        let _scope = layout_debug_scope!(
+            "table_cell::assign_inline_sizes {:x}",
+            self.block_flow.base.debug_id()
+        );
+        debug!(
+            "assign_inline_sizes({}): assigning inline_size for flow",
+            "table_cell"
+        );
 
         let shared_context = layout_context.shared_context();
         // The position was set to the column inline-size by the parent flow, table row flow.
         let containing_block_inline_size = self.block_flow.base.block_container_inline_size;
 
         let inline_size_computer = InternalTable;
-        inline_size_computer.compute_used_inline_size(&mut self.block_flow,
-                                                      shared_context,
-                                                      containing_block_inline_size);
+        inline_size_computer.compute_used_inline_size(
+            &mut self.block_flow,
+            shared_context,
+            containing_block_inline_size,
+        );
 
-        let inline_start_content_edge =
-            self.block_flow.fragment.border_box.start.i +
+        let inline_start_content_edge = self.block_flow.fragment.border_box.start.i +
             self.block_flow.fragment.border_padding.inline_start;
-        let inline_end_content_edge =
-            self.block_flow.base.block_container_inline_size -
+        let inline_end_content_edge = self.block_flow.base.block_container_inline_size -
             self.block_flow.fragment.border_padding.inline_start_end() -
             self.block_flow.fragment.border_box.size.inline;
         let padding_and_borders = self.block_flow.fragment.border_padding.inline_start_end();
         let content_inline_size =
             self.block_flow.fragment.border_box.size.inline - padding_and_borders;
 
-        self.block_flow.propagate_assigned_inline_size_to_children(shared_context,
-                                                                   inline_start_content_edge,
-                                                                   inline_end_content_edge,
-                                                                   content_inline_size,
-                                                                   |_, _, _, _, _, _| {});
+        self.block_flow.propagate_assigned_inline_size_to_children(
+            shared_context,
+            inline_start_content_edge,
+            inline_end_content_edge,
+            content_inline_size,
+            |_, _, _, _, _, _| {},
+        );
     }
 
     fn assign_block_size(&mut self, layout_context: &LayoutContext) {
@@ -246,15 +281,18 @@ impl Flow for TableCellFlow {
     }
 
     fn compute_stacking_relative_position(&mut self, layout_context: &LayoutContext) {
-        self.block_flow.compute_stacking_relative_position(layout_context)
+        self.block_flow
+            .compute_stacking_relative_position(layout_context)
     }
 
     fn update_late_computed_inline_position_if_necessary(&mut self, inline_position: Au) {
-        self.block_flow.update_late_computed_inline_position_if_necessary(inline_position)
+        self.block_flow
+            .update_late_computed_inline_position_if_necessary(inline_position)
     }
 
     fn update_late_computed_block_position_if_necessary(&mut self, block_position: Au) {
-        self.block_flow.update_late_computed_block_position_if_necessary(block_position)
+        self.block_flow
+            .update_late_computed_block_position_if_necessary(block_position)
     }
 
     fn build_display_list(&mut self, _: &mut DisplayListBuildState) {
@@ -264,12 +302,15 @@ impl Flow for TableCellFlow {
 
         // we skip setting the damage in TableCellStyleInfo::build_display_list()
         // because we only have immutable access
-        self.block_flow.fragment.restyle_damage.remove(ServoRestyleDamage::REPAINT);
+        self.block_flow
+            .fragment
+            .restyle_damage
+            .remove(ServoRestyleDamage::REPAINT);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut StackingContextCollectionState) {
-        self.block_flow.collect_stacking_contexts_for_block(state,
-                                                            StackingContextCollectionFlags::empty());
+        self.block_flow
+            .collect_stacking_contexts_for_block(state, StackingContextCollectionFlags::empty());
     }
 
     fn repair_style(&mut self, new_style: &::ServoArc<ComputedValues>) {
@@ -292,11 +333,17 @@ impl Flow for TableCellFlow {
         self.block_flow.generated_containing_block_size(flow)
     }
 
-    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 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)) {
@@ -379,67 +426,74 @@ impl CollapsedBordersForCell {
         }
     }
 
-    pub fn adjust_border_bounds_for_painting(&self,
-                                             border_bounds: &mut Rect<Au>,
-                                             writing_mode: WritingMode) {
+    pub fn adjust_border_bounds_for_painting(
+        &self,
+        border_bounds: &mut Rect<Au>,
+        writing_mode: WritingMode,
+    ) {
         let inline_start_divisor = if self.should_paint_inline_start_border() {
             2
         } else {
             -2
         };
-        let inline_start_offset = self.inline_start_width / 2 + self.inline_start_border.width /
-            inline_start_divisor;
+        let inline_start_offset =
+            self.inline_start_width / 2 + self.inline_start_border.width / inline_start_divisor;
         let inline_end_divisor = if self.should_paint_inline_end_border() {
             2
         } else {
             -2
         };
-        let inline_end_offset = self.inline_end_width / 2 + self.inline_end_border.width /
-            inline_end_divisor;
+        let inline_end_offset =
+            self.inline_end_width / 2 + self.inline_end_border.width / inline_end_divisor;
         let block_start_divisor = if self.should_paint_block_start_border() {
             2
         } else {
             -2
         };
-        let block_start_offset = self.block_start_width / 2 + self.block_start_border.width /
-            block_start_divisor;
+        let block_start_offset =
+            self.block_start_width / 2 + self.block_start_border.width / block_start_divisor;
         let block_end_divisor = if self.should_paint_block_end_border() {
             2
         } else {
             -2
         };
-        let block_end_offset = self.block_end_width / 2 + self.block_end_border.width /
-            block_end_divisor;
+        let block_end_offset =
+            self.block_end_width / 2 + self.block_end_border.width / block_end_divisor;
 
         // FIXME(pcwalton): Get the real container size.
         let mut logical_bounds =
             LogicalRect::from_physical(writing_mode, *border_bounds, Size2D::new(Au(0), Au(0)));
         logical_bounds.start.i = logical_bounds.start.i - inline_start_offset;
         logical_bounds.start.b = logical_bounds.start.b - block_start_offset;
-        logical_bounds.size.inline = logical_bounds.size.inline + inline_start_offset +
-            inline_end_offset;
-        logical_bounds.size.block = logical_bounds.size.block + block_start_offset +
-            block_end_offset;
+        logical_bounds.size.inline =
+            logical_bounds.size.inline + inline_start_offset + inline_end_offset;
+        logical_bounds.size.block =
+            logical_bounds.size.block + block_start_offset + block_end_offset;
         *border_bounds = logical_bounds.to_physical(writing_mode, Size2D::new(Au(0), Au(0)))
     }
 
     pub fn adjust_border_colors_and_styles_for_painting(
-            &self,
-            border_colors: &mut SideOffsets2D<Color>,
-            border_styles: &mut SideOffsets2D<BorderStyle>,
-            writing_mode: WritingMode) {
-        let logical_border_colors = LogicalMargin::new(writing_mode,
-                                                       self.block_start_border.color,
-                                                       self.inline_end_border.color,
-                                                       self.block_end_border.color,
-                                                       self.inline_start_border.color);
+        &self,
+        border_colors: &mut SideOffsets2D<Color>,
+        border_styles: &mut SideOffsets2D<BorderStyle>,
+        writing_mode: WritingMode,
+    ) {
+        let logical_border_colors = LogicalMargin::new(
+            writing_mode,
+            self.block_start_border.color,
+            self.inline_end_border.color,
+            self.block_end_border.color,
+            self.inline_start_border.color,
+        );
         *border_colors = logical_border_colors.to_physical(writing_mode);
 
-        let logical_border_styles = LogicalMargin::new(writing_mode,
-                                                       self.block_start_border.style,
-                                                       self.inline_end_border.style,
-                                                       self.block_end_border.style,
-                                                       self.inline_start_border.style);
+        let logical_border_styles = LogicalMargin::new(
+            writing_mode,
+            self.block_start_border.style,
+            self.inline_end_border.style,
+            self.block_end_border.style,
+            self.inline_start_border.style,
+        );
         *border_styles = logical_border_styles.to_physical(writing_mode);
     }
 }