[librsvg: 2/12] render_markers_for_shape: resolve the marker nodes here, not downstream

[Federico Mena Quintero <federico src gnome org>]

commit 8c40797f044e489a20ca1ff22b78b5beeb9f0431
Author: Federico Mena Quintero <federico gnome org>
Date:   Thu Jun 3 11:54:34 2021 -0500

    render_markers_for_shape: resolve the marker nodes here, not downstream

 src/marker.rs | 70 +++++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 47 insertions(+), 23 deletions(-)
---
diff --git a/src/marker.rs b/src/marker.rs
index 338fef76..a4ed8247 100644
--- a/src/marker.rs
+++ b/src/marker.rs
@@ -9,9 +9,9 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
 use crate::angle::Angle;
 use crate::aspect_ratio::*;
 use crate::bbox::BoundingBox;
-use crate::document::{AcquiredNodes, NodeId};
+use crate::document::AcquiredNodes;
 use crate::drawing_ctx::DrawingCtx;
-use crate::element::{Draw, Element, ElementResult, SetAttributes};
+use crate::element::{Draw, ElementResult, SetAttributes};
 use crate::error::*;
 use crate::float_eq_cairo::ApproxEqCairo;
 use crate::iri::Iri;
@@ -548,21 +548,23 @@ enum MarkerType {
     End,
 }
 
-fn emit_marker_by_name(
+fn emit_marker_by_node(
     draw_ctx: &mut DrawingCtx,
     acquired_nodes: &mut AcquiredNodes<'_>,
-    name: &NodeId,
+    marker_node: &Node,
     xpos: f64,
     ypos: f64,
     computed_angle: Angle,
     line_width: f64,
     clipping: bool,
 ) -> Result<BoundingBox, RenderingError> {
-    if let Ok(acquired) = acquired_nodes.acquire(name) {
-        let node = acquired.get();
+    match acquired_nodes.acquire_ref(marker_node) {
+        Ok(acquired) => {
+            let node = acquired.get();
 
-        match *node.borrow_element() {
-            Element::Marker(ref m) => m.render(
+            let marker = borrow_element_as!(marker_node, Marker);
+
+            marker.render(
                 &node,
                 acquired_nodes,
                 draw_ctx,
@@ -571,15 +573,13 @@ fn emit_marker_by_name(
                 computed_angle,
                 line_width,
                 clipping,
-            ),
-            _ => {
-                rsvg_log!("\"{}\" is not marker", name);
-                Ok(draw_ctx.empty_bbox())
-            }
+            )
+        }
+
+        Err(e) => {
+            rsvg_log!("could not acquire marker: {}", e);
+            Ok(draw_ctx.empty_bbox())
         }
-    } else {
-        rsvg_log!("marker \"{}\" not found", name);
-        Ok(draw_ctx.empty_bbox())
     }
 }
 
@@ -622,11 +622,11 @@ pub fn render_markers_for_shape(
         return Ok(draw_ctx.empty_bbox());
     }
 
-    let marker_start = values.marker_start().0;
-    let marker_mid = values.marker_mid().0;
-    let marker_end = values.marker_end().0;
+    let marker_start = acquire_marker(acquired_nodes, &values.marker_start().0);
+    let marker_mid = acquire_marker(acquired_nodes, &values.marker_mid().0);
+    let marker_end = acquire_marker(acquired_nodes, &values.marker_end().0);
 
-    if let (&Iri::None, &Iri::None, &Iri::None) = (&marker_start, &marker_mid, &marker_end) {
+    if marker_start.is_none() && marker_mid.is_none() && marker_end.is_none() {
         return Ok(draw_ctx.empty_bbox());
     }
 
@@ -634,12 +634,14 @@ pub fn render_markers_for_shape(
         &shape.path,
         draw_ctx.empty_bbox(),
         &mut |marker_type: MarkerType, x: f64, y: f64, computed_angle: Angle| {
-            if let Iri::Resource(ref marker) = match marker_type {
+            let marker_node = match marker_type {
                 MarkerType::Start => &marker_start,
                 MarkerType::Middle => &marker_mid,
                 MarkerType::End => &marker_end,
-            } {
-                emit_marker_by_name(
+            };
+
+            if let Some(ref marker) = *marker_node {
+                emit_marker_by_node(
                     draw_ctx,
                     acquired_nodes,
                     marker,
@@ -656,6 +658,28 @@ pub fn render_markers_for_shape(
     )
 }
 
+fn acquire_marker(acquired_nodes: &mut AcquiredNodes<'_>, iri: &Iri) -> Option<Node> {
+    iri.get().and_then(|id| {
+        acquired_nodes
+            .acquire(id)
+            .map_err(|e| {
+                rsvg_log!("cannot render marker: {}", e);
+                ()
+            })
+            .ok()
+            .and_then(|acquired| {
+                let node = acquired.get();
+
+                if is_element_of_type!(node, Marker) {
+                    Some(node.clone())
+                } else {
+                    rsvg_log!("{} is not a marker element", id);
+                    None
+                }
+            })
+    })
+}
+
 fn emit_markers_for_path<E>(
     path: &Path,
     empty_bbox: BoundingBox,