[librsvg: 4/5] Move extract_filter_from_filter_node() to filter.rs

[Marge Bot <marge-bot src gnome org>]

commit 3489553533d57270d1c40a10471a0fb2e9bfc9a4
Author: Federico Mena Quintero <federico gnome org>
Date:   Fri Sep 23 20:29:00 2022 -0500

    Move extract_filter_from_filter_node() to filter.rs
    
    That function pulls out all the innards from a <filter> node to
    generate a FilterSpec; it's better to keep it where the <filter> node
    is defined.
    
    Part-of: <https://gitlab.gnome.org/GNOME/librsvg/-/merge_requests/753>

 src/filter.rs      | 110 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 src/filters/mod.rs | 108 +---------------------------------------------------
 2 files changed, 107 insertions(+), 111 deletions(-)
---
diff --git a/src/filter.rs b/src/filter.rs
index bb6fd765a..963b963c4 100644
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -6,15 +6,13 @@ use std::slice::Iter;
 
 use crate::coord_units::CoordUnits;
 use crate::document::{AcquiredNodes, NodeId};
-use crate::drawing_ctx::DrawingCtx;
+use crate::drawing_ctx::{DrawingCtx, ViewParams};
 use crate::element::{Draw, Element, ElementResult, SetAttributes};
 use crate::error::ValueErrorKind;
 use crate::filter_func::FilterFunction;
-use crate::filters::{
-    extract_filter_from_filter_node, FilterResolveError, FilterSpec, ViewParamsGen,
-};
+use crate::filters::{FilterResolveError, FilterSpec, UserSpacePrimitive};
 use crate::length::*;
-use crate::node::NodeBorrow;
+use crate::node::{Node, NodeBorrow};
 use crate::parsers::{Parse, ParseValue};
 use crate::rect::Rect;
 use crate::session::Session;
@@ -122,6 +120,108 @@ impl FilterValue {
     }
 }
 
+/// Holds the viewport parameters for both objectBoundingBox and userSpaceOnUse units.
+///
+/// When collecting a set of filter primitives (`feFoo`) into a [`FilterSpec`], which is
+/// in user space, we need to convert each primitive's units into user space units.  So,
+/// pre-compute both cases and pass them around.
+///
+/// This struct needs a better name; I didn't want to make it seem specific to filters by
+/// calling `FiltersViewParams` or `FilterCollectionProcessViewParams`.  Maybe the
+/// original [`ViewParams`] should be this struct, with both cases included...
+pub struct ViewParamsGen {
+    object_bounding_box: ViewParams,
+    user_space_on_use: ViewParams,
+}
+
+impl ViewParamsGen {
+    pub fn new(draw_ctx: &DrawingCtx) -> Self {
+        ViewParamsGen {
+            object_bounding_box: draw_ctx.get_view_params_for_units(CoordUnits::ObjectBoundingBox),
+            user_space_on_use: draw_ctx.get_view_params_for_units(CoordUnits::UserSpaceOnUse),
+        }
+    }
+
+    fn get(&self, units: CoordUnits) -> &ViewParams {
+        match units {
+            CoordUnits::ObjectBoundingBox => &self.object_bounding_box,
+            CoordUnits::UserSpaceOnUse => &self.user_space_on_use,
+        }
+    }
+}
+
+fn extract_filter_from_filter_node(
+    filter_node: &Node,
+    acquired_nodes: &mut AcquiredNodes<'_>,
+    session: &Session,
+    filter_view_params: &ViewParamsGen,
+) -> Result<FilterSpec, FilterResolveError> {
+    assert!(is_element_of_type!(filter_node, Filter));
+
+    let filter_element = filter_node.borrow_element();
+
+    let user_space_filter = {
+        let filter_values = filter_element.get_computed_values();
+
+        let filter = borrow_element_as!(filter_node, Filter);
+
+        filter.to_user_space(&NormalizeParams::new(
+            filter_values,
+            filter_view_params.get(filter.get_filter_units()),
+        ))
+    };
+
+    let primitive_view_params = filter_view_params.get(user_space_filter.primitive_units);
+
+    let primitives = filter_node
+        .children()
+        .filter(|c| c.is_element())
+        // Skip nodes in error.
+        .filter(|c| {
+            let in_error = c.borrow_element().is_in_error();
+
+            if in_error {
+                rsvg_log!(
+                    session,
+                    "(ignoring filter primitive {} because it is in error)",
+                    c
+                );
+            }
+
+            !in_error
+        })
+        // Keep only filter primitives (those that implement the Filter trait)
+        .filter(|c| c.borrow_element().as_filter_effect().is_some())
+        .map(|primitive_node| {
+            let elt = primitive_node.borrow_element();
+            let effect = elt.as_filter_effect().unwrap();
+
+            let primitive_name = format!("{}", primitive_node);
+
+            let primitive_values = elt.get_computed_values();
+            let params = NormalizeParams::new(primitive_values, primitive_view_params);
+
+            effect
+                .resolve(acquired_nodes, &primitive_node)
+                .map_err(|e| {
+                    rsvg_log!(
+                        session,
+                        "(filter primitive {} returned an error: {})",
+                        primitive_name,
+                        e
+                    );
+                    e
+                })
+                .map(|primitive| primitive.into_user_space(&params))
+        })
+        .collect::<Result<Vec<UserSpacePrimitive>, FilterResolveError>>()?;
+
+    Ok(FilterSpec {
+        user_space_filter,
+        primitives,
+    })
+}
+
 fn filter_spec_from_filter_node(
     acquired_nodes: &mut AcquiredNodes<'_>,
     draw_ctx: &DrawingCtx,
diff --git a/src/filters/mod.rs b/src/filters/mod.rs
index 79ba56e69..b7b545b78 100644
--- a/src/filters/mod.rs
+++ b/src/filters/mod.rs
@@ -6,18 +6,16 @@ use std::rc::Rc;
 use std::time::Instant;
 
 use crate::bbox::BoundingBox;
-use crate::coord_units::CoordUnits;
 use crate::document::AcquiredNodes;
-use crate::drawing_ctx::{DrawingCtx, ViewParams};
+use crate::drawing_ctx::DrawingCtx;
 use crate::element::{Draw, ElementResult, SetAttributes};
 use crate::error::{ElementError, ParseError, RenderingError};
 use crate::filter::UserSpaceFilter;
 use crate::length::*;
-use crate::node::{Node, NodeBorrow};
+use crate::node::Node;
 use crate::paint_server::UserSpacePaintSource;
 use crate::parsers::{CustomIdent, Parse, ParseValue};
 use crate::properties::ColorInterpolationFilters;
-use crate::session::Session;
 use crate::surface_utils::shared_surface::{SharedImageSurface, SurfaceType};
 use crate::transform::Transform;
 use crate::xml::Attributes;
@@ -243,108 +241,6 @@ impl Primitive {
     }
 }
 
-/// Holds the viewport parameters for both objectBoundingBox and userSpaceOnUse units.
-///
-/// When collecting a set of filter primitives (`feFoo`) into a [`FilterSpec`], which is
-/// in user space, we need to convert each primitive's units into user space units.  So,
-/// pre-compute both cases and pass them around.
-///
-/// This struct needs a better name; I didn't want to make it seem specific to filters by
-/// calling `FiltersViewParams` or `FilterCollectionProcessViewParams`.  Maybe the
-/// original [`ViewParams`] should be this struct, with both cases included...
-pub struct ViewParamsGen {
-    object_bounding_box: ViewParams,
-    user_space_on_use: ViewParams,
-}
-
-impl ViewParamsGen {
-    pub fn new(draw_ctx: &DrawingCtx) -> Self {
-        ViewParamsGen {
-            object_bounding_box: draw_ctx.get_view_params_for_units(CoordUnits::ObjectBoundingBox),
-            user_space_on_use: draw_ctx.get_view_params_for_units(CoordUnits::UserSpaceOnUse),
-        }
-    }
-
-    fn get(&self, units: CoordUnits) -> &ViewParams {
-        match units {
-            CoordUnits::ObjectBoundingBox => &self.object_bounding_box,
-            CoordUnits::UserSpaceOnUse => &self.user_space_on_use,
-        }
-    }
-}
-
-pub fn extract_filter_from_filter_node(
-    filter_node: &Node,
-    acquired_nodes: &mut AcquiredNodes<'_>,
-    session: &Session,
-    filter_view_params: &ViewParamsGen,
-) -> Result<FilterSpec, FilterResolveError> {
-    assert!(is_element_of_type!(filter_node, Filter));
-
-    let filter_element = filter_node.borrow_element();
-
-    let user_space_filter = {
-        let filter_values = filter_element.get_computed_values();
-
-        let filter = borrow_element_as!(filter_node, Filter);
-
-        filter.to_user_space(&NormalizeParams::new(
-            filter_values,
-            filter_view_params.get(filter.get_filter_units()),
-        ))
-    };
-
-    let primitive_view_params = filter_view_params.get(user_space_filter.primitive_units);
-
-    let primitives = filter_node
-        .children()
-        .filter(|c| c.is_element())
-        // Skip nodes in error.
-        .filter(|c| {
-            let in_error = c.borrow_element().is_in_error();
-
-            if in_error {
-                rsvg_log!(
-                    session,
-                    "(ignoring filter primitive {} because it is in error)",
-                    c
-                );
-            }
-
-            !in_error
-        })
-        // Keep only filter primitives (those that implement the Filter trait)
-        .filter(|c| c.borrow_element().as_filter_effect().is_some())
-        .map(|primitive_node| {
-            let elt = primitive_node.borrow_element();
-            let effect = elt.as_filter_effect().unwrap();
-
-            let primitive_name = format!("{}", primitive_node);
-
-            let primitive_values = elt.get_computed_values();
-            let params = NormalizeParams::new(primitive_values, primitive_view_params);
-
-            effect
-                .resolve(acquired_nodes, &primitive_node)
-                .map_err(|e| {
-                    rsvg_log!(
-                        session,
-                        "(filter primitive {} returned an error: {})",
-                        primitive_name,
-                        e
-                    );
-                    e
-                })
-                .map(|primitive| primitive.into_user_space(&params))
-        })
-        .collect::<Result<Vec<UserSpacePrimitive>, FilterResolveError>>()?;
-
-    Ok(FilterSpec {
-        user_space_filter,
-        primitives,
-    })
-}
-
 /// Applies a filter and returns the resulting surface.
 pub fn render(
     filter: &FilterSpec,