[librsvg: 1/18] Remove ParseFromStreamError; use LoadingError directly everywhere

[Federico Mena Quintero <federico src gnome org>]

commit e5a1b3cd3f975cdfbfb3c58b73d3d774ea2b2e53
Author: Federico Mena Quintero <federico gnome org>
Date:   Thu Dec 5 21:25:28 2019 -0600

    Remove ParseFromStreamError; use LoadingError directly everywhere

 rsvg_internals/src/io.rs        |  4 ++--
 rsvg_internals/src/xml.rs       | 26 +++++++++++++-------------
 rsvg_internals/src/xml2_load.rs | 35 ++++++-----------------------------
 3 files changed, 21 insertions(+), 44 deletions(-)
---
diff --git a/rsvg_internals/src/io.rs b/rsvg_internals/src/io.rs
index 24f47f03..a146f0a2 100644
--- a/rsvg_internals/src/io.rs
+++ b/rsvg_internals/src/io.rs
@@ -54,14 +54,14 @@ const GZ_MAGIC_1: u8 = 0x8b;
 pub fn get_input_stream_for_loading(
     stream: &InputStream,
     cancellable: Option<&Cancellable>,
-) -> Result<InputStream, glib::Error> {
+) -> Result<InputStream, LoadingError> {
     // detect gzipped streams (svgz)
 
     let buffered = BufferedInputStream::new(stream);
     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"));
+        return Err(glib::Error::new(RsvgError, "Input file is too short").into());
     }
 
     let buf = buffered.peek_buffer();
diff --git a/rsvg_internals/src/xml.rs b/rsvg_internals/src/xml.rs
index 686c4b65..825a5923 100644
--- a/rsvg_internals/src/xml.rs
+++ b/rsvg_internals/src/xml.rs
@@ -17,7 +17,7 @@ use crate::node::{NodeType, RsvgNode};
 use crate::property_bag::PropertyBag;
 use crate::style::{Style, StyleType};
 use crate::text::NodeChars;
-use crate::xml2_load::{ParseFromStreamError, Xml2Parser};
+use crate::xml2_load::Xml2Parser;
 
 #[derive(Clone)]
 enum Context {
@@ -43,7 +43,7 @@ enum Context {
     XIncludeFallback(XIncludeContext),
 
     // An XML parsing error was found.  We will no-op upon any further XML events.
-    FatalError(ParseFromStreamError),
+    FatalError(LoadingError),
 }
 
 #[derive(Clone)]
@@ -140,7 +140,7 @@ impl XmlState {
         }
     }
 
-    fn check_last_error(&self) -> Result<(), ParseFromStreamError> {
+    fn check_last_error(&self) -> Result<(), LoadingError> {
         let inner = self.inner.borrow();
 
         match inner.context() {
@@ -151,7 +151,7 @@ impl XmlState {
 
     fn check_limits(&self) -> Result<(), ()> {
         if self.inner.borrow().num_loaded_elements > MAX_LOADED_ELEMENTS {
-            self.error(ParseFromStreamError::XmlParseError(format!(
+            self.error(LoadingError::XmlParseError(format!(
                 "cannot load more than {} XML elements",
                 MAX_LOADED_ELEMENTS
             )));
@@ -275,13 +275,13 @@ impl XmlState {
                 rsvg_log!("xml-stylesheet processing instruction does not have href; ignoring");
             }
         } else {
-            self.error(ParseFromStreamError::XmlParseError(String::from(
+            self.error(LoadingError::XmlParseError(String::from(
                 "invalid processing instruction data in xml-stylesheet",
             )));
         }
     }
 
-    pub fn error(&self, e: ParseFromStreamError) {
+    pub fn error(&self, e: LoadingError) {
         self.inner
             .borrow_mut()
             .context_stack
@@ -401,7 +401,7 @@ impl XmlState {
             Ok(()) => false,
             Err(AcquireError::ResourceError) => true,
             Err(AcquireError::FatalError(s)) => {
-                return Context::FatalError(ParseFromStreamError::XmlParseError(s))
+                return Context::FatalError(LoadingError::XmlParseError(s))
             }
         };
 
@@ -539,11 +539,12 @@ impl XmlState {
 
         // FIXME: pass a cancellable
         self.parse_from_stream(&stream, None).map_err(|e| match e {
-            ParseFromStreamError::CouldNotCreateXmlParser => {
+            LoadingError::CouldNotCreateXmlParser => {
                 AcquireError::FatalError(String::from("could not create XML parser"))
             }
-            ParseFromStreamError::IoError(_) => AcquireError::ResourceError,
-            ParseFromStreamError::XmlParseError(s) => AcquireError::FatalError(s),
+            LoadingError::Glib(_) => AcquireError::ResourceError,
+            LoadingError::XmlParseError(s) => AcquireError::FatalError(s),
+            _ => AcquireError::FatalError(String::from("unknown error")),
         })
     }
 
@@ -555,7 +556,7 @@ impl XmlState {
         &self,
         stream: &gio::InputStream,
         cancellable: Option<&gio::Cancellable>,
-    ) -> Result<(), ParseFromStreamError> {
+    ) -> Result<(), LoadingError> {
         let strong = self
             .inner
             .borrow()
@@ -644,8 +645,7 @@ pub fn xml_load_from_possibly_compressed_stream(
 
     state.inner.borrow_mut().weak = Some(Rc::downgrade(&state));
 
-    let stream =
-        get_input_stream_for_loading(stream, cancellable).map_err(ParseFromStreamError::IoError)?;
+    let stream = get_input_stream_for_loading(stream, cancellable)?;
 
     state.build_document(&stream, cancellable)
 }
diff --git a/rsvg_internals/src/xml2_load.rs b/rsvg_internals/src/xml2_load.rs
index 62c1d612..09d6c36a 100644
--- a/rsvg_internals/src/xml2_load.rs
+++ b/rsvg_internals/src/xml2_load.rs
@@ -93,7 +93,7 @@ unsafe extern "C" fn rsvg_sax_serror_cb(user_data: *mut libc::c_void, error: xml
     );
     xml2_parser
         .state
-        .error(ParseFromStreamError::XmlParseError(full_error_message));
+        .error(LoadingError::XmlParseError(full_error_message));
 }
 
 fn free_xml_parser_and_doc(parser: xmlParserCtxtPtr) {
@@ -395,7 +395,7 @@ impl Xml2Parser {
         unlimited_size: bool,
         stream: &gio::InputStream,
         cancellable: Option<&gio::Cancellable>,
-    ) -> Result<Box<Xml2Parser>, ParseFromStreamError> {
+    ) -> Result<Box<Xml2Parser>, LoadingError> {
         init_libxml2();
 
         // The Xml2Parser we end up creating, if
@@ -434,7 +434,7 @@ impl Xml2Parser {
             if parser.is_null() {
                 // on error, xmlCreateIOParserCtxt() frees our ctx via the
                 // stream_ctx_close function
-                Err(ParseFromStreamError::CouldNotCreateXmlParser)
+                Err(LoadingError::CouldNotCreateXmlParser)
             } else {
                 xml2_parser.parser.set(parser);
 
@@ -445,7 +445,7 @@ impl Xml2Parser {
         }
     }
 
-    pub fn parse(&self) -> Result<(), ParseFromStreamError> {
+    pub fn parse(&self) -> Result<(), LoadingError> {
         unsafe {
             let parser = self.parser.get();
 
@@ -456,11 +456,11 @@ impl Xml2Parser {
             let io_error = err_ref.take();
 
             if let Some(io_error) = io_error {
-                Err(ParseFromStreamError::IoError(io_error))
+                Err(LoadingError::Glib(io_error))
             } else if !xml_parse_success {
                 let xerr = xmlCtxtGetLastError(parser as *mut _);
                 let msg = xml2_error_to_string(xerr);
-                Err(ParseFromStreamError::XmlParseError(msg))
+                Err(LoadingError::XmlParseError(msg))
             } else {
                 Ok(())
             }
@@ -503,26 +503,3 @@ fn xml2_error_to_string(xerr: xmlErrorPtr) -> String {
         }
     }
 }
-
-// Error returned when parsing an XML stream
-#[derive(Clone)]
-pub enum ParseFromStreamError {
-    // We couldn't even create the libxml2 parser
-    CouldNotCreateXmlParser,
-
-    // GIO error from the I/O callbacks
-    IoError(glib::Error),
-
-    // XML parsing error from libxml2
-    XmlParseError(String),
-}
-
-impl From<ParseFromStreamError> for LoadingError {
-    fn from(e: ParseFromStreamError) -> LoadingError {
-        match e {
-            ParseFromStreamError::CouldNotCreateXmlParser => LoadingError::CouldNotCreateXmlParser,
-            ParseFromStreamError::IoError(e) => LoadingError::Glib(e),
-            ParseFromStreamError::XmlParseError(s) => LoadingError::XmlParseError(s),
-        }
-    }
-}