[librsvg: 7/9] Pass AcquiredNodes to FilterEffect::resolve()

[Federico Mena Quintero <federico src gnome org>]

commit 17e54e7aef8a45d0f1439e6ff59884815cd3a90a
Author: Federico Mena Quintero <federico gnome org>
Date:   Wed Apr 21 19:07:32 2021 -0500

    Pass AcquiredNodes to FilterEffect::resolve()
    
    feImage will need it.

 src/filter.rs                     |  2 +-
 src/filters/blend.rs              |  6 +++++-
 src/filters/color_matrix.rs       |  6 +++++-
 src/filters/component_transfer.rs |  6 +++++-
 src/filters/composite.rs          |  6 +++++-
 src/filters/convolve_matrix.rs    |  6 +++++-
 src/filters/displacement_map.rs   |  6 +++++-
 src/filters/flood.rs              |  6 +++++-
 src/filters/gaussian_blur.rs      |  6 +++++-
 src/filters/image.rs              |  6 +++++-
 src/filters/lighting.rs           | 16 ++++++++++++----
 src/filters/merge.rs              |  9 +++++++--
 src/filters/mod.rs                |  9 +++++++--
 src/filters/morphology.rs         |  6 +++++-
 src/filters/offset.rs             |  6 +++++-
 src/filters/tile.rs               |  6 +++++-
 src/filters/turbulence.rs         |  6 +++++-
 17 files changed, 92 insertions(+), 22 deletions(-)
---
diff --git a/src/filter.rs b/src/filter.rs
index 58fe87aa..3a9d96f3 100644
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -157,7 +157,7 @@ fn filter_spec_from_filter_node(
                         );
                         Err(FilterResolveError::ChildNodeInError)
                     } else {
-                        extract_filter_from_filter_node(node, draw_ctx)
+                        extract_filter_from_filter_node(node, acquired_nodes, draw_ctx)
                     }
                 }
 
diff --git a/src/filters/blend.rs b/src/filters/blend.rs
index 9ad5253f..9169265c 100644
--- a/src/filters/blend.rs
+++ b/src/filters/blend.rs
@@ -111,7 +111,11 @@ impl Blend {
 }
 
 impl FilterEffect for FeBlend {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/color_matrix.rs b/src/filters/color_matrix.rs
index 556a0ff5..a39e4f38 100644
--- a/src/filters/color_matrix.rs
+++ b/src/filters/color_matrix.rs
@@ -220,7 +220,11 @@ impl ColorMatrix {
 }
 
 impl FilterEffect for FeColorMatrix {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/component_transfer.rs b/src/filters/component_transfer.rs
index de115021..11259d1e 100644
--- a/src/filters/component_transfer.rs
+++ b/src/filters/component_transfer.rs
@@ -372,7 +372,11 @@ impl ComponentTransfer {
 }
 
 impl FilterEffect for FeComponentTransfer {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/composite.rs b/src/filters/composite.rs
index 9d6036fa..7ffffe0d 100644
--- a/src/filters/composite.rs
+++ b/src/filters/composite.rs
@@ -121,7 +121,11 @@ impl Composite {
 }
 
 impl FilterEffect for FeComposite {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/convolve_matrix.rs b/src/filters/convolve_matrix.rs
index b04f4f3e..3b802e2c 100644
--- a/src/filters/convolve_matrix.rs
+++ b/src/filters/convolve_matrix.rs
@@ -305,7 +305,11 @@ impl ConvolveMatrix {
 }
 
 impl FilterEffect for FeConvolveMatrix {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/displacement_map.rs b/src/filters/displacement_map.rs
index eaa3bf37..606c8e90 100644
--- a/src/filters/displacement_map.rs
+++ b/src/filters/displacement_map.rs
@@ -155,7 +155,11 @@ impl DisplacementMap {
 }
 
 impl FilterEffect for FeDisplacementMap {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/flood.rs b/src/filters/flood.rs
index 6789384e..8a305be9 100644
--- a/src/filters/flood.rs
+++ b/src/filters/flood.rs
@@ -46,7 +46,11 @@ impl Flood {
 }
 
 impl FilterEffect for FeFlood {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/gaussian_blur.rs b/src/filters/gaussian_blur.rs
index 576d460e..692920ed 100644
--- a/src/filters/gaussian_blur.rs
+++ b/src/filters/gaussian_blur.rs
@@ -247,7 +247,11 @@ impl GaussianBlur {
 }
 
 impl FilterEffect for FeGaussianBlur {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/image.rs b/src/filters/image.rs
index 63e04afa..9c677e24 100644
--- a/src/filters/image.rs
+++ b/src/filters/image.rs
@@ -155,7 +155,11 @@ impl Image {
 }
 
 impl FilterEffect for FeImage {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let feimage_values = cascaded.get().clone();
 
diff --git a/src/filters/lighting.rs b/src/filters/lighting.rs
index 7477870d..26fafca8 100644
--- a/src/filters/lighting.rs
+++ b/src/filters/lighting.rs
@@ -650,7 +650,11 @@ macro_rules! impl_lighting_filter {
         }
 
         impl FilterEffect for $lighting_type {
-            fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+            fn resolve(
+                &self,
+                _acquired_nodes: &mut AcquiredNodes<'_>,
+                node: &Node,
+            ) -> Result<ResolvedPrimitive, FilterResolveError> {
                 let mut sources = node.children().rev().filter(|c| {
                     c.is_element()
                         && matches!(
@@ -990,10 +994,12 @@ mod tests {
 </svg>
 "#,
         );
+        let mut acquired_nodes = AcquiredNodes::new(&document);
 
         let node = document.lookup_internal_node("diffuse_distant").unwrap();
         let lighting = borrow_element_as!(node, FeDiffuseLighting);
-        let ResolvedPrimitive { params, .. } = lighting.resolve(&node).unwrap();
+        let ResolvedPrimitive { params, .. } =
+            lighting.resolve(&mut acquired_nodes, &node).unwrap();
         let diffuse_lighting = match params {
             PrimitiveParams::DiffuseLighting(l) => l,
             _ => unreachable!(),
@@ -1008,7 +1014,8 @@ mod tests {
 
         let node = document.lookup_internal_node("specular_point").unwrap();
         let lighting = borrow_element_as!(node, FeSpecularLighting);
-        let ResolvedPrimitive { params, .. } = lighting.resolve(&node).unwrap();
+        let ResolvedPrimitive { params, .. } =
+            lighting.resolve(&mut acquired_nodes, &node).unwrap();
         let specular_lighting = match params {
             PrimitiveParams::SpecularLighting(l) => l,
             _ => unreachable!(),
@@ -1024,7 +1031,8 @@ mod tests {
 
         let node = document.lookup_internal_node("diffuse_spot").unwrap();
         let lighting = borrow_element_as!(node, FeDiffuseLighting);
-        let ResolvedPrimitive { params, .. } = lighting.resolve(&node).unwrap();
+        let ResolvedPrimitive { params, .. } =
+            lighting.resolve(&mut acquired_nodes, &node).unwrap();
         let diffuse_lighting = match params {
             PrimitiveParams::DiffuseLighting(l) => l,
             _ => unreachable!(),
diff --git a/src/filters/merge.rs b/src/filters/merge.rs
index 934e51d1..5458f0d6 100644
--- a/src/filters/merge.rs
+++ b/src/filters/merge.rs
@@ -142,7 +142,11 @@ impl Merge {
 }
 
 impl FilterEffect for FeMerge {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         Ok(ResolvedPrimitive {
             primitive: self.base.clone(),
             params: PrimitiveParams::Merge(Merge {
@@ -196,10 +200,11 @@ mod tests {
 </svg>
 "#,
         );
+        let mut acquired_nodes = AcquiredNodes::new(&document);
 
         let node = document.lookup_internal_node("merge").unwrap();
         let merge = borrow_element_as!(node, FeMerge);
-        let ResolvedPrimitive { params, .. } = merge.resolve(&node).unwrap();
+        let ResolvedPrimitive { params, .. } = merge.resolve(&mut acquired_nodes, &node).unwrap();
         let params = match params {
             PrimitiveParams::Merge(m) => m,
             _ => unreachable!(),
diff --git a/src/filters/mod.rs b/src/filters/mod.rs
index acf0ab68..3141ff59 100644
--- a/src/filters/mod.rs
+++ b/src/filters/mod.rs
@@ -34,7 +34,11 @@ pub use self::error::FilterResolveError;
 
 /// A filter primitive interface.
 pub trait FilterEffect: SetAttributes + Draw {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError>;
+    fn resolve(
+        &self,
+        acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError>;
 }
 
 // Filter Effects do not need to draw themselves
@@ -248,6 +252,7 @@ impl Primitive {
 
 pub fn extract_filter_from_filter_node(
     filter_node: &Node,
+    acquired_nodes: &mut AcquiredNodes<'_>,
     draw_ctx: &DrawingCtx,
 ) -> Result<FilterSpec, FilterResolveError> {
     let filter_node = &*filter_node;
@@ -290,7 +295,7 @@ pub fn extract_filter_from_filter_node(
             let primitive_name = format!("{}", primitive_node);
 
             effect
-                .resolve(&primitive_node)
+                .resolve(acquired_nodes, &primitive_node)
                 .map_err(|e| {
                     rsvg_log!(
                         "(filter primitive {} returned an error: {})",
diff --git a/src/filters/morphology.rs b/src/filters/morphology.rs
index f1cd515b..cfdedd01 100644
--- a/src/filters/morphology.rs
+++ b/src/filters/morphology.rs
@@ -161,7 +161,11 @@ impl Morphology {
 }
 
 impl FilterEffect for FeMorphology {
-    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        _node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         Ok(ResolvedPrimitive {
             primitive: self.base.clone(),
             params: PrimitiveParams::Morphology(self.params.clone()),
diff --git a/src/filters/offset.rs b/src/filters/offset.rs
index 1c968e58..cb13e6f7 100644
--- a/src/filters/offset.rs
+++ b/src/filters/offset.rs
@@ -83,7 +83,11 @@ impl Offset {
 }
 
 impl FilterEffect for FeOffset {
-    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        _node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         Ok(ResolvedPrimitive {
             primitive: self.base.clone(),
             params: PrimitiveParams::Offset(self.params.clone()),
diff --git a/src/filters/tile.rs b/src/filters/tile.rs
index cd7f3408..c7e9647b 100644
--- a/src/filters/tile.rs
+++ b/src/filters/tile.rs
@@ -80,7 +80,11 @@ impl Tile {
 }
 
 impl FilterEffect for FeTile {
-    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        _node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         Ok(ResolvedPrimitive {
             primitive: self.base.clone(),
             params: PrimitiveParams::Tile(self.params.clone()),
diff --git a/src/filters/turbulence.rs b/src/filters/turbulence.rs
index 913324f6..158b83ee 100644
--- a/src/filters/turbulence.rs
+++ b/src/filters/turbulence.rs
@@ -417,7 +417,11 @@ impl Turbulence {
 }
 
 impl FilterEffect for FeTurbulence {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
+    fn resolve(
+        &self,
+        _acquired_nodes: &mut AcquiredNodes<'_>,
+        node: &Node,
+    ) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();