[librsvg] CHandle: move the load_flags value from Handle to here

[Federico Mena Quintero <federico src gnome org>]

commit e217de7270b766e737a40de19995cf8ecfd74c4c
Author: Federico Mena Quintero <federico gnome org>
Date:   Fri Apr 5 12:19:04 2019 -0600

    CHandle: move the load_flags value from Handle to here

 librsvg_crate/src/lib.rs           |  9 +++++++--
 rsvg_internals/src/c_api.rs        | 18 +++++++++++-------
 rsvg_internals/src/handle.rs       | 26 +++++++++-----------------
 rsvg_internals/src/pixbuf_utils.rs |  9 +++++++--
 4 files changed, 34 insertions(+), 28 deletions(-)
---
diff --git a/librsvg_crate/src/lib.rs b/librsvg_crate/src/lib.rs
index 8308bf8d..585cf127 100644
--- a/librsvg_crate/src/lib.rs
+++ b/librsvg_crate/src/lib.rs
@@ -278,8 +278,13 @@ impl Loader {
         base_file: Option<&gio::File>,
         cancellable: P,
     ) -> Result<SvgHandle, LoadingError> {
-        let handle = Handle::new(self.load_flags());
-        handle.construct_read_stream_sync(stream, base_file, cancellable.into())?;
+        let handle = Handle::new();
+        handle.construct_read_stream_sync(
+            self.load_flags(),
+            stream,
+            base_file,
+            cancellable.into(),
+        )?;
 
         Ok(SvgHandle(handle))
     }
diff --git a/rsvg_internals/src/c_api.rs b/rsvg_internals/src/c_api.rs
index c9e51f70..6396c42c 100644
--- a/rsvg_internals/src/c_api.rs
+++ b/rsvg_internals/src/c_api.rs
@@ -158,6 +158,7 @@ pub struct RsvgHandle {
 /// from the C API.
 pub struct CHandle {
     dpi: Cell<Dpi>,
+    load_flags: Cell<LoadFlags>,
     handle: Handle,
 }
 
@@ -285,7 +286,8 @@ impl ObjectSubclass for CHandle {
     fn new() -> Self {
         CHandle {
             dpi: Cell::new(Dpi::default()),
-            handle: Handle::new(LoadFlags::default()),
+            load_flags: Cell::new(LoadFlags::default()),
+            handle: Handle::new(),
         }
     }
 }
@@ -299,7 +301,7 @@ impl ObjectImpl for CHandle {
         match *prop {
             subclass::Property("flags", ..) => {
                 let v: HandleFlags = value.get().expect("flags value has incorrect type");
-                self.handle.set_load_flags(LoadFlags::from(v));
+                self.load_flags.set(LoadFlags::from(v));
             }
 
             subclass::Property("dpi-x", ..) => {
@@ -333,7 +335,7 @@ impl ObjectImpl for CHandle {
 
         match *prop {
             subclass::Property("flags", ..) => {
-                let flags = HandleFlags::from(self.handle.get_load_flags());
+                let flags = HandleFlags::from(self.load_flags.get());
                 Ok(flags.to_value())
             }
 
@@ -542,7 +544,7 @@ pub unsafe extern "C" fn rsvg_rust_handle_get_flags(
 ) -> RsvgHandleFlags {
     let rhandle = get_rust_handle(raw_handle);
 
-    HandleFlags::from(rhandle.handle.get_load_flags()).to_glib()
+    HandleFlags::from(rhandle.load_flags.get()).to_glib()
 }
 
 #[no_mangle]
@@ -553,7 +555,7 @@ pub unsafe extern "C" fn rsvg_rust_handle_set_flags(
     let rhandle = get_rust_handle(raw_handle);
 
     let flags: HandleFlags = from_glib(flags);
-    rhandle.handle.set_load_flags(LoadFlags::from(flags));
+    rhandle.load_flags.set(LoadFlags::from(flags));
 }
 
 #[no_mangle]
@@ -598,7 +600,7 @@ pub unsafe extern "C" fn rsvg_rust_handle_read_stream_sync(
 
     match rhandle
         .handle
-        .read_stream_sync(&stream, cancellable.as_ref())
+        .read_stream_sync(rhandle.load_flags.get(), &stream, cancellable.as_ref())
     {
         Ok(()) => true.to_glib(),
 
@@ -635,7 +637,7 @@ pub unsafe extern "C" fn rsvg_rust_handle_close(
 ) -> glib_sys::gboolean {
     let rhandle = get_rust_handle(handle);
 
-    match rhandle.handle.close() {
+    match rhandle.handle.close(rhandle.load_flags.get()) {
         Ok(()) => true.to_glib(),
 
         Err(e) => {
@@ -822,6 +824,7 @@ pub unsafe extern "C" fn rsvg_rust_handle_new_from_gfile_sync(
         .map_err(|e| LoadingError::from(e))
         .and_then(|stream| {
             rhandle.handle.construct_read_stream_sync(
+                rhandle.load_flags.get(),
                 &stream.upcast(),
                 Some(&file),
                 cancellable.as_ref(),
@@ -856,6 +859,7 @@ pub unsafe extern "C" fn rsvg_rust_handle_new_from_stream_sync(
     let cancellable: Option<gio::Cancellable> = from_glib_none(cancellable);
 
     match rhandle.handle.construct_read_stream_sync(
+        rhandle.load_flags.get(),
         &stream,
         base_file.as_ref(),
         cancellable.as_ref(),
diff --git a/rsvg_internals/src/handle.rs b/rsvg_internals/src/handle.rs
index e7acc658..c4c9a77b 100644
--- a/rsvg_internals/src/handle.rs
+++ b/rsvg_internals/src/handle.rs
@@ -115,7 +115,6 @@ pub struct Handle {
     pub base_url: RefCell<Option<Url>>,
     base_url_cstring: RefCell<Option<CString>>, // needed because the C api returns *const char
     svg: RefCell<Option<Rc<Svg>>>,
-    load_flags: Cell<LoadFlags>,
     load_state: Cell<LoadState>,
     buffer: RefCell<Vec<u8>>, // used by the legacy write() api
     size_callback: RefCell<SizeCallback>,
@@ -124,12 +123,11 @@ pub struct Handle {
 }
 
 impl Handle {
-    pub fn new(load_flags: LoadFlags) -> Handle {
+    pub fn new() -> Handle {
         Handle {
             base_url: RefCell::new(None),
             base_url_cstring: RefCell::new(None),
             svg: RefCell::new(None),
-            load_flags: Cell::new(load_flags),
             load_state: Cell::new(LoadState::Start),
             buffer: RefCell::new(Vec::new()),
             size_callback: RefCell::new(SizeCallback::default()),
@@ -138,14 +136,6 @@ impl Handle {
         }
     }
 
-    pub fn set_load_flags(&self, load_flags: LoadFlags) {
-        self.load_flags.set(load_flags);
-    }
-
-    pub fn get_load_flags(&self) -> LoadFlags {
-        self.load_flags.get()
-    }
-
     // from the public API
     pub fn set_base_url(&self, url: &str) {
         if self.load_state.get() != LoadState::Start {
@@ -206,13 +196,14 @@ impl Handle {
 
     pub fn read_stream_sync(
         &self,
+        load_flags: LoadFlags,
         stream: &gio::InputStream,
         cancellable: Option<&gio::Cancellable>,
     ) -> Result<(), LoadingError> {
         self.load_state.set(LoadState::Loading);
 
         let svg =
-            Svg::load_from_stream(&self.load_options(), stream, cancellable).map_err(|e| {
+            Svg::load_from_stream(&self.load_options(load_flags), stream, cancellable).map_err(|e| {
                 self.load_state.set(LoadState::ClosedError);
                 e
             })?;
@@ -250,9 +241,9 @@ impl Handle {
         self.load_state.get()
     }
 
-    fn load_options(&self) -> LoadOptions {
+    fn load_options(&self, load_flags: LoadFlags) -> LoadOptions {
         LoadOptions::new(
-            self.load_flags.get(),
+            load_flags,
             self.base_url.borrow().clone(),
             locale_from_environment(),
         )
@@ -268,7 +259,7 @@ impl Handle {
         self.buffer.borrow_mut().extend_from_slice(buf);
     }
 
-    pub fn close(&self) -> Result<(), LoadingError> {
+    pub fn close(&self, load_flags: LoadFlags) -> Result<(), LoadingError> {
         let res = match self.load_state.get() {
             LoadState::Start => {
                 self.load_state.set(LoadState::ClosedError);
@@ -280,7 +271,7 @@ impl Handle {
                 let bytes = Bytes::from(&*buffer);
                 let stream = gio::MemoryInputStream::new_from_bytes(&bytes);
 
-                self.read_stream_sync(&stream.upcast(), None)
+                self.read_stream_sync(load_flags, &stream.upcast(), None)
             }
 
             LoadState::ClosedOk | LoadState::ClosedError => {
@@ -621,6 +612,7 @@ impl Handle {
 
     pub fn construct_read_stream_sync(
         &self,
+        load_flags: LoadFlags,
         stream: &gio::InputStream,
         base_file: Option<&gio::File>,
         cancellable: Option<&gio::Cancellable>,
@@ -629,7 +621,7 @@ impl Handle {
             self.set_base_gfile(file);
         }
 
-        self.read_stream_sync(stream, cancellable)
+        self.read_stream_sync(load_flags, stream, cancellable)
     }
 
     pub fn get_intrinsic_dimensions(&self) -> IntrinsicDimensions {
diff --git a/rsvg_internals/src/pixbuf_utils.rs b/rsvg_internals/src/pixbuf_utils.rs
index 63b8d60d..2b03f02f 100644
--- a/rsvg_internals/src/pixbuf_utils.rs
+++ b/rsvg_internals/src/pixbuf_utils.rs
@@ -206,13 +206,18 @@ fn pixbuf_from_file_with_size_mode(
         let path = PathBuf::from_glib_none(filename);
         let file = gio::File::new_for_path(path);
 
-        let handle = Handle::new(LoadFlags::default());
+        let handle = Handle::new();
         let cancellable: Option<&gio::Cancellable> = None;
         if let Err(e) = file
             .read(cancellable)
             .map_err(|e| LoadingError::from(e))
             .and_then(|stream| {
-                handle.construct_read_stream_sync(&stream.upcast(), Some(&file), None)
+                handle.construct_read_stream_sync(
+                    LoadFlags::default(),
+                    &stream.upcast(),
+                    Some(&file),
+                    None,
+                )
             })
         {
             set_gerror(error, 0, &format!("{}", e));