Remove the concept of an element being "in error"

Fixes #737

Part-of: <https://gitlab.gnome.org/GNOME/librsvg/-/merge_requests/763>

7 files changed, 19 insertions, 91 deletions

diff --git a/src/element.rs b/src/element.rs
index eaa1eddb..bf5c1a30 100644
--- a/src/element.rs
+++ b/src/element.rs
@@ -101,7 +101,6 @@ pub struct ElementInner<T: SetAttributes + Draw> {
     attributes: Attributes,
     specified_values: SpecifiedValues,
     important_styles: HashSet<QualName>,
-    is_in_error: bool,
     values: ComputedValues,
     required_extensions: Option<RequiredExtensions>,
     required_features: Option<RequiredFeatures>,
@@ -121,7 +120,6 @@ impl<T: SetAttributes + Draw> ElementInner<T> {
             attributes,
             specified_values: Default::default(),
             important_styles: Default::default(),
-            is_in_error: false,
             values: Default::default(),
             required_extensions: Default::default(),
             required_features: Default::default(),
@@ -237,10 +235,6 @@ impl<T: SetAttributes + Draw> ElementInner<T> {
             );
         }
     }
-
-    fn is_in_error(&self) -> bool {
-        self.is_in_error
-    }
 }
 
 impl<T: SetAttributes + Draw> Draw for ElementInner<T> {
@@ -252,22 +246,11 @@ impl<T: SetAttributes + Draw> Draw for ElementInner<T> {
         draw_ctx: &mut DrawingCtx,
         clipping: bool,
     ) -> Result<BoundingBox, RenderingError> {
-        if !self.is_in_error() {
-            let values = cascaded.get();
-            if values.is_displayed() {
-                self.element_impl
-                    .draw(node, acquired_nodes, cascaded, draw_ctx, clipping)
-            } else {
-                Ok(draw_ctx.empty_bbox())
-            }
+        let values = cascaded.get();
+        if values.is_displayed() {
+            self.element_impl
+                .draw(node, acquired_nodes, cascaded, draw_ctx, clipping)
         } else {
-            rsvg_log!(
-                draw_ctx.session(),
-                "(not rendering element {} because it is in error)",
-                self
-            );
-
-            // maybe we should actually return a RenderingError::ElementIsInError here?
             Ok(draw_ctx.empty_bbox())
         }
     }
@@ -502,10 +485,6 @@ impl Element {
         call_inner!(self, set_style_attribute, session);
     }
 
-    pub fn is_in_error(&self) -> bool {
-        call_inner!(self, is_in_error)
-    }
-
     pub fn as_filter_effect(&self) -> Option<&dyn FilterEffect> {
         match self {
             Element::FeBlend(ref fe) => Some(&fe.element_impl),
diff --git a/src/filter.rs b/src/filter.rs
index d9cc96f2..259a5b18 100644
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -182,20 +182,6 @@ fn extract_filter_from_filter_node(
     let primitives = filter_node
         .children()
         .filter(|c| c.is_element())
-        // Skip nodes in error.
-        .filter(|c| {
-            let in_error = c.borrow_element().is_in_error();
-
-            if in_error {
-                rsvg_log!(
-                    session,
-                    "(ignoring filter primitive {} because it is in error)",
-                    c
-                );
-            }
-
-            !in_error
-        })
         // Keep only filter primitives (those that implement the Filter trait)
         .filter(|c| c.borrow_element().as_filter_effect().is_some())
         .map(|primitive_node| {
@@ -255,24 +241,12 @@ fn filter_spec_from_filter_node(
             let element = node.borrow_element();
 
             match *element {
-                Element::Filter(_) => {
-                    if element.is_in_error() {
-                        rsvg_log!(
-                            session,
-                            "element {} will not be filtered since its filter \"{}\" is in error",
-                            node_being_filtered_name,
-                            node_id,
-                        );
-                        Err(FilterResolveError::ChildNodeInError)
-                    } else {
-                        extract_filter_from_filter_node(
-                            node,
-                            acquired_nodes,
-                            &session,
-                            &filter_view_params,
-                        )
-                    }
-                }
+                Element::Filter(_) => extract_filter_from_filter_node(
+                    node,
+                    acquired_nodes,
+                    &session,
+                    &filter_view_params,
+                ),
 
                 _ => {
                     rsvg_log!(
diff --git a/src/filters/component_transfer.rs b/src/filters/component_transfer.rs
index cdbd1052..02efa6ca 100644
--- a/src/filters/component_transfer.rs
+++ b/src/filters/component_transfer.rs
@@ -407,15 +407,6 @@ fn get_functions(node: &Node) -> Result<Functions, FilterResolveError> {
     let func_b_node = get_func_x_node!(node, FeFuncB, Channel::B);
     let func_a_node = get_func_x_node!(node, FeFuncA, Channel::A);
 
-    for node in [&func_r_node, &func_g_node, &func_b_node, &func_a_node]
-        .iter()
-        .filter_map(|x| x.as_ref())
-    {
-        if node.borrow_element().is_in_error() {
-            return Err(FilterResolveError::ChildNodeInError);
-        }
-    }
-
     let r = func_or_default!(func_r_node, FeFuncR);
     let g = func_or_default!(func_g_node, FeFuncG);
     let b = func_or_default!(func_b_node, FeFuncB);
diff --git a/src/filters/lighting.rs b/src/filters/lighting.rs
index 20263d73..e222de22 100644
--- a/src/filters/lighting.rs
+++ b/src/filters/lighting.rs
@@ -724,10 +724,6 @@ macro_rules! impl_lighting_filter {
                 let source_node = source_node.unwrap();
                 let elt = source_node.borrow_element();
 
-                if elt.is_in_error() {
-                    return Err(FilterResolveError::ChildNodeInError);
-                }
-
                 let source = match *elt {
                     Element::FeDistantLight(ref l) => {
                         UntransformedLightSource::Distant(l.element_impl.clone())
diff --git a/src/filters/merge.rs b/src/filters/merge.rs
index 94b1603a..56292406 100644
--- a/src/filters/merge.rs
+++ b/src/filters/merge.rs
@@ -162,10 +162,6 @@ fn resolve_merge_nodes(node: &Node) -> Result<Vec<MergeNode>, FilterResolveError
     for child in node.children().filter(|c| c.is_element()) {
         let elt = child.borrow_element();
 
-        if elt.is_in_error() {
-            return Err(FilterResolveError::ChildNodeInError);
-        }
-
         let cascaded = CascadedValues::new_from_node(&child);
         let values = cascaded.get();
 
diff --git a/src/gradient.rs b/src/gradient.rs
index ac5de916..27dff133 100644
--- a/src/gradient.rs
+++ b/src/gradient.rs
@@ -418,26 +418,18 @@ impl UnresolvedGradient {
             let elt = child.borrow_element();
 
             if let Element::Stop(ref stop) = *elt {
-                if elt.is_in_error() {
-                    rsvg_log!(
-                        session,
-                        "(not using gradient stop {} because it is in error)",
-                        child
-                    );
-                } else {
-                    let cascaded = CascadedValues::new_from_node(&child);
-                    let values = cascaded.get();
+                let cascaded = CascadedValues::new_from_node(&child);
+                let values = cascaded.get();
 
-                    let UnitInterval(stop_opacity) = values.stop_opacity().0;
-                    let UnitInterval(o) = opacity;
+                let UnitInterval(stop_opacity) = values.stop_opacity().0;
+                let UnitInterval(o) = opacity;
 
-                    let composed_opacity = UnitInterval(stop_opacity * o);
+                let composed_opacity = UnitInterval(stop_opacity * o);
 
-                    let rgba =
-                        resolve_color(&values.stop_color().0, composed_opacity, values.color().0);
+                let rgba =
+                    resolve_color(&values.stop_color().0, composed_opacity, values.color().0);
 
-                    self.add_color_stop(stop.offset, rgba);
-                }
+                self.add_color_stop(stop.offset, rgba);
             }
         }
     }
diff --git a/src/structure.rs b/src/structure.rs
index 09055d57..c7a3c729 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -101,7 +101,7 @@ impl Draw for Switch {
             &mut |an, dc, _transform| {
                 if let Some(child) = node.children().filter(|c| c.is_element()).find(|c| {
                     let elt = c.borrow_element();
-                    elt.get_cond(dc.user_language()) && !elt.is_in_error()
+                    elt.get_cond(dc.user_language())
                 }) {
                     child.draw(
                         an,