[librsvg: 40/45] Pass a Session to the gradient.resolve machinery

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

commit a3799b318cc53454773f24d55900927e2d20d8d9
Author: Federico Mena Quintero <federico gnome org>
Date:   Tue Aug 23 20:04:46 2022 -0500

    Pass a Session to the gradient.resolve machinery
    
    Part-of: <https://gitlab.gnome.org/GNOME/librsvg/-/merge_requests/731>

 src/gradient.rs     | 38 +++++++++++++++++++++++++++-----------
 src/paint_server.rs |  4 ++--
 2 files changed, 29 insertions(+), 13 deletions(-)
---
diff --git a/src/gradient.rs b/src/gradient.rs
index a45e8a850..d201a74fc 100644
--- a/src/gradient.rs
+++ b/src/gradient.rs
@@ -410,7 +410,7 @@ impl UnresolvedGradient {
 
     /// Looks for <stop> children inside a linearGradient or radialGradient node,
     /// and adds their info to the UnresolvedGradient &self.
-    fn add_color_stops_from_node(&mut self, node: &Node, opacity: UnitInterval) {
+    fn add_color_stops_from_node(&mut self, node: &Node, opacity: UnitInterval, session: &Session) {
         assert!(matches!(
             *node.borrow_element(),
             Element::LinearGradient(_) | Element::RadialGradient(_)
@@ -421,7 +421,11 @@ impl UnresolvedGradient {
 
             if let Element::Stop(ref stop) = *elt {
                 if elt.is_in_error() {
-                    rsvg_log!("(not using gradient stop {} because it is in error)", child);
+                    rsvg_log_session!(
+                        session,
+                        "(not using gradient stop {} because it is in error)",
+                        child
+                    );
                 } else {
                     let cascaded = CascadedValues::new_from_node(&child);
                     let values = cascaded.get();
@@ -564,7 +568,12 @@ impl Draw for LinearGradient {}
 macro_rules! impl_gradient {
     ($gradient_type:ident, $other_type:ident) => {
         impl $gradient_type {
-            fn get_unresolved(&self, node: &Node, opacity: UnitInterval) -> Unresolved {
+            fn get_unresolved(
+                &self,
+                node: &Node,
+                opacity: UnitInterval,
+                session: &Session,
+            ) -> Unresolved {
                 let mut gradient = UnresolvedGradient {
                     units: self.common.units,
                     transform: self.common.transform,
@@ -573,7 +582,7 @@ macro_rules! impl_gradient {
                     variant: self.get_unresolved_variant(),
                 };
 
-                gradient.add_color_stops_from_node(node, opacity);
+                gradient.add_color_stops_from_node(node, opacity, session);
 
                 Unresolved {
                     gradient,
@@ -586,11 +595,12 @@ macro_rules! impl_gradient {
                 node: &Node,
                 acquired_nodes: &mut AcquiredNodes<'_>,
                 opacity: UnitInterval,
+                session: &Session,
             ) -> Result<ResolvedGradient, AcquireError> {
                 let Unresolved {
                     mut gradient,
                     mut fallback,
-                } = self.get_unresolved(node, opacity);
+                } = self.get_unresolved(node, opacity, session);
 
                 let mut stack = NodeStack::new();
 
@@ -605,10 +615,10 @@ macro_rules! impl_gradient {
 
                         let unresolved = match *acquired_node.borrow_element() {
                             Element::$gradient_type(ref g) => {
-                                g.get_unresolved(&acquired_node, opacity)
+                                g.get_unresolved(&acquired_node, opacity, session)
                             }
                             Element::$other_type(ref g) => {
-                                g.get_unresolved(&acquired_node, opacity)
+                                g.get_unresolved(&acquired_node, opacity, session)
                             }
                             _ => return Err(AcquireError::InvalidLinkType(node_id.clone())),
                         };
@@ -743,8 +753,11 @@ mod tests {
             Attributes::new(),
         ));
 
-        let unresolved = borrow_element_as!(node, LinearGradient)
-            .get_unresolved(&node, UnitInterval::clamp(1.0));
+        let unresolved = borrow_element_as!(node, LinearGradient).get_unresolved(
+            &node,
+            UnitInterval::clamp(1.0),
+            &session,
+        );
         let gradient = unresolved.gradient.resolve_from_defaults();
         assert!(gradient.is_resolved());
 
@@ -754,8 +767,11 @@ mod tests {
             Attributes::new(),
         ));
 
-        let unresolved = borrow_element_as!(node, RadialGradient)
-            .get_unresolved(&node, UnitInterval::clamp(1.0));
+        let unresolved = borrow_element_as!(node, RadialGradient).get_unresolved(
+            &node,
+            UnitInterval::clamp(1.0),
+            &session,
+        );
         let gradient = unresolved.gradient.resolve_from_defaults();
         assert!(gradient.is_resolved());
     }
diff --git a/src/paint_server.rs b/src/paint_server.rs
index 822fd2334..ac758c790 100644
--- a/src/paint_server.rs
+++ b/src/paint_server.rs
@@ -141,7 +141,7 @@ impl PaintServer {
 
                     match *node.borrow_element() {
                         Element::LinearGradient(ref g) => {
-                            g.resolve(node, acquired_nodes, opacity).map(|g| {
+                            g.resolve(node, acquired_nodes, opacity, session).map(|g| {
                                 PaintSource::Gradient(
                                     g,
                                     alternate.map(|c| resolve_color(&c, opacity, current_color)),
@@ -157,7 +157,7 @@ impl PaintServer {
                             })
                         }
                         Element::RadialGradient(ref g) => {
-                            g.resolve(node, acquired_nodes, opacity).map(|g| {
+                            g.resolve(node, acquired_nodes, opacity, session).map(|g| {
                                 PaintSource::Gradient(
                                     g,
                                     alternate.map(|c| resolve_color(&c, opacity, current_color)),