Merge pull request #3424 from SimonSapin/font-size-absolute

Add font-size absolute size keywords. Fix #3417

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;
@@ -1168,17 +1169,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;
@@ -1188,8 +1189,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;
     }
@@ -273,7 +273,7 @@ impl Flow for TableFlow {
                         *col_inline_size = (*col_inline_size).scale_by(ratio);
                     }
                 } else if num_unspecified_inline_sizes != 0 {
-                    let extra_column_inline_size = (content_inline_size - total_column_inline_size) / Au::new(num_unspecified_inline_sizes);
+                    let extra_column_inline_size = (content_inline_size - total_column_inline_size) / num_unspecified_inline_sizes;
                     for col_inline_size in self.col_inline_sizes.mut_iter() {
                         if *col_inline_size == Au(0) {
                             *col_inline_size = extra_column_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/style/properties/mod.rs.mako

@@ -904,8 +904,9 @@ pub mod longhands {
             use super::super::Au;
             pub type T = Au;
         }
+        static MEDIUM_PX: int = 16;
         #[inline] pub fn get_initial_value() -> computed_value::T {
-            Au::from_px(16)  // medium
+            Au::from_px(MEDIUM_PX)
         }
         #[inline]
         pub fn to_computed_value(_value: SpecifiedValue, context: &computed::Context)
@@ -913,16 +914,26 @@ pub mod longhands {
             // We already computed this element's font size; no need to compute it again.
             return context.font_size
         }
-        /// <length> | <percentage>
+        /// <length> | <percentage> | <absolute-size>
-        /// TODO: support <absolute-size> and <relative-size>
+        /// TODO: support <relative-size>
         pub fn from_component_value(input: &ComponentValue, _base_url: &Url)
                                     -> Result<SpecifiedValue, ()> {
-            specified::LengthOrPercentage::parse_non_negative(input).map(|value| {
+            match specified::LengthOrPercentage::parse_non_negative(input) {
-                match value {
+                Ok(specified::LP_Length(value)) => return Ok(value),
-                    specified::LP_Length(value) => value,
+                Ok(specified::LP_Percentage(value)) => return Ok(specified::Em(value)),
-                    specified::LP_Percentage(value) => specified::Em(value),
+                Err(()) => (),
-                }
+            }
-            })
+            let au = match try!(get_ident_lower(input)).as_slice() {
+                "xx-small" => Au::from_px(MEDIUM_PX) * 3 / 5,
+                "x-small" => Au::from_px(MEDIUM_PX) * 3 / 4,
+                "small" => Au::from_px(MEDIUM_PX) * 8 / 9,
+                "medium" => Au::from_px(MEDIUM_PX),
+                "large" => Au::from_px(MEDIUM_PX) * 6 / 5,
+                "x-large" => Au::from_px(MEDIUM_PX) * 3 / 2,
+                "xx-large" => Au::from_px(MEDIUM_PX) * 2,
+                _ => return Err(())
+            };
+            Ok(specified::Au_(au))
         }
     </%self:single_component_value>
 

components/util/geometry.rs

@@ -9,7 +9,7 @@ use geom::size::Size2D;
 
 use serialize::{Encodable, Encoder};
 use std::default::Default;
-use std::num::{NumCast, One, Zero};
+use std::num::{NumCast, Zero};
 use std::fmt;
 
 // Units for use with geom::length and geom::scale_factor.
@@ -102,30 +102,27 @@ impl Sub<Au,Au> for Au {
 
 }
 
-impl Mul<Au,Au> for Au {
+impl Mul<i32, Au> for Au {
     #[inline]
-    fn mul(&self, other: &Au) -> Au {
+    fn mul(&self, other: &i32) -> Au {
         let Au(s) = *self;
-        let Au(o) = *other;
+        Au(s * *other)
-        Au(s * o)
     }
 }
 
-impl Div<Au,Au> for Au {
+impl Div<i32, Au> for Au {
     #[inline]
-    fn div(&self, other: &Au) -> Au {
+    fn div(&self, other: &i32) -> Au {
         let Au(s) = *self;
-        let Au(o) = *other;
+        Au(s / *other)
-        Au(s / o)
     }
 }
 
-impl Rem<Au,Au> for Au {
+impl Rem<i32, Au> for Au {
     #[inline]
-    fn rem(&self, other: &Au) -> Au {
+    fn rem(&self, other: &i32) -> Au {
         let Au(s) = *self;
-        let Au(o) = *other;
+        Au(s % *other)
-        Au(s % o)
     }
 }
 
@@ -137,17 +134,6 @@ impl Neg<Au> for Au {
     }
 }
 
-impl One for Au {
-    #[inline]
-    fn one() -> Au { Au(1) }
-}
-
-impl Num 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]

tests/ref/basic.list

@@ -23,8 +23,7 @@
 == text_decoration_cached.html text_decoration_cached_ref.html
 # text_decoration_propagation_a.html text_decoration_propagation_b.html
 # inline_text_align_a.html inline_text_align_b.html
-== font_size_em.html font_size_em_ref.html
+== font_size.html font_size_ref.html
-== font_size_percentage.html font_size_em_ref.html
 == img_size_a.html img_size_b.html
 == img_dynamic_remove.html img_dynamic_remove_ref.html
 == upper_id_attr.html upper_id_attr_ref.html

tests/ref/font_size.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<title>font-size (issues #1435, #3417)</title>
+<body style="font-size: 20px">
+<p style="font-size: 24pt">24pt is 32px.
+<p style="font-size: 2em">2em is 40px.
+<p style="font-size: 200%">200% is 40px.
+<p style="font-size: xx-small">xx-small is 9.6px.
+<p style="font-size: x-small">x-small is 12px.
+<p style="font-size: small">small is 14.2222…px.
+<p style="font-size: medium">medium is 16px.
+<p style="font-size: large">large is 19.2px.
+<p style="font-size: x-large">x-large is 24px.
+<p style="font-size: xx-large">xx-large is 32px.

tests/ref/font_size_em.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>font-size: 2em (Bug #1435)</title>
-    <style type="text/css">
-      body { font-size: 20px; }
-      p { font-size: 2em; }
-    </style>
-  </head>
-  <body>
-    <p>This text should be 40px high.</p>
-  </body>
-</html>

tests/ref/font_size_em_ref.html

@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>font-size: 2em (Bug #1435)</title>
-    <style type="text/css">
-      p { font-size: 40px; }
-    </style>
-  </head>
-  <body>
-    <p>This text should be 40px high.</p>
-  </body>
-</html>

tests/ref/font_size_percentage.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>font-size: 200% (Bug #1435)</title>
-    <style type="text/css">
-      body { font-size: 20px }
-      p { font-size: 200%; }
-    </style>
-  </head>
-  <body>
-    <p>This text should be 40px high.</p>
-  </body>
-</html>

tests/ref/font_size_ref.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<title>font-size (issues #1435, #3417)</title>
+<body>
+<p style="font-size: 32px">24pt is 32px.
+<p style="font-size: 40px">2em is 40px.
+<p style="font-size: 40px">200% is 40px.
+<p style="font-size: 9.6px">xx-small is 9.6px.
+<p style="font-size: 12px">x-small is 12px.
+<p style="font-size: 14.2222222222222222222222222222px">small is 14.2222…px.
+<p style="font-size: 16px">medium is 16px.
+<p style="font-size: 19.2px">large is 19.2px.
+<p style="font-size: 24px">x-large is 24px.
+<p style="font-size: 32px">xx-large is 32px.