[librsvg: 8/45] Move set_pattern_on_draw_context() to a new ResolvedPaintSource trait

[Federico Mena Quintero <federico src gnome org>]

commit 4ef3d70f46e1562a6e4c48a25d61f91f9fc921a0
Author: Federico Mena Quintero <federico gnome org>
Date:   Thu Sep 26 18:05:31 2019 -0500

    Move set_pattern_on_draw_context() to a new ResolvedPaintSource trait

 rsvg_internals/src/gradient.rs     | 15 ++++++++-------
 rsvg_internals/src/paint_server.rs | 23 ++++++++++++-----------
 rsvg_internals/src/pattern.rs      | 31 ++++++++++++++++---------------
 3 files changed, 36 insertions(+), 33 deletions(-)
---
diff --git a/rsvg_internals/src/gradient.rs b/rsvg_internals/src/gradient.rs
index 9edfd8da..38bf8d9f 100644
--- a/rsvg_internals/src/gradient.rs
+++ b/rsvg_internals/src/gradient.rs
@@ -9,7 +9,7 @@ use crate::drawing_ctx::{AcquiredNode, DrawingCtx, NodeStack, ViewParams};
 use crate::error::*;
 use crate::length::*;
 use crate::node::{CascadedValues, NodeResult, NodeTrait, NodeType, RsvgNode};
-use crate::paint_server::{PaintSource, Resolve};
+use crate::paint_server::{PaintSource, Resolve, ResolvedPaintSource};
 use crate::parsers::{Parse, ParseError, ParseValue};
 use crate::properties::ComputedValues;
 use crate::property_bag::PropertyBag;
@@ -613,26 +613,27 @@ macro_rules! impl_paint_source {
                     Ok(None)
                 }
             }
+        }
 
+        impl ResolvedPaintSource for $gradient {
             fn set_pattern_on_draw_context(
-                &self,
-                gradient: Self::Resolved,
+                self,
                 values: &ComputedValues,
                 draw_ctx: &mut DrawingCtx,
                 opacity: &UnitInterval,
                 bbox: &BoundingBox,
             ) -> Result<bool, RenderingError> {
-                assert!(gradient.is_resolved());
+                assert!(self.is_resolved());
 
-                let units = gradient.common.units.unwrap();
+                let units = self.common.units.unwrap();
                 let params = if units == GradientUnits(CoordUnits::ObjectBoundingBox) {
                     draw_ctx.push_view_box(1.0, 1.0)
                 } else {
                     draw_ctx.get_view_params()
                 };
 
-                let p = gradient.variant.to_cairo_gradient(values, &params);
-                gradient.common.set_on_cairo_pattern(&p, bbox, opacity);
+                let p = self.variant.to_cairo_gradient(values, &params);
+                self.common.set_on_cairo_pattern(&p, bbox, opacity);
                 let cr = draw_ctx.get_cairo_context();
                 cr.set_source(&p);
 
diff --git a/rsvg_internals/src/paint_server.rs b/rsvg_internals/src/paint_server.rs
index 9e3601fb..43d18512 100644
--- a/rsvg_internals/src/paint_server.rs
+++ b/rsvg_internals/src/paint_server.rs
@@ -55,7 +55,7 @@ impl Parse for PaintServer {
 }
 
 pub trait PaintSource {
-    type Resolved;
+    type Resolved: ResolvedPaintSource;
 
     fn resolve(
         &self,
@@ -64,15 +64,6 @@ pub trait PaintSource {
         bbox: &BoundingBox,
     ) -> Result<Option<Self::Resolved>, RenderingError>;
 
-    fn set_pattern_on_draw_context(
-        &self,
-        pattern: Self::Resolved,
-        values: &ComputedValues,
-        draw_ctx: &mut DrawingCtx,
-        opacity: &UnitInterval,
-        bbox: &BoundingBox,
-    ) -> Result<bool, RenderingError>;
-
     fn resolve_fallbacks_and_set_pattern(
         &self,
         node: &RsvgNode,
@@ -83,13 +74,23 @@ pub trait PaintSource {
         if let Some(resolved) = self.resolve(&node, draw_ctx, bbox)? {
             let cascaded = CascadedValues::new_from_node(node);
             let values = cascaded.get();
-            self.set_pattern_on_draw_context(resolved, values, draw_ctx, opacity, bbox)
+            resolved.set_pattern_on_draw_context(values, draw_ctx, opacity, bbox)
         } else {
             Ok(false)
         }
     }
 }
 
+pub trait ResolvedPaintSource {
+    fn set_pattern_on_draw_context(
+        self,
+        values: &ComputedValues,
+        draw_ctx: &mut DrawingCtx,
+        opacity: &UnitInterval,
+        bbox: &BoundingBox,
+    ) -> Result<bool, RenderingError>;
+}
+
 // Any of the attributes in gradient and pattern elements may be omitted.
 // The missing ones are resolved from the "fallback" IRI. If still missing,
 // they are resolved to the default value
diff --git a/rsvg_internals/src/pattern.rs b/rsvg_internals/src/pattern.rs
index df1a439f..1db0d3dd 100644
--- a/rsvg_internals/src/pattern.rs
+++ b/rsvg_internals/src/pattern.rs
@@ -12,7 +12,7 @@ use crate::error::{AttributeResultExt, RenderingError};
 use crate::float_eq_cairo::ApproxEqCairo;
 use crate::length::*;
 use crate::node::*;
-use crate::paint_server::{PaintSource, Resolve};
+use crate::paint_server::{PaintSource, Resolve, ResolvedPaintSource};
 use crate::parsers::ParseValue;
 use crate::properties::ComputedValues;
 use crate::property_bag::PropertyBag;
@@ -178,28 +178,29 @@ impl PaintSource for NodePattern {
 
         Ok(Some(result))
     }
+}
 
+impl ResolvedPaintSource for NodePattern {
     fn set_pattern_on_draw_context(
-        &self,
-        pattern: Self::Resolved,
+        self,
         values: &ComputedValues,
         draw_ctx: &mut DrawingCtx,
         _opacity: &UnitInterval,
         bbox: &BoundingBox,
     ) -> Result<bool, RenderingError> {
-        assert!(pattern.is_resolved());
+        assert!(self.is_resolved());
 
-        if pattern.node.borrow().is_none() {
+        if self.node.borrow().is_none() {
             // This means we didn't find any children among the fallbacks,
             // so there is nothing to render.
             return Ok(false);
         }
 
-        let units = pattern.units.unwrap();
-        let content_units = pattern.content_units.unwrap();
-        let pattern_affine = pattern.affine.unwrap();
-        let vbox = pattern.vbox.unwrap();
-        let preserve_aspect_ratio = pattern.preserve_aspect_ratio.unwrap();
+        let units = self.units.unwrap();
+        let content_units = self.content_units.unwrap();
+        let pattern_affine = self.affine.unwrap();
+        let vbox = self.vbox.unwrap();
+        let preserve_aspect_ratio = self.preserve_aspect_ratio.unwrap();
 
         let (pattern_x, pattern_y, pattern_width, pattern_height) = {
             let params = if units == PatternUnits(CoordUnits::ObjectBoundingBox) {
@@ -208,10 +209,10 @@ impl PaintSource for NodePattern {
                 draw_ctx.get_view_params()
             };
 
-            let pattern_x = pattern.x.unwrap().normalize(values, &params);
-            let pattern_y = pattern.y.unwrap().normalize(values, &params);
-            let pattern_width = pattern.width.unwrap().normalize(values, &params);
-            let pattern_height = pattern.height.unwrap().normalize(values, &params);
+            let pattern_x = self.x.unwrap().normalize(values, &params);
+            let pattern_y = self.y.unwrap().normalize(values, &params);
+            let pattern_width = self.width.unwrap().normalize(values, &params);
+            let pattern_height = self.height.unwrap().normalize(values, &params);
 
             (pattern_x, pattern_y, pattern_width, pattern_height)
         };
@@ -338,7 +339,7 @@ impl PaintSource for NodePattern {
         // Set up transformations to be determined by the contents units
 
         // Draw everything
-        let pattern_node = pattern.node.borrow().as_ref().unwrap().upgrade().unwrap();
+        let pattern_node = self.node.borrow().as_ref().unwrap().upgrade().unwrap();
         let pattern_cascaded = CascadedValues::new_from_node(&pattern_node);
         let pattern_values = pattern_cascaded.get();