GNOME.org
 

[librsvg: 5/9] Split out FilterError into a FilterResolveError


commit 4925b49c6b1dc87502b7326bb26c1411984063cc
Author: Federico Mena Quintero <federico gnome org>
Date:   Tue Apr 20 19:53:57 2021 -0500

    Split out FilterError into a FilterResolveError
    
    Let's see if we can leave resolve-time errors as the ones we can
    ignore, and leave rendering-time Cairo errors as hard errors that need
    the drawing process to be aborted.

 src/filters/blend.rs              |  7 +++++--
 src/filters/color_matrix.rs       |  7 +++++--
 src/filters/component_transfer.rs | 11 +++++++----
 src/filters/composite.rs          |  7 +++++--
 src/filters/convolve_matrix.rs    |  7 +++++--
 src/filters/displacement_map.rs   |  7 +++++--
 src/filters/error.rs              | 20 ++++++++++++++++----
 src/filters/flood.rs              |  6 ++++--
 src/filters/gaussian_blur.rs      |  7 +++++--
 src/filters/image.rs              |  6 ++++--
 src/filters/lighting.rs           |  9 +++++----
 src/filters/merge.rs              | 11 +++++++----
 src/filters/mod.rs                | 11 +++++++----
 src/filters/morphology.rs         |  7 +++++--
 src/filters/offset.rs             |  7 +++++--
 src/filters/tile.rs               |  7 +++++--
 src/filters/turbulence.rs         |  6 ++++--
 17 files changed, 99 insertions(+), 44 deletions(-)
---
diff --git a/src/filters/blend.rs b/src/filters/blend.rs
index b0fc5afb..9ad5253f 100644
--- a/src/filters/blend.rs
+++ b/src/filters/blend.rs
@@ -13,7 +13,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// Enumeration of the possible blending modes.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
@@ -108,7 +111,7 @@ impl Blend {
 }
 
 impl FilterEffect for FeBlend {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/color_matrix.rs b/src/filters/color_matrix.rs
index d466f0a4..556a0ff5 100644
--- a/src/filters/color_matrix.rs
+++ b/src/filters/color_matrix.rs
@@ -18,7 +18,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// Color matrix operation types.
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@@ -217,7 +220,7 @@ impl ColorMatrix {
 }
 
 impl FilterEffect for FeColorMatrix {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/component_transfer.rs b/src/filters/component_transfer.rs
index a10e619b..de115021 100644
--- a/src/filters/component_transfer.rs
+++ b/src/filters/component_transfer.rs
@@ -19,7 +19,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// The `feComponentTransfer` filter primitive.
 #[derive(Default)]
@@ -369,7 +372,7 @@ impl ComponentTransfer {
 }
 
 impl FilterEffect for FeComponentTransfer {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
@@ -385,7 +388,7 @@ impl FilterEffect for FeComponentTransfer {
 }
 
 /// Takes a feComponentTransfer and walks its children to produce the feFuncX arguments.
-fn get_functions(node: &Node) -> Result<Functions, FilterError> {
+fn get_functions(node: &Node) -> Result<Functions, FilterResolveError> {
     let func_r_node = get_func_x_node!(node, FeFuncR, Channel::R);
     let func_g_node = get_func_x_node!(node, FeFuncG, Channel::G);
     let func_b_node = get_func_x_node!(node, FeFuncB, Channel::B);
@@ -396,7 +399,7 @@ fn get_functions(node: &Node) -> Result<Functions, FilterError> {
         .filter_map(|x| x.as_ref())
     {
         if node.borrow_element().is_in_error() {
-            return Err(FilterError::ChildNodeInError);
+            return Err(FilterResolveError::ChildNodeInError);
         }
     }
 
diff --git a/src/filters/composite.rs b/src/filters/composite.rs
index 4a08ddca..9d6036fa 100644
--- a/src/filters/composite.rs
+++ b/src/filters/composite.rs
@@ -13,7 +13,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// Enumeration of the possible compositing operations.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
@@ -118,7 +121,7 @@ impl Composite {
 }
 
 impl FilterEffect for FeComposite {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/convolve_matrix.rs b/src/filters/convolve_matrix.rs
index c75d9b5a..b04f4f3e 100644
--- a/src/filters/convolve_matrix.rs
+++ b/src/filters/convolve_matrix.rs
@@ -22,7 +22,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// The `feConvolveMatrix` filter primitive.
 #[derive(Default)]
@@ -302,7 +305,7 @@ impl ConvolveMatrix {
 }
 
 impl FilterEffect for FeConvolveMatrix {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/displacement_map.rs b/src/filters/displacement_map.rs
index 07bc125d..eaa3bf37 100644
--- a/src/filters/displacement_map.rs
+++ b/src/filters/displacement_map.rs
@@ -14,7 +14,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// Enumeration of the color channels the displacement map can source.
 #[derive(Clone, Copy)]
@@ -152,7 +155,7 @@ impl DisplacementMap {
 }
 
 impl FilterEffect for FeDisplacementMap {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/error.rs b/src/filters/error.rs
index 3ca64bb1..9a56d8fe 100644
--- a/src/filters/error.rs
+++ b/src/filters/error.rs
@@ -18,10 +18,15 @@ pub enum FilterError {
     CairoError(cairo::Error),
     /// Error from the rendering backend.
     Rendering(RenderingError),
-    /// A lighting filter has none or multiple light sources.
-    InvalidLightSourceCount,
     /// A lighting filter input surface is too small.
     LightingInputTooSmall,
+}
+
+/// Errors that can occur while resolving a `FilterSpec`.
+#[derive(Debug)]
+pub enum FilterResolveError {
+    /// A lighting filter has none or multiple light sources.
+    InvalidLightSourceCount,
     /// Child node was in error.
     ChildNodeInError,
 }
@@ -36,12 +41,19 @@ impl fmt::Display for FilterError {
             }
             FilterError::CairoError(ref status) => write!(f, "Cairo error: {}", status),
             FilterError::Rendering(ref e) => write!(f, "Rendering error: {}", e),
-            FilterError::InvalidLightSourceCount => write!(f, "invalid light source count"),
             FilterError::LightingInputTooSmall => write!(
                 f,
                 "lighting filter input surface is too small (less than 2×2 pixels)"
             ),
-            FilterError::ChildNodeInError => write!(f, "child node was in error"),
+        }
+    }
+}
+
+impl fmt::Display for FilterResolveError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            FilterResolveError::InvalidLightSourceCount => write!(f, "invalid light source count"),
+            FilterResolveError::ChildNodeInError => write!(f, "child node was in error"),
         }
     }
 }
diff --git a/src/filters/flood.rs b/src/filters/flood.rs
index 29a3ec7e..6789384e 100644
--- a/src/filters/flood.rs
+++ b/src/filters/flood.rs
@@ -8,7 +8,9 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Primitive, PrimitiveParams, ResolvedPrimitive,
+};
 
 /// The `feFlood` filter primitive.
 #[derive(Default)]
@@ -44,7 +46,7 @@ impl Flood {
 }
 
 impl FilterEffect for FeFlood {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/gaussian_blur.rs b/src/filters/gaussian_blur.rs
index 26cd3524..576d460e 100644
--- a/src/filters/gaussian_blur.rs
+++ b/src/filters/gaussian_blur.rs
@@ -19,7 +19,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// The maximum gaussian blur kernel size.
 ///
@@ -244,7 +247,7 @@ impl GaussianBlur {
 }
 
 impl FilterEffect for FeGaussianBlur {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
 
diff --git a/src/filters/image.rs b/src/filters/image.rs
index b19ab2d6..63e04afa 100644
--- a/src/filters/image.rs
+++ b/src/filters/image.rs
@@ -15,7 +15,9 @@ use crate::xml::Attributes;
 
 use super::bounds::{Bounds, BoundsBuilder};
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Primitive, PrimitiveParams, ResolvedPrimitive,
+};
 
 /// The `feImage` filter primitive.
 #[derive(Default)]
@@ -153,7 +155,7 @@ impl Image {
 }
 
 impl FilterEffect for FeImage {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let feimage_values = cascaded.get().clone();
 
diff --git a/src/filters/lighting.rs b/src/filters/lighting.rs
index 0588b3de..7477870d 100644
--- a/src/filters/lighting.rs
+++ b/src/filters/lighting.rs
@@ -13,7 +13,8 @@ use crate::element::{Draw, Element, ElementResult, SetAttributes};
 use crate::filters::{
     bounds::BoundsBuilder,
     context::{FilterContext, FilterOutput},
-    FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive,
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
 };
 use crate::node::{CascadedValues, Node, NodeBorrow};
 use crate::paint_server::resolve_color;
@@ -649,7 +650,7 @@ macro_rules! impl_lighting_filter {
         }
 
         impl FilterEffect for $lighting_type {
-            fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+            fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
                 let mut sources = node.children().rev().filter(|c| {
                     c.is_element()
                         && matches!(
@@ -662,14 +663,14 @@ macro_rules! impl_lighting_filter {
 
                 let source_node = sources.next();
                 if source_node.is_none() || sources.next().is_some() {
-                    return Err(FilterError::InvalidLightSourceCount);
+                    return Err(FilterResolveError::InvalidLightSourceCount);
                 }
 
                 let source_node = source_node.unwrap();
                 let elt = source_node.borrow_element();
 
                 if elt.is_in_error() {
-                    return Err(FilterError::ChildNodeInError);
+                    return Err(FilterResolveError::ChildNodeInError);
                 }
 
                 let source = match *elt {
diff --git a/src/filters/merge.rs b/src/filters/merge.rs
index e01348a4..934e51d1 100644
--- a/src/filters/merge.rs
+++ b/src/filters/merge.rs
@@ -12,7 +12,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// The `feMerge` filter primitive.
 pub struct FeMerge {
@@ -139,7 +142,7 @@ impl Merge {
 }
 
 impl FilterEffect for FeMerge {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         Ok(ResolvedPrimitive {
             primitive: self.base.clone(),
             params: PrimitiveParams::Merge(Merge {
@@ -150,14 +153,14 @@ impl FilterEffect for FeMerge {
 }
 
 /// Takes a feMerge and walks its children to produce a list of feMergeNode arguments.
-fn resolve_merge_nodes(node: &Node) -> Result<Vec<MergeNode>, FilterError> {
+fn resolve_merge_nodes(node: &Node) -> Result<Vec<MergeNode>, FilterResolveError> {
     let mut merge_nodes = Vec::new();
 
     for child in node.children().filter(|c| c.is_element()) {
         let elt = child.borrow_element();
 
         if elt.is_in_error() {
-            return Err(FilterError::ChildNodeInError);
+            return Err(FilterResolveError::ChildNodeInError);
         }
 
         let cascaded = CascadedValues::new_from_node(&child);
diff --git a/src/filters/mod.rs b/src/filters/mod.rs
index 57f7c9a2..73482656 100644
--- a/src/filters/mod.rs
+++ b/src/filters/mod.rs
@@ -29,11 +29,11 @@ pub mod context;
 use self::context::{FilterContext, FilterOutput, FilterResult};
 
 mod error;
-use self::error::FilterError;
+use self::error::{FilterError, FilterResolveError};
 
 /// A filter primitive interface.
 pub trait FilterEffect: SetAttributes + Draw {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError>;
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError>;
 }
 
 // Filter Effects do not need to draw themselves
@@ -248,7 +248,7 @@ impl Primitive {
 pub fn extract_filter_from_filter_node(
     filter_node: &Node,
     draw_ctx: &DrawingCtx,
-) -> Result<FilterSpec, FilterError> {
+) -> Result<FilterSpec, FilterResolveError> {
     let filter_node = &*filter_node;
     assert!(is_element_of_type!(filter_node, Filter));
 
@@ -306,7 +306,7 @@ pub fn extract_filter_from_filter_node(
                     )
                 })
         })
-        .collect::<Result<Vec<UserSpacePrimitive>, FilterError>>()?;
+        .collect::<Result<Vec<UserSpacePrimitive>, FilterResolveError>>()?;
 
     Ok(FilterSpec {
         user_space_filter,
@@ -326,6 +326,9 @@ pub fn render(
     node_bbox: BoundingBox,
 ) -> Result<SharedImageSurface, RenderingError> {
     extract_filter_from_filter_node(filter_node, draw_ctx)
+        .map_err(|e| {
+            FilterError::InvalidParameter(format!("error when creating filter spec: {}", e))
+        })
         .and_then(|filter| {
             let filter_ctx = FilterContext::new(
                 &filter.user_space_filter,
diff --git a/src/filters/morphology.rs b/src/filters/morphology.rs
index d6f8ccb6..f1cd515b 100644
--- a/src/filters/morphology.rs
+++ b/src/filters/morphology.rs
@@ -20,7 +20,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// Enumeration of the possible morphology operations.
 #[derive(Clone)]
@@ -158,7 +161,7 @@ impl Morphology {
 }
 
 impl FilterEffect for FeMorphology {
-    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         Ok(ResolvedPrimitive {
             primitive: self.base.clone(),
             params: PrimitiveParams::Morphology(self.params.clone()),
diff --git a/src/filters/offset.rs b/src/filters/offset.rs
index 662fea92..1c968e58 100644
--- a/src/filters/offset.rs
+++ b/src/filters/offset.rs
@@ -11,7 +11,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// The `feOffset` filter primitive.
 #[derive(Default)]
@@ -80,7 +83,7 @@ impl Offset {
 }
 
 impl FilterEffect for FeOffset {
-    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         Ok(ResolvedPrimitive {
             primitive: self.base.clone(),
             params: PrimitiveParams::Offset(self.params.clone()),
diff --git a/src/filters/tile.rs b/src/filters/tile.rs
index 108f7816..cd7f3408 100644
--- a/src/filters/tile.rs
+++ b/src/filters/tile.rs
@@ -8,7 +8,10 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterInput, FilterOutput};
-use super::{FilterEffect, FilterError, Input, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Input, Primitive, PrimitiveParams,
+    ResolvedPrimitive,
+};
 
 /// The `feTile` filter primitive.
 #[derive(Default)]
@@ -77,7 +80,7 @@ impl Tile {
 }
 
 impl FilterEffect for FeTile {
-    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, _node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         Ok(ResolvedPrimitive {
             primitive: self.base.clone(),
             params: PrimitiveParams::Tile(self.params.clone()),
diff --git a/src/filters/turbulence.rs b/src/filters/turbulence.rs
index 8cb3b3ad..913324f6 100644
--- a/src/filters/turbulence.rs
+++ b/src/filters/turbulence.rs
@@ -18,7 +18,9 @@ use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
 use super::context::{FilterContext, FilterOutput};
-use super::{FilterEffect, FilterError, Primitive, PrimitiveParams, ResolvedPrimitive};
+use super::{
+    FilterEffect, FilterError, FilterResolveError, Primitive, PrimitiveParams, ResolvedPrimitive,
+};
 
 /// Enumeration of the tile stitching modes.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
@@ -415,7 +417,7 @@ impl Turbulence {
 }
 
 impl FilterEffect for FeTurbulence {
-    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterError> {
+    fn resolve(&self, node: &Node) -> Result<ResolvedPrimitive, FilterResolveError> {
         let cascaded = CascadedValues::new_from_node(node);
         let values = cascaded.get();
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]