refactor: Convert parsing logic to use FromWStr

core/src/avm2/globals/flash/display/bitmap.rs

@@ -84,17 +84,10 @@
 
     let bitmap_data = args.try_get_object(0).and_then(|o| o.as_bitmap_data());
 
-    let pixel_snapping = args.get_string(activation, 1);
-
-    let pixel_snapping = if &pixel_snapping == b"always" {
-        PixelSnapping::Always
-    } else if &pixel_snapping == b"auto" {
-        PixelSnapping::Auto
-    } else if &pixel_snapping == b"never" {
-        PixelSnapping::Never
-    } else {
-        return Err(make_error_2008(activation, "pixelSnapping"));
-    };
+    let pixel_snapping = args
+        .get_string(activation, 1)
+        .parse()
+        .map_err(|_| make_error_2008(activation, "pixelSnapping"))?;
 
     let smoothing = args.get_bool(2);
 
@@ -185,17 +178,10 @@
     let this = this.as_object().unwrap();
 
     if let Some(bitmap) = this.as_display_object().and_then(|dobj| dobj.as_bitmap()) {
-        let value = args.get_string(activation, 0);
-
-        let pixel_snapping = if &value == b"always" {
-            PixelSnapping::Always
-        } else if &value == b"auto" {
-            PixelSnapping::Auto
-        } else if &value == b"never" {
-            PixelSnapping::Never
-        } else {
-            return Err(make_error_2008(activation, "pixelSnapping"));
-        };
+        let pixel_snapping = args
+            .get_string(activation, 0)
+            .parse()
+            .map_err(|_| make_error_2008(activation, "pixelSnapping"))?;
 
         bitmap.set_pixel_snapping(pixel_snapping);
     }

core/src/avm2/globals/flash/display/graphics.rs

@@ -1012,15 +1012,10 @@ pub fn draw_path<'gc>(
     let mut drawing = this.as_drawing().unwrap();
     let commands = args.get_object(activation, 0, "commands")?;
     let data = args.get_object(activation, 1, "data")?;
-    let winding = args.get_string(activation, 2);
-
-    let fill_rule = if winding == WStr::from_units(b"nonZero") {
-        FillRule::NonZero
-    } else if winding == WStr::from_units(b"evenOdd") {
-        FillRule::EvenOdd
-    } else {
-        return Err(make_error_2008(activation, "winding"));
-    };
+    let fill_rule = args
+        .get_string(activation, 2)
+        .parse()
+        .map_err(|_| make_error_2008(activation, "winding"))?;
 
     // FIXME - implement fill behavior described in the Flash docs
     // (which is different from just running each command sequentially on `Graphics`)
@@ -1490,17 +1485,11 @@ fn handle_igraphics_data<'gc>(
 
         let data = obj.get_slot(graphics_path_slots::DATA).as_object();
 
-        let winding = obj
+        let fill_rule = obj
             .get_slot(graphics_path_slots::_WINDING)
-            .coerce_to_string(activation)?;
-
-        let fill_rule = if winding == WStr::from_units(b"nonZero") {
-            FillRule::NonZero
-        } else if winding == WStr::from_units(b"evenOdd") {
-            FillRule::EvenOdd
-        } else {
-            unreachable!("AS3 setter guarantees value of winding");
-        };
+            .coerce_to_string(activation)?
+            .parse()
+            .expect("AS3 setter guarantees value of winding");
 
         if let (Some(commands), Some(data)) = (commands, data) {
             process_commands(

render/src/bitmap.rs

@@ -1,4 +1,5 @@
 use h263_rs_yuv::bt601::yuv420_to_rgba;
+use ruffle_wstr::{FromWStr, WStr};
 use std::any::Any;
 use std::borrow::Cow;
 use std::fmt::Debug;
@@ -66,6 +67,22 @@
     Never,
 }
 
+impl FromWStr for PixelSnapping {
+    type Err = ();
+
+    fn from_wstr(s: &WStr) -> Result<Self, Self::Err> {
+        if s == b"always" {
+            Ok(PixelSnapping::Always)
+        } else if s == b"auto" {
+            Ok(PixelSnapping::Auto)
+        } else if s == b"never" {
+            Ok(PixelSnapping::Never)
+        } else {
+            Err(())
+        }
+    }
+}
+
 impl PixelSnapping {
     pub fn apply(&self, matrix: &mut Matrix) {
         match self {

render/src/shape_utils.rs

@@ -1,5 +1,6 @@
 use crate::matrix::Matrix;
 use enum_map::Enum;
+use ruffle_wstr::{FromWStr, WStr};
 use smallvec::SmallVec;
 use swf::{CharacterId, FillStyle, LineStyle, Rectangle, Shape, ShapeRecord, Twips};
 
@@ -19,6 +20,20 @@ pub enum GradientType {
     Focal,
 }
 
+impl FromWStr for FillRule {
+    type Err = ();
+
+    fn from_wstr(s: &WStr) -> Result<Self, Self::Err> {
+        if s == b"evenOdd" {
+            Ok(FillRule::EvenOdd)
+        } else if s == b"nonZero" {
+            Ok(FillRule::NonZero)
+        } else {
+            Err(())
+        }
+    }
+}
+
 #[cfg(feature = "tessellator")]
 impl From<FillRule> for lyon::path::FillRule {
     fn from(rule: FillRule) -> lyon::path::FillRule {