[librsvg: 17/36] pattern: partially remove interior mutability

[Federico Mena Quintero <federico src gnome org>]

commit dce09ec45f28bbe6e99849ca0d52f475ed9d030e
Author: Paolo Borelli <pborelli gnome org>
Date:   Sun Jun 30 15:57:23 2019 +0200

    pattern: partially remove interior mutability
    
    We still use refcell for the pattern node used during resolution.
    Also, the whole module can probably be simplified merging the
    NodePattern and Pattern structs.

 rsvg_internals/src/pattern.rs | 68 +++++++++++++++----------------------------
 1 file changed, 24 insertions(+), 44 deletions(-)
---
diff --git a/rsvg_internals/src/pattern.rs b/rsvg_internals/src/pattern.rs
index e0b92d6e..42606b30 100644
--- a/rsvg_internals/src/pattern.rs
+++ b/rsvg_internals/src/pattern.rs
@@ -44,7 +44,7 @@ pub struct PatternData {
     // Point back to our corresponding node, or to the fallback node which has children.
     // If the value is None, it means we are fully resolved and didn't find any children
     // among the fallbacks.
-    pub node: Option<RsvgWeakNode>,
+    pub node: RefCell<Option<RsvgWeakNode>>,
 }
 
 macro_rules! fallback_to (
@@ -81,10 +81,10 @@ impl Resolve for PatternData {
         self.fallback = fallback.fallback.clone();
 
         if !self.children_are_resolved() {
-            if fallback.node.is_some() {
-                self.node = fallback.node.clone();
+            if fallback.node.borrow().is_some() {
+                *self.node.borrow_mut() = fallback.node.borrow().clone();
             } else {
-                self.node = None;
+                *self.node.borrow_mut() = None;
             }
         }
     }
@@ -104,7 +104,7 @@ impl Resolve for PatternData {
 
 impl PatternData {
     fn children_are_resolved(&self) -> bool {
-        if let Some(ref weak) = self.node {
+        if let Some(ref weak) = *self.node.borrow() {
             let strong_node = &weak.clone().upgrade().unwrap();
             strong_node.has_children()
         } else {
@@ -116,53 +116,43 @@ impl PatternData {
 }
 
 pub struct NodePattern {
-    pattern: RefCell<PatternData>,
+    pattern: PatternData,
 }
 
 impl Default for NodePattern {
     fn default() -> NodePattern {
         NodePattern {
-            pattern: RefCell::new(PatternData::default()),
+            pattern: PatternData::default(),
         }
     }
 }
 
 impl NodeTrait for NodePattern {
     fn set_atts(&mut self, _: Option<&RsvgNode>, pbag: &PropertyBag<'_>) -> NodeResult {
-        let mut p = self.pattern.borrow_mut();
-
         for (attr, value) in pbag.iter() {
             match attr {
-                local_name!("patternUnits") => p.units = Some(attr.parse(value)?),
-
-                local_name!("patternContentUnits") => p.content_units = Some(attr.parse(value)?),
-
-                local_name!("viewBox") => p.vbox = Some(Some(attr.parse(value)?)),
-
+                local_name!("patternUnits") => self.pattern.units = Some(attr.parse(value)?),
+                local_name!("patternContentUnits") => {
+                    self.pattern.content_units = Some(attr.parse(value)?)
+                }
+                local_name!("viewBox") => self.pattern.vbox = Some(Some(attr.parse(value)?)),
                 local_name!("preserveAspectRatio") => {
-                    p.preserve_aspect_ratio = Some(attr.parse(value)?)
+                    self.pattern.preserve_aspect_ratio = Some(attr.parse(value)?)
                 }
-
-                local_name!("patternTransform") => p.affine = Some(attr.parse(value)?),
-
+                local_name!("patternTransform") => self.pattern.affine = Some(attr.parse(value)?),
                 local_name!("xlink:href") => {
-                    p.fallback = Some(Fragment::parse(value).attribute(attr)?);
+                    self.pattern.fallback = Some(Fragment::parse(value).attribute(attr)?);
                 }
-
-                local_name!("x") => p.x = Some(attr.parse(value)?),
-
-                local_name!("y") => p.y = Some(attr.parse(value)?),
-
+                local_name!("x") => self.pattern.x = Some(attr.parse(value)?),
+                local_name!("y") => self.pattern.y = Some(attr.parse(value)?),
                 local_name!("width") => {
-                    p.width =
+                    self.pattern.width =
                         Some(attr.parse_and_validate(value, LengthHorizontal::check_nonnegative)?)
                 }
-
                 local_name!("height") => {
-                    p.height =
+                    self.pattern.height =
                         Some(attr.parse_and_validate(value, LengthVertical::check_nonnegative)?)
                 }
-
                 _ => (),
             }
         }
@@ -184,18 +174,9 @@ impl PaintSource for NodePattern {
         draw_ctx: &mut DrawingCtx,
         _bbox: &BoundingBox,
     ) -> Result<Option<Self::Source>, RenderingError> {
-        {
-            // Initialize pattern.node and release the mutable borrow
-            let mut p = self.pattern.borrow_mut();
-            p.node = Some(node.downgrade());
-        }
+        *self.pattern.node.borrow_mut() = Some(node.downgrade());
 
-        let mut result = node
-            .borrow()
-            .get_impl::<NodePattern>()
-            .pattern
-            .borrow()
-            .clone();
+        let mut result = node.borrow().get_impl::<NodePattern>().pattern.clone();
         let mut stack = NodeStack::new();
 
         while !result.is_resolved() {
@@ -211,8 +192,7 @@ impl PaintSource for NodePattern {
                 }
 
                 let node_data = a_node.borrow();
-                let fallback = node_data.get_impl::<NodePattern>().pattern.borrow();
-                result.resolve_from_fallback(&fallback);
+                result.resolve_from_fallback(&node_data.get_impl::<NodePattern>().pattern);
 
                 stack.push(a_node);
             } else {
@@ -233,7 +213,7 @@ impl PaintSource for NodePattern {
     ) -> Result<bool, RenderingError> {
         assert!(pattern.is_resolved());
 
-        if pattern.node.is_none() {
+        if pattern.node.borrow().is_none() {
             // This means we didn't find any children among the fallbacks,
             // so there is nothing to render.
             return Ok(false);
@@ -382,7 +362,7 @@ impl PaintSource for NodePattern {
         // Set up transformations to be determined by the contents units
 
         // Draw everything
-        let pattern_node = pattern.node.as_ref().unwrap().upgrade().unwrap();
+        let pattern_node = pattern.node.borrow().as_ref().unwrap().upgrade().unwrap();
         let pattern_cascaded = CascadedValues::new_from_node(&pattern_node);
         let pattern_values = pattern_cascaded.get();