WIP: Limit use of f64

Author: GPHemsley

src/color.rs

@@ -2,7 +2,6 @@
  * 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 std::f64::consts::PI;
 use std::fmt;
 
 use super::{BasicParseError, ParseError, Parser, ToCss, Token};
@@ -103,12 +102,6 @@ impl<'de> Deserialize<'de> for RGBA {
 
 // NOTE: `RGBA` should not implement `ToCss` because it is an internal primitive that does not directly represent a CSS value.
 
-#[inline]
-fn f32_to_f64(f: f32) -> f64 {
-    const PRECISION: f64 = 1e6;
-    (f64::from(f) * PRECISION).round() / PRECISION
-}
-
 /// <hue>
 /// <https://w3c.github.io/csswg-drafts/css-color-4/#hue-syntax>
 #[derive(Clone, Copy, PartialEq, Debug)]
@@ -195,11 +188,11 @@ pub enum SrgbColor {
     /// <https://w3c.github.io/csswg-drafts/css-color-4/#numeric-srgb>
     Rgb {
         /// The red channel.
-        red: Option<f64>,
+        red: Option<f32>,
         /// The green channel.
-        green: Option<f64>,
+        green: Option<f32>,
         /// The blue channel.
-        blue: Option<f64>,
+        blue: Option<f32>,
         /// The alpha channel.
         alpha: Option<AlphaValue>,
     },
@@ -230,9 +223,9 @@ pub enum SrgbColor {
 impl SrgbColor {
     /// Construct an sRGB color from its component channels.
     pub fn new(
-        red: Option<f64>,
-        green: Option<f64>,
-        blue: Option<f64>,
+        red: Option<f32>,
+        green: Option<f32>,
+        blue: Option<f32>,
         alpha: Option<AlphaValue>,
     ) -> Self {
         Self::Rgb {
@@ -276,15 +269,15 @@ impl SrgbColor {
     /// Construct an sRGB color from channels represented as bytes.
     pub fn from_ints(red: u8, green: u8, blue: u8, alpha: u8) -> Self {
         Self::new(
-            Some(red as f64 / 255.),
-            Some(green as f64 / 255.),
-            Some(blue as f64 / 255.),
+            Some(red as f32 / 255.),
+            Some(green as f32 / 255.),
+            Some(blue as f32 / 255.),
             Some(AlphaValue::new(alpha as f32 / 255.)),
         )
     }
 
     /// Construct an sRGB color from channels represented as floats in the range 0 to 1.
-    pub fn from_floats(red: f64, green: f64, blue: f64, alpha: f32) -> Self {
+    pub fn from_floats(red: f32, green: f32, blue: f32, alpha: f32) -> Self {
         Self::new(
             Some(red),
             Some(green),
@@ -294,7 +287,7 @@ impl SrgbColor {
     }
 
     /// Extract sRGB color channels, with missing components converted to zero.
-    pub fn to_floats(self: Self) -> (f64, f64, f64, f32) {
+    pub fn to_floats(self: Self) -> (f32, f32, f32, f32) {
         match self {
             Self::Rgb {
                 red,
@@ -319,9 +312,9 @@ impl SrgbColor {
                     lightness.unwrap_or(0.).clamp(0., 1.),
                 );
                 (
-                    f32_to_f64(r),
-                    f32_to_f64(g),
-                    f32_to_f64(b),
+                    r,
+                    g,
+                    b,
                     alpha.unwrap_or(AlphaValue::new(0.)).number.clamp(0., 1.),
                 )
             }
@@ -337,9 +330,9 @@ impl SrgbColor {
                     blackness.unwrap_or(0.).clamp(0., 1.),
                 );
                 (
-                    f32_to_f64(r),
-                    f32_to_f64(g),
-                    f32_to_f64(b),
+                    r,
+                    g,
+                    b,
                     alpha.unwrap_or(AlphaValue::new(0.)).number.clamp(0., 1.),
                 )
             }
@@ -353,7 +346,7 @@ impl SrgbColor {
 
     /// Convert an sRGB color to an RGBA color primitive.
     pub fn to_rgba(self: Self) -> RGBA {
-        let (red, green, blue, alpha): (f64, f64, f64, f32) = self.to_floats();
+        let (red, green, blue, alpha): (f32, f32, f32, f32) = self.to_floats();
 
         RGBA {
             red: (red * 255.).round() as u8,
@@ -371,7 +364,7 @@ impl ToCss for SrgbColor {
     where
         W: fmt::Write,
     {
-        let (red, green, blue, alpha): (f64, f64, f64, f32) = self.to_floats();
+        let (red, green, blue, alpha): (f32, f32, f32, f32) = self.to_floats();
 
         let serialize_alpha = alpha != 1.;
 
@@ -751,13 +744,10 @@ pub trait ColorComponentParser<'i> {
             Token::Dimension {
                 value: v, ref unit, ..
             } => {
-                // Expand f32 to f64 to avoid rounding errors during conversion.
-                let v = v as f64;
-
                 let degrees = match_ignore_ascii_case! { &*unit,
                     "deg" => v,
-                    "grad" => (v / 400.) * 360.,
-                    "rad" => (v / (2. * PI)) * 360.,
+                    "grad" => v * 0.9,
+                    "rad" => v.to_degrees(),
                     "turn" => v * 360.,
                     _ => return Err(location.new_unexpected_token_error(Token::Ident(unit.clone()))),
                 };
@@ -1187,15 +1177,15 @@ where
     // Determine whether this is the number syntax or the percentage syntax.
     arguments
         .try_parse(|input| {
-            let red = Some(component_parser.parse_number(input)? as f64 / 255.);
+            let red = Some(component_parser.parse_number(input)? / 255.);
 
             input.expect_comma()?;
 
-            let green = Some(component_parser.parse_number(input)? as f64 / 255.);
+            let green = Some(component_parser.parse_number(input)? / 255.);
 
             input.expect_comma()?;
 
-            let blue = Some(component_parser.parse_number(input)? as f64 / 255.);
+            let blue = Some(component_parser.parse_number(input)? / 255.);
 
             let alpha = parse_alpha_component(component_parser, input, true)?;
 
@@ -1204,15 +1194,15 @@ where
             )))
         })
         .or(arguments.try_parse(|input| {
-            let red = Some(f32_to_f64(component_parser.parse_percentage(input)?));
+            let red = Some(component_parser.parse_percentage(input)?);
 
             input.expect_comma()?;
 
-            let green = Some(f32_to_f64(component_parser.parse_percentage(input)?));
+            let green = Some(component_parser.parse_percentage(input)?);
 
             input.expect_comma()?;
 
-            let blue = Some(f32_to_f64(component_parser.parse_percentage(input)?));
+            let blue = Some(component_parser.parse_percentage(input)?);
 
             let alpha = parse_alpha_component(component_parser, input, true)?;
 
@@ -1222,17 +1212,17 @@ where
         }))
         .or(arguments.try_parse(|input| {
             let red = component_parser.parse_none_or(
-                |component_parser, input| Ok(component_parser.parse_number(input)? as f64 / 255.),
+                |component_parser, input| Ok(component_parser.parse_number(input)? / 255.),
                 input,
             )?;
 
             let green = component_parser.parse_none_or(
-                |component_parser, input| Ok(component_parser.parse_number(input)? as f64 / 255.),
+                |component_parser, input| Ok(component_parser.parse_number(input)? / 255.),
                 input,
             )?;
 
             let blue = component_parser.parse_none_or(
-                |component_parser, input| Ok(component_parser.parse_number(input)? as f64 / 255.),
+                |component_parser, input| Ok(component_parser.parse_number(input)? / 255.),
                 input,
             )?;
 
@@ -1244,17 +1234,17 @@ where
         }))
         .or(arguments.try_parse(|input| {
             let red = component_parser.parse_none_or(
-                |component_parser, input| Ok(component_parser.parse_percentage(input)? as f64),
+                |component_parser, input| Ok(component_parser.parse_percentage(input)?),
                 input,
             )?;
 
             let green = component_parser.parse_none_or(
-                |component_parser, input| Ok(component_parser.parse_percentage(input)? as f64),
+                |component_parser, input| Ok(component_parser.parse_percentage(input)?),
                 input,
             )?;
 
             let blue = component_parser.parse_none_or(
-                |component_parser, input| Ok(component_parser.parse_percentage(input)? as f64),
+                |component_parser, input| Ok(component_parser.parse_percentage(input)?),
                 input,
             )?;