[librsvg] rsvg_load_read_stream_sync(): Port most of this to Rust

[Federico Mena Quintero <federico src gnome org>]

commit 4d8ab01bc2aad0aec5c75b205d1a7bd63450fe08
Author: Federico Mena Quintero <federico gnome org>
Date:   Fri Dec 7 11:01:54 2018 -0600

    rsvg_load_read_stream_sync(): Port most of this to Rust

 librsvg/rsvg-load.c             | 35 ++++++++++-------------------------
 rsvg_internals/src/io.rs        | 31 +++----------------------------
 rsvg_internals/src/lib.rs       |  4 +---
 rsvg_internals/src/xml2_load.rs | 23 ++++++++++++++++++-----
 4 files changed, 32 insertions(+), 61 deletions(-)
---
diff --git a/librsvg/rsvg-load.c b/librsvg/rsvg-load.c
index b15e4f95..a786a403 100644
--- a/librsvg/rsvg-load.c
+++ b/librsvg/rsvg-load.c
@@ -48,11 +48,11 @@ extern gboolean rsvg_xml_state_tree_is_valid(RsvgXmlState *xml, GError **error);
 extern void rsvg_xml_state_error(RsvgXmlState *xml, const char *msg);
 
 /* Implemented in rsvg_internals/src/xml2_load.rs */
-extern gboolean rsvg_xml_state_parse_from_stream (RsvgXmlState *xml,
-                                                  gboolean      unlimited_size,
-                                                  GInputStream *stream,
-                                                  GCancellable *cancellable,
-                                                  GError      **error);
+extern gboolean rsvg_xml_state_load_from_possibly_compressed_stream (RsvgXmlState *xml,
+                                                                     gboolean      unlimited_size,
+                                                                     GInputStream *stream,
+                                                                     GCancellable *cancellable,
+                                                                     GError      **error);
 
 /* Implemented in rsvg_internals/src/handle.rs */
 extern void rsvg_handle_rust_steal_result (RsvgHandleRust *raw_handle, RsvgXmlState *xml);
@@ -226,12 +226,6 @@ close_impl (RsvgLoad *load, GError ** error)
 #define GZ_MAGIC_0 ((guchar) 0x1f)
 #define GZ_MAGIC_1 ((guchar) 0x8b)
 
-/* Implemented in rsvg_internals/src/io.rs */
-extern GInputStream *
-rsvg_get_input_stream_for_loading (GInputStream *stream,
-                                   GCancellable *cancellable,
-                                   GError      **error);
-
 gboolean
 rsvg_load_read_stream_sync (RsvgLoad     *load,
                             GInputStream *stream,
@@ -241,26 +235,17 @@ rsvg_load_read_stream_sync (RsvgLoad     *load,
     GError *err = NULL;
     gboolean res = FALSE;
 
-    stream = rsvg_get_input_stream_for_loading (stream, cancellable, error);
-    if (stream == NULL) {
-        goto out;
-    }
-
     g_assert (load->xml.ctxt == NULL);
 
-    res = rsvg_xml_state_parse_from_stream (load->xml.rust_state,
-                                            load->unlimited_size,
-                                            stream,
-                                            cancellable,
-                                            &err);
+    res = rsvg_xml_state_load_from_possibly_compressed_stream (load->xml.rust_state,
+                                                               load->unlimited_size,
+                                                               stream,
+                                                               cancellable,
+                                                               &err);
     if (!res) {
         g_propagate_error (error, err);
     }
 
-    g_object_unref (stream);
-
-out:
-
     load->state = LOAD_STATE_CLOSED;
 
     return res;
diff --git a/rsvg_internals/src/io.rs b/rsvg_internals/src/io.rs
index 9cd7fb16..aad45638 100644
--- a/rsvg_internals/src/io.rs
+++ b/rsvg_internals/src/io.rs
@@ -1,6 +1,4 @@
 use data_url;
-use gio_sys;
-use glib_sys;
 use libc;
 
 use gio::{
@@ -17,7 +15,6 @@ use gio::{
     ZlibDecompressor,
 };
 use glib::{self, translate::*, Bytes as GBytes, Cast};
-use std::ptr;
 
 use allowed_url::AllowedUrl;
 use error::{LoadingError, RsvgError};
@@ -67,14 +64,14 @@ pub fn binary_data_to_glib(
 const GZ_MAGIC_0: u8 = 0x1f;
 const GZ_MAGIC_1: u8 = 0x8b;
 
-fn get_input_stream_for_loading(
+pub fn get_input_stream_for_loading(
     stream: InputStream,
-    cancellable: Option<Cancellable>,
+    cancellable: Option<&Cancellable>,
 ) -> Result<InputStream, glib::Error> {
     // detect gzipped streams (svgz)
 
     let buffered = BufferedInputStream::new(&stream);
-    let num_read = buffered.fill(2, cancellable.as_ref())?;
+    let num_read = buffered.fill(2, cancellable)?;
     if num_read < 2 {
         // FIXME: this string was localized in the original; localize it
         return Err(glib::Error::new(RsvgError, "Input file is too short"));
@@ -91,28 +88,6 @@ fn get_input_stream_for_loading(
     }
 }
 
-#[no_mangle]
-pub unsafe fn rsvg_get_input_stream_for_loading(
-    stream: *mut gio_sys::GInputStream,
-    cancellable: *mut gio_sys::GCancellable,
-    error: *mut *mut glib_sys::GError,
-) -> *mut gio_sys::GInputStream {
-    let stream = from_glib_borrow(stream);
-    let cancellable = from_glib_borrow(cancellable);
-
-    match get_input_stream_for_loading(stream, cancellable) {
-        Ok(stream) => stream.to_glib_full(),
-
-        Err(e) => {
-            if !error.is_null() {
-                *error = e.to_glib_full() as *mut _;
-            }
-
-            ptr::null_mut()
-        }
-    }
-}
-
 /// Returns an input stream.  The url can be a data: URL or a plain URI
 pub fn acquire_stream(
     aurl: &AllowedUrl,
diff --git a/rsvg_internals/src/lib.rs b/rsvg_internals/src/lib.rs
index a2e78376..bc0164bc 100644
--- a/rsvg_internals/src/lib.rs
+++ b/rsvg_internals/src/lib.rs
@@ -57,8 +57,6 @@ pub use handle::{
     rsvg_handle_rust_steal_result,
 };
 
-pub use io::rsvg_get_input_stream_for_loading;
-
 pub use node::rsvg_node_unref;
 
 pub use structure::rsvg_node_svg_get_size;
@@ -73,7 +71,7 @@ pub use xml::{
 pub use xml2_load::{
     rsvg_create_xml_push_parser,
     rsvg_set_error_from_xml,
-    rsvg_xml_state_parse_from_stream,
+    rsvg_xml_state_load_from_possibly_compressed_stream,
 };
 
 #[macro_use]
diff --git a/rsvg_internals/src/xml2_load.rs b/rsvg_internals/src/xml2_load.rs
index fa5993da..57cf72d3 100644
--- a/rsvg_internals/src/xml2_load.rs
+++ b/rsvg_internals/src/xml2_load.rs
@@ -15,6 +15,7 @@ use std::str;
 use glib::translate::*;
 
 use error::set_gerror;
+use io::get_input_stream_for_loading;
 use property_bag::PropertyBag;
 use util::utf8_cstr;
 use xml::XmlState;
@@ -285,7 +286,7 @@ impl Xml2Parser {
         xml: &mut XmlState,
         unlimited_size: bool,
         stream: gio::InputStream,
-        cancellable: Option<gio::Cancellable>,
+        cancellable: Option<&gio::Cancellable>,
     ) -> Result<Xml2Parser, ParseFromStreamError> {
         // The Xml2Parser we end up creating, if
         // xmlCreateIOParserCtxt() is successful, needs to hold a
@@ -298,7 +299,7 @@ impl Xml2Parser {
 
         let ctx = Box::new(StreamCtx {
             stream,
-            cancellable,
+            cancellable: cancellable.map(|c| c.clone()),
             gio_error: gio_error.clone(),
         });
 
@@ -431,14 +432,26 @@ pub fn xml_state_parse_from_stream(
     xml: &mut XmlState,
     unlimited_size: bool,
     stream: gio::InputStream,
-    cancellable: Option<gio::Cancellable>,
+    cancellable: Option<&gio::Cancellable>,
 ) -> Result<(), ParseFromStreamError> {
     Xml2Parser::from_stream(xml, unlimited_size, stream, cancellable)
         .and_then(|parser| parser.parse())
 }
 
+fn xml_state_load_from_possibly_compressed_stream(
+    xml: &mut XmlState,
+    unlimited_size: bool,
+    stream: gio::InputStream,
+    cancellable: Option<gio::Cancellable>,
+) -> Result<(), ParseFromStreamError> {
+    let stream = get_input_stream_for_loading(stream, cancellable.as_ref())
+        .map_err(|e| ParseFromStreamError::IoError(e))?;
+
+    xml_state_parse_from_stream(xml, unlimited_size, stream, cancellable.as_ref())
+}
+
 #[no_mangle]
-pub unsafe extern "C" fn rsvg_xml_state_parse_from_stream(
+pub unsafe extern "C" fn rsvg_xml_state_load_from_possibly_compressed_stream(
     xml: *mut XmlState,
     unlimited_size: glib_sys::gboolean,
     stream: *mut gio_sys::GInputStream,
@@ -453,7 +466,7 @@ pub unsafe extern "C" fn rsvg_xml_state_parse_from_stream(
     let stream = from_glib_none(stream);
     let cancellable = from_glib_none(cancellable);
 
-    match xml_state_parse_from_stream(xml, unlimited_size, stream, cancellable) {
+    match xml_state_load_from_possibly_compressed_stream(xml, unlimited_size, stream, cancellable) {
         Ok(()) => true.to_glib(),
 
         Err(e) => {