[librsvg: 4/5] CHandle: move the configuration part to an inner structure

[Federico Mena Quintero <federico src gnome org>]

commit 9a2ec3586e0480192954193a09d0bf5b3440f492
Author: Federico Mena Quintero <federico gnome org>
Date:   Mon Oct 28 15:45:34 2019 -0600

    CHandle: move the configuration part to an inner structure
    
    This separates the load_state from the inner_config.  Since the config
    is now a RefCell<CHandleInner>, we don't need a bunch of .get() or
    .borrow_mut() everywhere when dealing with individual fields anymore.

 librsvg/c_api.rs | 141 +++++++++++++++++++++++++++++++------------------------
 1 file changed, 79 insertions(+), 62 deletions(-)
---
diff --git a/librsvg/c_api.rs b/librsvg/c_api.rs
index 05b7ffe0..9bfe61ae 100644
--- a/librsvg/c_api.rs
+++ b/librsvg/c_api.rs
@@ -1,4 +1,4 @@
-use std::cell::{Cell, Ref, RefCell, RefMut};
+use std::cell::{Ref, RefCell, RefMut};
 use std::ffi::{CStr, CString};
 use std::ops;
 use std::path::PathBuf;
@@ -198,14 +198,18 @@ impl BaseUrl {
 /// Contains all the interior mutability for a RsvgHandle to be called
 /// from the C API.
 pub struct CHandle {
-    dpi: Cell<Dpi>,
-    load_flags: Cell<LoadFlags>,
-    base_url: RefCell<BaseUrl>,
-    size_callback: RefCell<SizeCallback>,
-    is_testing: Cell<bool>,
+    inner: RefCell<CHandleInner>,
     load_state: RefCell<LoadState>,
 }
 
+struct CHandleInner {
+    dpi: Dpi,
+    load_flags: LoadFlags,
+    base_url: BaseUrl,
+    size_callback: SizeCallback,
+    is_testing: bool,
+}
+
 unsafe impl ClassStruct for RsvgHandleClass {
     type Type = CHandle;
 }
@@ -329,11 +333,13 @@ impl ObjectSubclass for CHandle {
 
     fn new() -> Self {
         CHandle {
-            dpi: Cell::new(Dpi::default()),
-            load_flags: Cell::new(LoadFlags::default()),
-            base_url: RefCell::new(BaseUrl::default()),
-            size_callback: RefCell::new(SizeCallback::default()),
-            is_testing: Cell::new(false),
+            inner: RefCell::new(CHandleInner {
+                dpi: Dpi::default(),
+                load_flags: LoadFlags::default(),
+                base_url: BaseUrl::default(),
+                size_callback: SizeCallback::default(),
+                is_testing: false,
+            }),
             load_state: RefCell::new(LoadState::Start),
         }
     }
@@ -387,12 +393,7 @@ impl ObjectImpl for CHandle {
             subclass::Property("dpi-x", ..) => Ok(self.get_dpi_x().to_value()),
             subclass::Property("dpi-y", ..) => Ok(self.get_dpi_y().to_value()),
 
-            subclass::Property("base-uri", ..) => Ok(self
-                .base_url
-                .borrow()
-                .get()
-                .map(|url| url.as_str())
-                .to_value()),
+            subclass::Property("base-uri", ..) => Ok(self.get_base_url().to_value()),
 
             subclass::Property("width", ..) =>
                 Ok(self.get_dimensions_or_empty().width.to_value()),
@@ -433,7 +434,8 @@ impl CHandle {
         match Url::parse(&url) {
             Ok(u) => {
                 rsvg_log!("setting base_uri to \"{}\"", u.as_str());
-                self.base_url.borrow_mut().set(u);
+                let mut inner = self.inner.borrow_mut();
+                inner.base_url.set(u);
             }
 
             Err(e) => {
@@ -450,41 +452,54 @@ impl CHandle {
         self.set_base_url(&file.get_uri());
     }
 
+    fn get_base_url(&self) -> Option<String> {
+        let inner = self.inner.borrow();
+        inner.base_url.get().map(|url| url.as_str().to_string())
+    }
+
     fn get_base_url_as_ptr(&self) -> *const libc::c_char {
-        self.base_url.borrow().get_ptr()
+        let inner = self.inner.borrow();
+        inner.base_url.get_ptr()
     }
 
     fn set_dpi_x(&self, dpi_x: f64) {
-        let dpi = self.dpi.get();
-        self.dpi.set(Dpi::new(dpi_x, dpi.y()));
+        let mut inner = self.inner.borrow_mut();
+        let dpi = inner.dpi;
+        inner.dpi = Dpi::new(dpi_x, dpi.y());
     }
 
     fn set_dpi_y(&self, dpi_y: f64) {
-        let dpi = self.dpi.get();
-        self.dpi.set(Dpi::new(dpi.x(), dpi_y));
+        let mut inner = self.inner.borrow_mut();
+        let dpi = inner.dpi;
+        inner.dpi = Dpi::new(dpi.x(), dpi_y);
     }
 
     fn get_dpi_x(&self) -> f64 {
-        self.dpi.get().x()
+        let inner = self.inner.borrow();
+        inner.dpi.x()
     }
 
     fn get_dpi_y(&self) -> f64 {
-        self.dpi.get().y()
+        let inner = self.inner.borrow();
+        inner.dpi.y()
     }
 
     fn set_flags(&self, flags: HandleFlags) {
-        self.load_flags.set(LoadFlags::from(flags));
+        let mut inner = self.inner.borrow_mut();
+        inner.load_flags = LoadFlags::from(flags);
     }
 
     fn get_flags(&self) -> HandleFlags {
-        HandleFlags::from(self.load_flags.get())
+        let inner = self.inner.borrow();
+        HandleFlags::from(inner.load_flags)
     }
 
     fn load_options(&self) -> LoadOptions {
-        let flags = self.load_flags.get();
-        LoadOptions::new(self.base_url.borrow().get().map(|u| (*u).clone()))
-            .with_unlimited_size(flags.unlimited_size)
-            .keep_image_data(flags.keep_image_data)
+        let inner = self.inner.borrow();
+
+        LoadOptions::new(inner.base_url.get().map(|u| (*u).clone()))
+            .with_unlimited_size(inner.load_flags.unlimited_size)
+            .keep_image_data(inner.load_flags.keep_image_data)
     }
 
     fn set_size_callback(
@@ -493,7 +508,8 @@ impl CHandle {
         user_data: glib_sys::gpointer,
         destroy_notify: glib_sys::GDestroyNotify,
     ) {
-        *self.size_callback.borrow_mut() = SizeCallback::new(size_func, user_data, destroy_notify);
+        let mut inner = self.inner.borrow_mut();
+        inner.size_callback = SizeCallback::new(size_func, user_data, destroy_notify);
     }
 
     fn write(&self, buf: &[u8]) {
@@ -504,16 +520,16 @@ impl CHandle {
                 *state = LoadState::Loading {
                     buffer: Vec::from(buf),
                 }
-            }
+            },
 
             LoadState::Loading { ref mut buffer } => {
                 buffer.extend_from_slice(buf);
-            }
+            },
 
             _ => {
                 rsvg_g_critical("Handle must not be closed in order to write to it");
                 return;
-            }
+            },
         }
     }
 
@@ -618,23 +634,23 @@ impl CHandle {
 
     fn get_dimensions(&self) -> Result<RsvgDimensionData, RenderingError> {
         let handle = self.get_handle_ref()?;
-        let size_callback = self.size_callback.borrow();
-        handle.get_dimensions(self.dpi.get(), &*size_callback, self.is_testing.get())
+        let inner = self.inner.borrow();
+        handle.get_dimensions(inner.dpi, &inner.size_callback, inner.is_testing)
     }
 
     fn get_dimensions_sub(&self, id: Option<&str>) -> Result<RsvgDimensionData, RenderingError> {
         let handle = self.get_handle_ref()?;
-        let size_callback = self.size_callback.borrow();
+        let inner = self.inner.borrow();
         handle
-            .get_dimensions_sub(id, self.dpi.get(), &*size_callback, self.is_testing.get())
+            .get_dimensions_sub(id, inner.dpi, &inner.size_callback, inner.is_testing)
             .map_err(warn_on_invalid_id)
     }
 
     fn get_position_sub(&self, id: Option<&str>) -> Result<RsvgPositionData, RenderingError> {
         let handle = self.get_handle_ref()?;
-        let size_callback = self.size_callback.borrow();
+        let inner = self.inner.borrow();
         handle
-            .get_position_sub(id, self.dpi.get(), &*size_callback, self.is_testing.get())
+            .get_position_sub(id, inner.dpi, &inner.size_callback, inner.is_testing)
             .map_err(warn_on_invalid_id)
     }
 
@@ -646,25 +662,26 @@ impl CHandle {
         check_cairo_context(cr)?;
 
         let handle = self.get_handle_ref()?;
-        let size_callback = self.size_callback.borrow();
+        let inner = self.inner.borrow();
         handle
             .render_cairo_sub(
                 cr,
                 id,
-                self.dpi.get(),
-                &*size_callback,
-                self.is_testing.get(),
+                inner.dpi,
+                &inner.size_callback,
+                inner.is_testing,
             )
             .map_err(warn_on_invalid_id)
     }
 
     fn get_pixbuf_sub(&self, id: Option<&str>) -> Result<Pixbuf, RenderingError> {
         let handle = self.get_handle_ref()?;
-        let size_callback = self.size_callback.borrow();
-        let dpi = self.dpi.get();
-        let is_testing = self.is_testing.get();
+        let inner = self.inner.borrow();
+
+        let dpi = inner.dpi;
+        let is_testing = inner.is_testing;
 
-        let dimensions = handle.get_dimensions(dpi, &size_callback, is_testing)?;
+        let dimensions = handle.get_dimensions(dpi, &inner.size_callback, is_testing)?;
 
         if dimensions.width == 0 || dimensions.height == 0 {
             return empty_pixbuf();
@@ -676,7 +693,7 @@ impl CHandle {
         {
             let cr = cairo::Context::new(&surface);
             handle
-                .render_cairo_sub(&cr, id, dpi, &size_callback, is_testing)
+                .render_cairo_sub(&cr, id, dpi, &inner.size_callback, is_testing)
                 .map_err(warn_on_invalid_id)?;
         }
 
@@ -693,7 +710,8 @@ impl CHandle {
         check_cairo_context(cr)?;
 
         let handle = self.get_handle_ref()?;
-        handle.render_document(cr, viewport, self.dpi.get(), self.is_testing.get())
+        let inner = self.inner.borrow();
+        handle.render_document(cr, viewport, inner.dpi, inner.is_testing)
     }
 
     fn get_geometry_for_layer(
@@ -702,8 +720,9 @@ impl CHandle {
         viewport: &cairo::Rectangle,
     ) -> Result<(RsvgRectangle, RsvgRectangle), RenderingError> {
         let handle = self.get_handle_ref()?;
+        let inner = self.inner.borrow();
         handle
-            .get_geometry_for_layer(id, viewport, self.dpi.get(), self.is_testing.get())
+            .get_geometry_for_layer(id, viewport, inner.dpi, inner.is_testing)
             .map_err(warn_on_invalid_id)
     }
 
@@ -716,8 +735,9 @@ impl CHandle {
         check_cairo_context(cr)?;
 
         let handle = self.get_handle_ref()?;
+        let inner = self.inner.borrow();
         handle
-            .render_layer(cr, id, viewport, self.dpi.get(), self.is_testing.get())
+            .render_layer(cr, id, viewport, inner.dpi, inner.is_testing)
             .map_err(warn_on_invalid_id)
     }
 
@@ -726,8 +746,9 @@ impl CHandle {
         id: Option<&str>,
     ) -> Result<(RsvgRectangle, RsvgRectangle), RenderingError> {
         let handle = self.get_handle_ref()?;
+        let inner = self.inner.borrow();
         handle
-            .get_geometry_for_element(id, self.dpi.get(), self.is_testing.get())
+            .get_geometry_for_element(id, inner.dpi, inner.is_testing)
             .map_err(warn_on_invalid_id)
     }
 
@@ -740,14 +761,9 @@ impl CHandle {
         check_cairo_context(cr)?;
 
         let handle = self.get_handle_ref()?;
+        let inner = self.inner.borrow();
         handle
-            .render_element(
-                cr,
-                id,
-                element_viewport,
-                self.dpi.get(),
-                self.is_testing.get(),
-            )
+            .render_element(cr, id, element_viewport, inner.dpi, inner.is_testing)
             .map_err(warn_on_invalid_id)
     }
 
@@ -757,7 +773,8 @@ impl CHandle {
     }
 
     fn set_testing(&self, is_testing: bool) {
-        self.is_testing.set(is_testing);
+        let mut inner = self.inner.borrow_mut();
+        inner.is_testing = is_testing;
     }
 }