Remove min/max functions from util::geometry. Use std::cmp instead.

components/layout/block.rs

@@ -38,9 +38,9 @@ use gfx::display_list::{RootOfStackingContextLevel};
 use gfx::render_task::RenderLayer;
 use servo_msg::compositor_msg::{FixedPosition, LayerId, Scrollable};
 use servo_util::geometry::Au;
-use servo_util::geometry;
 use servo_util::logical_geometry::WritingMode;
 use servo_util::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize};
+use std::cmp::{max, min};
 use std::fmt;
 use std::mem;
 use style::computed_values::{LPA_Auto, LPA_Length, LPA_Percentage, LPN_Length, LPN_None};
@@ -723,8 +723,8 @@ impl BlockFlow {
     /// This is where we use the preferred inline-sizes and minimum inline-sizes
     /// calculated in the bubble-inline-sizes traversal.
     fn get_shrink_to_fit_inline_size(&self, available_inline_size: Au) -> Au {
-        geometry::min(self.base.intrinsic_inline_sizes.preferred_inline_size,
+        min(self.base.intrinsic_inline_sizes.preferred_inline_size,
-                      geometry::max(self.base.intrinsic_inline_sizes.minimum_inline_size, available_inline_size))
+                      max(self.base.intrinsic_inline_sizes.minimum_inline_size, available_inline_size))
     }
 
     /// Collect and update static y-offsets bubbled up by kids.
@@ -1090,7 +1090,7 @@ impl BlockFlow {
 
         // Intrinsic height should include floating descendants with a margin
         // below the element's bottom edge (see CSS Section 10.6.7).
-        let content_block_size = geometry::max(
+        let content_block_size = max(
             cur_b - block_start_offset,
             floats.clearance(ClearBoth));
 
@@ -1509,13 +1509,13 @@ impl Flow for BlockFlow {
 
             if !fixed_width {
                 intrinsic_inline_sizes.minimum_inline_size =
-                    geometry::max(intrinsic_inline_sizes.minimum_inline_size,
+                    max(intrinsic_inline_sizes.minimum_inline_size,
                                   child_base.intrinsic_inline_sizes.total_minimum_inline_size());
 
                 match float_kind {
                     float::none => {
                         intrinsic_inline_sizes.preferred_inline_size =
-                            geometry::max(intrinsic_inline_sizes.preferred_inline_size,
+                            max(intrinsic_inline_sizes.preferred_inline_size,
                                   child_base.intrinsic_inline_sizes.total_preferred_inline_size());
                     }
                     float::left => {
@@ -1533,13 +1533,13 @@ impl Flow for BlockFlow {
         }
 
         intrinsic_inline_sizes.preferred_inline_size =
-            geometry::max(intrinsic_inline_sizes.preferred_inline_size,
+            max(intrinsic_inline_sizes.preferred_inline_size,
                           left_float_width + right_float_width);
 
         let fragment_intrinsic_inline_sizes = self.fragment.intrinsic_inline_sizes();
-        intrinsic_inline_sizes.minimum_inline_size = geometry::max(intrinsic_inline_sizes.minimum_inline_size,
+        intrinsic_inline_sizes.minimum_inline_size = max(intrinsic_inline_sizes.minimum_inline_size,
                                                        fragment_intrinsic_inline_sizes.minimum_inline_size);
-        intrinsic_inline_sizes.preferred_inline_size = geometry::max(intrinsic_inline_sizes.preferred_inline_size,
+        intrinsic_inline_sizes.preferred_inline_size = max(intrinsic_inline_sizes.preferred_inline_size,
                                                          fragment_intrinsic_inline_sizes.preferred_inline_size);
         intrinsic_inline_sizes.surround_inline_size = fragment_intrinsic_inline_sizes.surround_inline_size;
         self.base.intrinsic_inline_sizes = intrinsic_inline_sizes;

components/layout/floats.rs

@@ -2,9 +2,10 @@
  * 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/. */
 
-use servo_util::geometry::{Au, max, min};
+use servo_util::geometry::Au;
 use servo_util::logical_geometry::WritingMode;
 use servo_util::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize};
+use std::cmp::{max, min};
 use std::i32;
 use std::fmt;
 use style::computed_values::float;

components/layout/fragment.rs

@@ -46,6 +46,7 @@ use servo_util::range::*;
 use servo_util::namespace;
 use servo_util::smallvec::SmallVec;
 use servo_util::str::is_whitespace;
+use std::cmp::{max, min};
 use std::fmt;
 use std::from_str::FromStr;
 use std::mem;
@@ -1165,17 +1166,17 @@ impl Fragment {
             TableWrapperFragment => {}
             InlineBlockFragment(ref mut info) => {
                 let block_flow = info.flow_ref.get_mut().as_block();
-                result.minimum_inline_size = geometry::max(result.minimum_inline_size,
+                result.minimum_inline_size = max(result.minimum_inline_size,
                         block_flow.base.intrinsic_inline_sizes.minimum_inline_size +
                         block_flow.base.intrinsic_inline_sizes.surround_inline_size);
-                result.preferred_inline_size = geometry::max(result.preferred_inline_size,
+                result.preferred_inline_size = max(result.preferred_inline_size,
                         block_flow.base.intrinsic_inline_sizes.preferred_inline_size +
                         block_flow.base.intrinsic_inline_sizes.surround_inline_size);
             },
             ImageFragment(ref mut image_fragment_info) => {
                 let image_inline_size = image_fragment_info.image_inline_size();
-                result.minimum_inline_size = geometry::max(result.minimum_inline_size, image_inline_size);
+                result.minimum_inline_size = max(result.minimum_inline_size, image_inline_size);
-                result.preferred_inline_size = geometry::max(result.preferred_inline_size, image_inline_size);
+                result.preferred_inline_size = max(result.preferred_inline_size, image_inline_size);
             }
             ScannedTextFragment(ref text_fragment_info) => {
                 let range = &text_fragment_info.range;
@@ -1185,8 +1186,8 @@ impl Fragment {
                 // TODO: Account for soft wrap opportunities.
                 let max_line_inline_size = text_fragment_info.run.metrics_for_range(range).advance_width;
 
-                result.minimum_inline_size = geometry::max(result.minimum_inline_size, min_line_inline_size);
+                result.minimum_inline_size = max(result.minimum_inline_size, min_line_inline_size);
-                result.preferred_inline_size = geometry::max(result.preferred_inline_size, max_line_inline_size);
+                result.preferred_inline_size = max(result.preferred_inline_size, max_line_inline_size);
             }
             UnscannedTextFragment(..) => fail!("Unscanned text fragments should have been scanned by now!"),
         }

components/layout/inline.rs

@@ -23,10 +23,10 @@ use gfx::font_context::FontContext;
 use geom::Size2D;
 use gfx::text::glyph::CharIndex;
 use servo_util::geometry::Au;
-use servo_util::geometry;
 use servo_util::logical_geometry::{LogicalRect, LogicalSize};
 use servo_util::range;
 use servo_util::range::{EachIndex, Range, RangeIndex, IntRangeIndex};
+use std::cmp::max;
 use std::fmt;
 use std::mem;
 use std::num;
@@ -928,7 +928,7 @@ impl Flow for InlineFlow {
 
             let fragment_intrinsic_inline_sizes =
                 fragment.intrinsic_inline_sizes();
-            intrinsic_inline_sizes.minimum_inline_size = geometry::max(
+            intrinsic_inline_sizes.minimum_inline_size = max(
                 intrinsic_inline_sizes.minimum_inline_size,
                 fragment_intrinsic_inline_sizes.minimum_inline_size);
             intrinsic_inline_sizes.preferred_inline_size =

components/layout/model.rs

@@ -13,8 +13,8 @@ use geom::SideOffsets2D;
 use style::computed_values::{LPA_Auto, LPA_Length, LPA_Percentage, LP_Length, LP_Percentage};
 use style::ComputedValues;
 use servo_util::geometry::Au;
-use servo_util::geometry;
 use servo_util::logical_geometry::LogicalMargin;
+use std::cmp::{max, min};
 use std::fmt;
 
 /// A collapsible margin. See CSS 2.1 § 8.3.1.
@@ -50,8 +50,8 @@ impl AdjoiningMargins {
     }
 
     pub fn union(&mut self, other: AdjoiningMargins) {
-        self.most_positive = geometry::max(self.most_positive, other.most_positive);
+        self.most_positive = max(self.most_positive, other.most_positive);
-        self.most_negative = geometry::min(self.most_negative, other.most_negative)
+        self.most_negative = min(self.most_negative, other.most_negative)
     }
 
     pub fn collapse(&self) -> Au {

components/layout/table.rs

@@ -17,8 +17,8 @@ use table_wrapper::{TableLayout, FixedLayout, AutoLayout};
 use wrapper::ThreadSafeLayoutNode;
 
 use servo_util::geometry::Au;
-use servo_util::geometry;
 use servo_util::logical_geometry::LogicalRect;
+use std::cmp::max;
 use std::fmt;
 use style::computed_values::table_layout;
 
@@ -233,7 +233,7 @@ impl Flow for TableFlow {
         let fragment_intrinsic_inline_sizes = self.block_flow.fragment.intrinsic_inline_sizes();
         self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = min_inline_size;
         self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size =
-            geometry::max(min_inline_size, pref_inline_size);
+            max(min_inline_size, pref_inline_size);
         self.block_flow.base.intrinsic_inline_sizes.surround_inline_size =
             fragment_intrinsic_inline_sizes.surround_inline_size;
     }

components/layout/table_row.rs

@@ -18,7 +18,7 @@ use model::{MaybeAuto, Specified, Auto};
 use wrapper::ThreadSafeLayoutNode;
 
 use servo_util::geometry::Au;
-use servo_util::geometry;
+use std::cmp::max;
 use std::fmt;
 
 /// A table formatting context.
@@ -91,19 +91,19 @@ impl TableRowFlow {
                 let child_specified_block_size = MaybeAuto::from_style(child_fragment.style().content_block_size(),
                                                                    Au::new(0)).specified_or_zero();
                 max_y =
-                    geometry::max(max_y,
+                    max(max_y,
                                   child_specified_block_size + child_fragment.border_padding.block_start_end());
             }
             let child_node = flow::mut_base(kid);
             child_node.position.start.b = cur_y;
-            max_y = geometry::max(max_y, child_node.position.size.block);
+            max_y = max(max_y, child_node.position.size.block);
         }
 
         let mut block_size = max_y;
         // TODO: Percentage block-size
         block_size = match MaybeAuto::from_style(self.block_flow.fragment.style().content_block_size(), Au(0)) {
             Auto => block_size,
-            Specified(value) => geometry::max(value, block_size)
+            Specified(value) => max(value, block_size)
         };
         // cur_y = cur_y + block-size;
 
@@ -188,8 +188,8 @@ impl Flow for TableRowFlow {
             pref_inline_size = pref_inline_size + child_base.intrinsic_inline_sizes.preferred_inline_size;
         }
         self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = min_inline_size;
-        self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = geometry::max(min_inline_size,
+        self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = max(
-                                                                              pref_inline_size);
+            min_inline_size, pref_inline_size);
     }
 
     /// Recursively (top-down) determines the actual inline-size of child contexts and fragments. When called

components/layout/table_rowgroup.rs

@@ -17,7 +17,7 @@ use table::{InternalTable, TableFlow};
 use wrapper::ThreadSafeLayoutNode;
 
 use servo_util::geometry::Au;
-use servo_util::geometry;
+use std::cmp::max;
 use std::fmt;
 
 /// A table formatting context.
@@ -169,8 +169,8 @@ impl Flow for TableRowGroupFlow {
         }
 
         self.block_flow.base.intrinsic_inline_sizes.minimum_inline_size = min_inline_size;
-        self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = geometry::max(min_inline_size,
+        self.block_flow.base.intrinsic_inline_sizes.preferred_inline_size = max(
-                                                                              pref_inline_size);
+            min_inline_size, pref_inline_size);
     }
 
     /// Recursively (top-down) determines the actual inline-size of child contexts and fragments. When

components/layout/table_wrapper.rs

@@ -17,7 +17,7 @@ use model::{Specified, Auto, specified};
 use wrapper::ThreadSafeLayoutNode;
 
 use servo_util::geometry::Au;
-use servo_util::geometry;
+use std::cmp::max;
 use std::fmt;
 use style::computed_values::table_layout;
 
@@ -250,7 +250,7 @@ impl TableWrapper {
 
                 // Compare border-edge inline-sizes. Because fixed_cells_inline-size indicates content-inline-size,
                 // padding and border values are added to fixed_cells_inline-size.
-                computed_inline_size = geometry::max(
+                computed_inline_size = max(
                     fixed_cells_inline_size + padding_and_borders, computed_inline_size);
                 computed_inline_size
             },
@@ -276,7 +276,7 @@ impl TableWrapper {
                 // required by all columns. It will be distributed over the columns.
                 let (inline_size, extra_inline_size) = match input.computed_inline_size {
                     Auto => {
-                        if input.available_inline_size > geometry::max(cols_max, cap_min) {
+                        if input.available_inline_size > max(cols_max, cap_min) {
                             if cols_max > cap_min {
                                 table_wrapper.col_inline_sizes = col_pref_inline_sizes.clone();
                                 (cols_max, Au(0))
@@ -288,7 +288,7 @@ impl TableWrapper {
                                 table_wrapper.col_inline_sizes = col_min_inline_sizes.clone();
                                 cols_min
                             } else {
-                                geometry::max(input.available_inline_size, cap_min)
+                                max(input.available_inline_size, cap_min)
                             };
                             (max, max - cols_min)
                         }
@@ -298,7 +298,7 @@ impl TableWrapper {
                             table_wrapper.col_inline_sizes = col_min_inline_sizes.clone();
                             cols_min
                         } else {
-                            geometry::max(inline_size, cap_min)
+                            max(inline_size, cap_min)
                         };
                         (max, max - cols_min)
                     }

components/util/geometry.rs

@@ -134,10 +134,6 @@ impl Neg<Au> for Au {
     }
 }
 
-#[inline]
-pub fn min(x: Au, y: Au) -> Au { if x < y { x } else { y } }
-#[inline]
-pub fn max(x: Au, y: Au) -> Au { if x > y { x } else { y } }
 
 impl NumCast for Au {
     #[inline]