Fix Tiny Skia panic on infinite length quads

Fixes issue 2066.

Iced may produce primitives with an infinite length or width. The WGPU
renderer handles those somewhere along the pipeline. Tiny Skia's
`PathBuilder::finish` returns `None` if non-normal floats are passed to
the builder. This patch adds a check to prevent that.

See:
* https://github.com/RazrFalcon/tiny-skia/blob/master/path/src/path_builder.rs#L421
* https://github.com/RazrFalcon/tiny-skia/blob/master/path/src/rect.rs#L344

Author: joshuamegnauth54

tiny_skia/src/backend.rs

@@ -1,5 +1,3 @@
-use tiny_skia::Size;
-
 use crate::core::{Background, Color, Gradient, Rectangle, Vector};
 use crate::graphics::backend;
 use crate::graphics::text;
@@ -155,6 +153,29 @@ impl Backend {
                 border,
                 shadow,
             } => {
+                // Tiny Skia's `PathBuilder::finish` returns `None` on infinites and NaNs which causes iced to panic.
+                // Certain widget combinations can lead to an infinite in either dimension hence the need for this check.
+                // However, it's likely a misuse of iced's API so the check only applies on debug builds.
+                // https://docs.rs/tiny-skia/latest/tiny_skia/struct.Rect.html#method.from_points
+                #[cfg(debug_assertions)]
+                let checked_bounds = Rectangle::new(
+                    bounds.position(),
+                    crate::core::Size {
+                        width: if bounds.width.is_normal() {
+                            bounds.width
+                        } else {
+                            clip_bounds.width
+                        },
+                        height: if bounds.height.is_normal() {
+                            bounds.height
+                        } else {
+                            clip_bounds.height
+                        },
+                    },
+                );
+                #[cfg(debug_assertions)]
+                let bounds = &checked_bounds;
+
                 let physical_bounds = (*bounds + translation) * scale_factor;
 
                 if !clip_bounds.intersects(&physical_bounds) {
@@ -211,31 +232,34 @@ impl Backend {
                             (x..x + width).map(move |x| (x as f32, y as f32))
                         })
                         .filter_map(|(x, y)| {
-                            Size::from_wh(half_width, half_height).map(|size| {
-                                let shadow_distance = rounded_box_sdf(
-                                    Vector::new(
-                                        x - physical_bounds.position().x
-                                            - (shadow.offset.x * scale_factor)
-                                            - half_width,
-                                        y - physical_bounds.position().y
-                                            - (shadow.offset.y * scale_factor)
-                                            - half_height,
-                                    ),
-                                    size,
-                                    &radii,
-                                );
-                                let shadow_alpha = 1.0
-                                    - smoothstep(
-                                        -shadow.blur_radius * scale_factor,
-                                        shadow.blur_radius * scale_factor,
-                                        shadow_distance,
+                            tiny_skia::Size::from_wh(half_width, half_height)
+                                .map(|size| {
+                                    let shadow_distance = rounded_box_sdf(
+                                        Vector::new(
+                                            x - physical_bounds.position().x
+                                                - (shadow.offset.x
+                                                    * scale_factor)
+                                                - half_width,
+                                            y - physical_bounds.position().y
+                                                - (shadow.offset.y
+                                                    * scale_factor)
+                                                - half_height,
+                                        ),
+                                        size,
+                                        &radii,
                                     );
-
-                                let mut color = into_color(shadow.color);
-                                color.apply_opacity(shadow_alpha);
-
-                                color.to_color_u8().premultiply()
-                            })
+                                    let shadow_alpha = 1.0
+                                        - smoothstep(
+                                            -shadow.blur_radius * scale_factor,
+                                            shadow.blur_radius * scale_factor,
+                                            shadow_distance,
+                                        );
+
+                                    let mut color = into_color(shadow.color);
+                                    color.apply_opacity(shadow_alpha);
+
+                                    color.to_color_u8().premultiply()
+                                })
                         })
                         .collect();
 
@@ -947,7 +971,11 @@ fn smoothstep(a: f32, b: f32, x: f32) -> f32 {
     x * x * (3.0 - 2.0 * x)
 }
 
-fn rounded_box_sdf(to_center: Vector, size: Size, radii: &[f32]) -> f32 {
+fn rounded_box_sdf(
+    to_center: Vector,
+    size: tiny_skia::Size,
+    radii: &[f32],
+) -> f32 {
     let radius = match (to_center.x > 0.0, to_center.y > 0.0) {
         (true, true) => radii[2],
         (true, false) => radii[1],