Combine ViewParams and Viewport into a single struct Viewport

ViewParams was the original set of values that we used since 2018 for
length normalization.

Viewport was my attempt to start unifying the "viewport" concept,
around 2020 and #298.

My current plan is to remove the current viewport from the mutable
part of DrawingCtx, and instead pass the current viewport as function
arguments to the draw() functions.

This commit basically moves the fields and methods from ViewParams
into Viewport, and makes everything use Viewport instead of
ViewParams.  Things are a bit funky because of the viewport_stack
field, which is shared via an Option<Weak<>> to the viewport stack in
the DrawingCtx - but that will disappear when the current viewport is
passed as arguments instead of mutable state.

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

12 files changed, 170 insertions, 156 deletions

diff --git a/src/drawing_ctx.rs b/src/drawing_ctx.rs
index 46c98d5b..0597bea3 100644
--- a/src/drawing_ctx.rs
+++ b/src/drawing_ctx.rs
@@ -47,58 +47,6 @@ use crate::transform::{Transform, ValidTransform};
 use crate::unit_interval::UnitInterval;
 use crate::viewbox::ViewBox;
 
-/// Holds values that are required to normalize `CssLength` values to a current viewport.
-///
-/// This struct is created by calling `DrawingCtx::push_view_box()` or
-/// `DrawingCtx::get_view_params()`.
-///
-/// This struct holds the size of the current viewport in the user's coordinate system.  A
-/// viewport pushed with `DrawingCtx::push_view_box()` will remain in place until the
-/// returned `ViewParams` is dropped; at that point, the `DrawingCtx` will resume using its
-/// previous viewport.
-pub struct ViewParams {
-    pub dpi: Dpi,
-    pub vbox: ViewBox,
-    viewport_stack: Option<Weak<RefCell<Vec<Viewport>>>>,
-}
-
-impl ViewParams {
-    pub fn new(dpi: Dpi, view_box_width: f64, view_box_height: f64) -> ViewParams {
-        ViewParams {
-            dpi,
-            vbox: ViewBox::from(Rect::from_size(view_box_width, view_box_height)),
-            viewport_stack: None,
-        }
-    }
-
-    pub fn with_units(&self, units: CoordUnits) -> ViewParams {
-        match units {
-            CoordUnits::ObjectBoundingBox => ViewParams {
-                dpi: self.dpi,
-                vbox: ViewBox::from(Rect::from_size(1.0, 1.0)),
-                viewport_stack: None,
-            },
-
-            CoordUnits::UserSpaceOnUse => ViewParams {
-                dpi: self.dpi,
-                vbox: self.vbox,
-                viewport_stack: None,
-            },
-        }
-    }
-}
-
-impl Drop for ViewParams {
-    fn drop(&mut self) {
-        if let Some(ref weak_stack) = self.viewport_stack {
-            let stack = weak_stack
-                .upgrade()
-                .expect("A ViewParams was dropped after its DrawingCtx!?");
-            stack.borrow_mut().pop();
-        }
-    }
-}
-
 /// Opaque font options for a DrawingCtx.
 ///
 /// This is used for DrawingCtx::create_pango_context.
@@ -161,13 +109,60 @@ impl<'a> PathHelper<'a> {
     }
 }
 
-#[derive(Copy, Clone)]
-struct Viewport {
+/// Holds the size of the current viewport in the user's coordinate system.
+#[derive(Clone)]
+pub struct Viewport {
+    pub dpi: Dpi,
+
+    /// Corners of the current coordinate space.
+    pub vbox: ViewBox,
+
     /// The viewport's coordinate system, or "user coordinate system" in SVG terms.
     transform: Transform,
 
-    /// Corners of the current coordinate space.
-    vbox: ViewBox,
+    viewport_stack: Option<Weak<RefCell<Vec<Viewport>>>>,
+}
+
+impl Drop for Viewport {
+    fn drop(&mut self) {
+        if let Some(ref weak_stack) = self.viewport_stack {
+            let stack = weak_stack
+                .upgrade()
+                .expect("A Viewport was dropped after its DrawingCtx!?");
+            stack.borrow_mut().pop();
+        }
+    }
+}
+
+impl Viewport {
+    /// FIXME: this is just used in Handle::with_height_to_user(), and in length.rs's test suite.
+    /// Find a way to do this without involving a default identity transform.
+    pub fn new(dpi: Dpi, view_box_width: f64, view_box_height: f64) -> Viewport {
+        Viewport {
+            dpi,
+            vbox: ViewBox::from(Rect::from_size(view_box_width, view_box_height)),
+            transform: Default::default(),
+            viewport_stack: None,
+        }
+    }
+
+    pub fn with_units(&self, units: CoordUnits) -> Viewport {
+        match units {
+            CoordUnits::ObjectBoundingBox => Viewport {
+                dpi: self.dpi,
+                vbox: ViewBox::from(Rect::from_size(1.0, 1.0)),
+                transform: self.transform,
+                viewport_stack: None,
+            },
+
+            CoordUnits::UserSpaceOnUse => Viewport {
+                dpi: self.dpi,
+                vbox: self.vbox,
+                transform: self.transform,
+                viewport_stack: None,
+            },
+        }
+    }
 }
 
 pub struct DrawingCtx {
@@ -303,9 +298,14 @@ impl DrawingCtx {
         drawsub_stack: Vec<Node>,
     ) -> DrawingCtx {
         let vbox = ViewBox::from(viewport);
-        let initial_viewport = Viewport { transform, vbox };
+        let initial_viewport = Viewport {
+            dpi,
+            vbox,
+            transform,
+            viewport_stack: None,
+        };
 
-        let viewport_stack = vec![initial_viewport];
+        let viewport_stack = vec![initial_viewport.clone()];
 
         DrawingCtx {
             session,
@@ -334,7 +334,7 @@ impl DrawingCtx {
 
         DrawingCtx {
             session: self.session.clone(),
-            initial_viewport: self.initial_viewport,
+            initial_viewport: self.initial_viewport.clone(),
             dpi: self.dpi,
             cr_stack,
             cr,
@@ -434,29 +434,37 @@ impl DrawingCtx {
 
     fn get_top_viewport(&self) -> Viewport {
         let viewport_stack = self.viewport_stack.borrow();
-        *viewport_stack
+        let viewport = viewport_stack
             .last()
-            .expect("viewport_stack must never be empty!")
+            .expect("viewport_stack must never be empty!");
+        Viewport {
+            viewport_stack: None,
+            ..*viewport
+        }
     }
 
     // Same as `push_coord_units` but doesn't leave the coordinate space pushed
-    pub fn get_view_params_for_units(&self, units: CoordUnits) -> ViewParams {
+    pub fn get_viewport_for_units(&self, units: CoordUnits) -> Viewport {
+        let transform = self.get_top_viewport().transform;
+
         match units {
-            CoordUnits::ObjectBoundingBox => ViewParams {
+            CoordUnits::ObjectBoundingBox => Viewport {
                 dpi: self.dpi,
                 vbox: ViewBox::from(Rect::from_size(1.0, 1.0)),
+                transform,
                 viewport_stack: None,
             },
 
-            CoordUnits::UserSpaceOnUse => ViewParams {
+            CoordUnits::UserSpaceOnUse => Viewport {
                 dpi: self.dpi,
                 vbox: self.get_top_viewport().vbox,
+                transform,
                 viewport_stack: None,
             },
         }
     }
 
-    pub fn push_coord_units(&self, units: CoordUnits) -> ViewParams {
+    pub fn push_coord_units(&self, units: CoordUnits) -> Viewport {
         match units {
             CoordUnits::ObjectBoundingBox => self.push_view_box(1.0, 1.0),
 
@@ -468,63 +476,65 @@ impl DrawingCtx {
         }
     }
 
-    /// Gets the viewport that was last pushed with `push_view_box()`.
-    pub fn get_view_params(&self) -> ViewParams {
-        let viewport = self.get_top_viewport();
-
-        ViewParams {
-            dpi: self.dpi,
-            vbox: viewport.vbox,
-            viewport_stack: None,
-        }
+    /// Gets the viewport that was last pushed.
+    pub fn get_viewport(&self) -> Viewport {
+        self.get_top_viewport()
     }
 
-    fn push_viewport(&self, viewport: Viewport) -> ViewParams {
+    fn push_viewport(&self, viewport: Viewport) -> Viewport {
         let vbox = viewport.vbox;
+        let transform = viewport.transform;
 
         self.viewport_stack.borrow_mut().push(viewport);
 
-        ViewParams {
+        Viewport {
             dpi: self.dpi,
             vbox,
+            transform,
             viewport_stack: Some(Rc::downgrade(&self.viewport_stack)),
         }
     }
 
     /// Pushes a viewport size for normalizing `Length` values.
     ///
-    /// With the returned `ViewParams`, plus a `ComputedValues`, you can create a
+    /// With the returned `Viewport`, plus a `ComputedValues`, you can create a
     /// `NormalizeParams` that can be used with calls to `CssLength.to_user()` that
     /// correspond to this viewport.
     ///
     /// The viewport will stay in place, and will be the one returned by
-    /// `get_view_params()`, until the returned `ViewParams` is dropped.
-    pub fn push_view_box(&self, width: f64, height: f64) -> ViewParams {
-        let Viewport { transform, .. } = self.get_top_viewport();
+    /// [`DrawingCtx::get_viewport()`], until the returned `Viewport` is dropped.
+    pub fn push_view_box(&self, width: f64, height: f64) -> Viewport {
+        let top_viewport = self.get_top_viewport();
 
         let vbox = ViewBox::from(Rect::from_size(width, height));
-        self.push_viewport(Viewport { transform, vbox })
+        let viewport = Viewport {
+            dpi: top_viewport.dpi,
+            vbox,
+            transform: top_viewport.transform,
+            viewport_stack: None,
+        };
+        self.push_viewport(viewport)
     }
 
     /// Creates a new coordinate space inside a viewport and sets a clipping rectangle.
     ///
     /// Note that this actually changes the `draw_ctx.cr`'s transformation to match
     /// the new coordinate space, but the old one is not restored after the
-    /// result's `ViewParams` is dropped.  Thus, this function must be called
+    /// result's `Viewport` is dropped.  Thus, this function must be called
     /// inside `with_saved_cr` or `draw_ctx.with_discrete_layer`.
     pub fn push_new_viewport(
         &self,
         vbox: Option<ViewBox>,
-        viewport: Rect,
+        viewport_rect: Rect,
         preserve_aspect_ratio: AspectRatio,
         clip_mode: ClipMode,
-    ) -> Option<ViewParams> {
+    ) -> Option<Viewport> {
         if let ClipMode::ClipToViewport = clip_mode {
-            clip_to_rectangle(&self.cr, &viewport);
+            clip_to_rectangle(&self.cr, &viewport_rect);
         }
 
         preserve_aspect_ratio
-            .viewport_to_viewbox_transform(vbox, &viewport)
+            .viewport_to_viewbox_transform(vbox, &viewport_rect)
             .unwrap_or_else(|_e| {
                 match vbox {
                     None => unreachable!(
@@ -549,8 +559,10 @@ impl DrawingCtx {
                 let top_viewport = self.get_top_viewport();
 
                 self.push_viewport(Viewport {
-                    transform: top_viewport.transform.post_transform(&t),
+                    dpi: self.dpi,
                     vbox: vbox.unwrap_or(top_viewport.vbox),
+                    transform: top_viewport.transform.post_transform(&t),
+                    viewport_stack: None,
                 })
             })
     }
@@ -631,7 +643,7 @@ impl DrawingCtx {
         let mask_units = mask.get_units();
 
         let mask_rect = {
-            let params = NormalizeParams::new(values, &self.get_view_params_for_units(mask_units));
+            let params = NormalizeParams::new(values, &self.get_viewport_for_units(mask_units));
             mask.get_rect(&params)
         };
 
@@ -674,7 +686,7 @@ impl DrawingCtx {
 
             // TODO: this is the last place where push_coord_units() is called.  The call to
             // draw_children below assumes that the new coordinate system is in place.  Can we
-            // pass the ViewParams to with_discrete_layer / Node::draw instead of having them
+            // pass the Viewport to with_discrete_layer / Node::draw instead of having them
             // assume the viewport from the DrawingCtx?
             let _params = self.push_coord_units(mask.get_content_units());
 
@@ -794,7 +806,7 @@ impl DrawingCtx {
                                     .unwrap(),
                             )?;
 
-                            let params = temporary_draw_ctx.get_view_params();
+                            let params = temporary_draw_ctx.get_viewport();
 
                             let stroke_paint_source =
                                 Rc::new(filter.stroke_paint_source.to_user_space(
@@ -1617,7 +1629,7 @@ impl DrawingCtx {
     ) -> Result<SharedImageSurface, RenderingError> {
         let surface = cairo::ImageSurface::create(cairo::Format::ARgb32, width, height)?;
 
-        let save_initial_viewport = self.initial_viewport;
+        let save_initial_viewport = self.initial_viewport.clone();
         let save_cr = self.cr.clone();
 
         {
@@ -1626,8 +1638,10 @@ impl DrawingCtx {
 
             self.cr = cr;
             self.initial_viewport = Viewport {
+                dpi: self.dpi,
                 transform: affine,
                 vbox: ViewBox::from(Rect::from_size(f64::from(width), f64::from(height))),
+                viewport_stack: None,
             };
 
             let _ = self.draw_node_from_stack(node, acquired_nodes, cascaded, false)?;
diff --git a/src/filter.rs b/src/filter.rs
index 05aad8ac..ba2ebb14 100644
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -6,7 +6,7 @@ use std::slice::Iter;
 
 use crate::coord_units::CoordUnits;
 use crate::document::{AcquiredNodes, NodeId};
-use crate::drawing_ctx::{DrawingCtx, ViewParams};
+use crate::drawing_ctx::{DrawingCtx, Viewport};
 use crate::element::{set_attribute, ElementData, ElementTrait};
 use crate::error::ValueErrorKind;
 use crate::filter_func::FilterFunction;
@@ -131,22 +131,22 @@ impl FilterValue {
 /// pre-compute both cases and pass them around.
 ///
 /// This struct needs a better name; I didn't want to make it seem specific to filters by
-/// calling `FiltersViewParams` or `FilterCollectionProcessViewParams`.  Maybe the
-/// original [`ViewParams`] should be this struct, with both cases included...
-pub struct ViewParamsGen {
-    object_bounding_box: ViewParams,
-    user_space_on_use: ViewParams,
+/// calling `FiltersViewport` or `FilterCollectionProcessViewport`.  Maybe the
+/// original [`Viewport`] should be this struct, with both cases included...
+struct ViewportGen {
+    object_bounding_box: Viewport,
+    user_space_on_use: Viewport,
 }
 
-impl ViewParamsGen {
+impl ViewportGen {
     pub fn new(draw_ctx: &DrawingCtx) -> Self {
-        ViewParamsGen {
-            object_bounding_box: draw_ctx.get_view_params_for_units(CoordUnits::ObjectBoundingBox),
-            user_space_on_use: draw_ctx.get_view_params_for_units(CoordUnits::UserSpaceOnUse),
+        ViewportGen {
+            object_bounding_box: draw_ctx.get_viewport_for_units(CoordUnits::ObjectBoundingBox),
+            user_space_on_use: draw_ctx.get_viewport_for_units(CoordUnits::UserSpaceOnUse),
         }
     }
 
-    fn get(&self, units: CoordUnits) -> &ViewParams {
+    fn get(&self, units: CoordUnits) -> &Viewport {
         match units {
             CoordUnits::ObjectBoundingBox => &self.object_bounding_box,
             CoordUnits::UserSpaceOnUse => &self.user_space_on_use,
@@ -158,7 +158,7 @@ fn extract_filter_from_filter_node(
     filter_node: &Node,
     acquired_nodes: &mut AcquiredNodes<'_>,
     session: &Session,
-    filter_view_params: &ViewParamsGen,
+    filter_view_params: &ViewportGen,
 ) -> Result<FilterSpec, FilterResolveError> {
     assert!(is_element_of_type!(filter_node, Filter));
 
@@ -226,7 +226,7 @@ fn filter_spec_from_filter_node(
 ) -> Result<FilterSpec, FilterResolveError> {
     let session = draw_ctx.session().clone();
 
-    let filter_view_params = ViewParamsGen::new(draw_ctx);
+    let filter_view_params = ViewportGen::new(draw_ctx);
 
     acquired_nodes
         .acquire(node_id)
diff --git a/src/gradient.rs b/src/gradient.rs
index 04420400..311343cb 100644
--- a/src/gradient.rs
+++ b/src/gradient.rs
@@ -7,7 +7,7 @@ use markup5ever::{
 
 use crate::coord_units::CoordUnits;
 use crate::document::{AcquiredNodes, NodeId, NodeStack};
-use crate::drawing_ctx::ViewParams;
+use crate::drawing_ctx::Viewport;
 use crate::element::{set_attribute, ElementData, ElementTrait};
 use crate::error::*;
 use crate::href::{is_href, set_href};
@@ -654,12 +654,12 @@ impl ResolvedGradient {
     pub fn to_user_space(
         &self,
         object_bbox: &Option<Rect>,
-        current_params: &ViewParams,
+        viewport: &Viewport,
         values: &NormalizeValues,
     ) -> Option<UserSpaceGradient> {
         let units = self.units.0;
         let transform = rect_to_transform(object_bbox, units).ok()?;
-        let view_params = current_params.with_units(units);
+        let view_params = viewport.with_units(units);
         let params = NormalizeParams::from_values(values, &view_params);
 
         let gradient_transform = self.transform.to_transform();
diff --git a/src/handle.rs b/src/handle.rs
index 36de859d..86428008 100644
--- a/src/handle.rs
+++ b/src/handle.rs
@@ -9,7 +9,7 @@ use crate::bbox::BoundingBox;
 use crate::css::{Origin, Stylesheet};
 use crate::document::{AcquiredNodes, Document, NodeId};
 use crate::dpi::Dpi;
-use crate::drawing_ctx::{draw_tree, with_saved_cr, DrawingMode, ViewParams};
+use crate::drawing_ctx::{draw_tree, with_saved_cr, DrawingMode, Viewport};
 use crate::error::{DefsLookupErrorKind, LoadingError, RenderingError};
 use crate::length::*;
 use crate::node::{CascadedValues, Node, NodeBorrow};
@@ -124,7 +124,7 @@ impl Handle {
         let width = dimensions.width;
         let height = dimensions.height;
 
-        let view_params = ViewParams::new(dpi, 0.0, 0.0);
+        let view_params = Viewport::new(dpi, 0.0, 0.0);
         let root = self.document.root();
         let cascaded = CascadedValues::new_from_node(&root);
         let values = cascaded.get();
diff --git a/src/image.rs b/src/image.rs
index 282bb3e4..1d85c98f 100644
--- a/src/image.rs
+++ b/src/image.rs
@@ -71,8 +71,8 @@ impl ElementTrait for Image {
 
         let values = cascaded.get();
 
-        let view_params = draw_ctx.get_view_params();
-        let params = NormalizeParams::new(values, &view_params);
+        let viewport = draw_ctx.get_viewport();
+        let params = NormalizeParams::new(values, &viewport);
 
         let x = values.x().0.to_user(&params);
         let y = values.y().0.to_user(&params);
diff --git a/src/length.rs b/src/length.rs
index 5d91b166..56156d41 100644
--- a/src/length.rs
+++ b/src/length.rs
@@ -48,7 +48,7 @@ use std::fmt;
 use std::marker::PhantomData;
 
 use crate::dpi::Dpi;
-use crate::drawing_ctx::ViewParams;
+use crate::drawing_ctx::Viewport;
 use crate::error::*;
 use crate::parsers::{finite_f32, Parse};
 use crate::properties::{ComputedValues, FontSize};
@@ -327,17 +327,17 @@ pub struct NormalizeParams {
 
 impl NormalizeParams {
     /// Extracts the information needed to normalize [`Length`] values from a set of
-    /// [`ComputedValues`] and the viewport size in [`ViewParams`].
-    pub fn new(values: &ComputedValues, params: &ViewParams) -> NormalizeParams {
+    /// [`ComputedValues`] and the viewport size in [`Viewport`].
+    pub fn new(values: &ComputedValues, viewport: &Viewport) -> NormalizeParams {
         let v = NormalizeValues::new(values);
-        NormalizeParams::from_values(&v, params)
+        NormalizeParams::from_values(&v, viewport)
     }
 
-    pub fn from_values(v: &NormalizeValues, params: &ViewParams) -> NormalizeParams {
+    pub fn from_values(v: &NormalizeValues, viewport: &Viewport) -> NormalizeParams {
         NormalizeParams {
-            vbox: params.vbox,
-            font_size: font_size_from_values(v, params.dpi),
-            dpi: params.dpi,
+            vbox: viewport.vbox,
+            font_size: font_size_from_values(v, viewport.dpi),
+            dpi: viewport.dpi,
         }
     }
 
@@ -641,7 +641,7 @@ mod tests {
 
     #[test]
     fn normalize_default_works() {
-        let view_params = ViewParams::new(Dpi::new(40.0, 40.0), 100.0, 100.0);
+        let view_params = Viewport::new(Dpi::new(40.0, 40.0), 100.0, 100.0);
         let values = ComputedValues::default();
         let params = NormalizeParams::new(&values, &view_params);
 
@@ -653,7 +653,7 @@ mod tests {
 
     #[test]
     fn normalize_absolute_units_works() {
-        let view_params = ViewParams::new(Dpi::new(40.0, 50.0), 100.0, 100.0);
+        let view_params = Viewport::new(Dpi::new(40.0, 50.0), 100.0, 100.0);
         let values = ComputedValues::default();
         let params = NormalizeParams::new(&values, &view_params);
 
@@ -686,7 +686,7 @@ mod tests {
 
     #[test]
     fn normalize_percent_works() {
-        let view_params = ViewParams::new(Dpi::new(40.0, 40.0), 100.0, 200.0);
+        let view_params = Viewport::new(Dpi::new(40.0, 40.0), 100.0, 200.0);
         let values = ComputedValues::default();
         let params = NormalizeParams::new(&values, &view_params);
 
@@ -702,7 +702,7 @@ mod tests {
 
     #[test]
     fn normalize_font_em_ex_works() {
-        let view_params = ViewParams::new(Dpi::new(40.0, 40.0), 100.0, 200.0);
+        let view_params = Viewport::new(Dpi::new(40.0, 40.0), 100.0, 200.0);
         let values = ComputedValues::default();
         let params = NormalizeParams::new(&values, &view_params);
 
diff --git a/src/marker.rs b/src/marker.rs
index 63b5843f..73b5a6aa 100644
--- a/src/marker.rs
+++ b/src/marker.rs
@@ -121,8 +121,8 @@ impl Marker {
 
         let values = cascaded.get();
 
-        let view_params = draw_ctx.get_view_params();
-        let params = NormalizeParams::new(values, &view_params);
+        let viewport = draw_ctx.get_viewport();
+        let params = NormalizeParams::new(values, &viewport);
 
         let marker_width = self.width.to_user(&params);
         let marker_height = self.height.to_user(&params);
@@ -151,7 +151,7 @@ impl Marker {
             transform = transform.pre_scale(line_width, line_width);
         }
 
-        let content_view_params = if let Some(vbox) = self.vbox {
+        let content_viewport = if let Some(vbox) = self.vbox {
             if vbox.is_empty() {
                 return Ok(draw_ctx.empty_bbox());
             }
@@ -168,7 +168,7 @@ impl Marker {
             draw_ctx.push_view_box(marker_width, marker_height)
         };
 
-        let content_params = NormalizeParams::new(values, &content_view_params);
+        let content_params = NormalizeParams::new(values, &content_viewport);
 
         transform = transform.pre_translate(
             -self.ref_x.to_user(&content_params),
diff --git a/src/paint_server.rs b/src/paint_server.rs
index aa4a1768..01393b8d 100644
--- a/src/paint_server.rs
+++ b/src/paint_server.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 use cssparser::Parser;
 
 use crate::document::{AcquiredNodes, NodeId};
-use crate::drawing_ctx::ViewParams;
+use crate::drawing_ctx::Viewport;
 use crate::element::ElementData;
 use crate::error::{AcquireError, NodeIdError, ParseError, ValueErrorKind};
 use crate::gradient::{ResolvedGradient, UserSpaceGradient};
@@ -243,7 +243,7 @@ impl PaintSource {
     pub fn to_user_space(
         &self,
         object_bbox: &Option<Rect>,
-        current_params: &ViewParams,
+        viewport: &Viewport,
         values: &NormalizeValues,
     ) -> UserSpacePaintSource {
         match *self {
@@ -251,7 +251,7 @@ impl PaintSource {
             PaintSource::SolidColor(c) => UserSpacePaintSource::SolidColor(c),
 
             PaintSource::Gradient(ref g, c) => {
-                match (g.to_user_space(object_bbox, current_params, values), c) {
+                match (g.to_user_space(object_bbox, viewport, values), c) {
                     (Some(gradient), c) => UserSpacePaintSource::Gradient(gradient, c),
                     (None, Some(c)) => UserSpacePaintSource::SolidColor(c),
                     (None, None) => UserSpacePaintSource::None,
@@ -259,7 +259,7 @@ impl PaintSource {
             }
 
             PaintSource::Pattern(ref p, c) => {
-                match (p.to_user_space(object_bbox, current_params, values), c) {
+                match (p.to_user_space(object_bbox, viewport, values), c) {
                     (Some(pattern), c) => UserSpacePaintSource::Pattern(pattern, c),
                     (None, Some(c)) => UserSpacePaintSource::SolidColor(c),
                     (None, None) => UserSpacePaintSource::None,
diff --git a/src/pattern.rs b/src/pattern.rs
index 922df110..8a10317f 100644
--- a/src/pattern.rs
+++ b/src/pattern.rs
@@ -5,7 +5,7 @@ use markup5ever::{expanded_name, local_name, namespace_url, ns};
 use crate::aspect_ratio::*;
 use crate::coord_units::CoordUnits;
 use crate::document::{AcquiredNode, AcquiredNodes, NodeId, NodeStack};
-use crate::drawing_ctx::ViewParams;
+use crate::drawing_ctx::Viewport;
 use crate::element::{set_attribute, ElementData, ElementTrait};
 use crate::error::*;
 use crate::href::{is_href, set_href};
@@ -353,12 +353,12 @@ impl ResolvedPattern {
     pub fn to_user_space(
         &self,
         object_bbox: &Option<Rect>,
-        current_params: &ViewParams,
+        viewport: &Viewport,
         values: &NormalizeValues,
     ) -> Option<UserSpacePattern> {
         let node_with_children = self.node_with_children()?;
 
-        let view_params = current_params.with_units(self.units.0);
+        let view_params = viewport.with_units(self.units.0);
         let params = NormalizeParams::from_values(values, &view_params);
 
         let rect = self.get_rect(&params);
diff --git a/src/shapes.rs b/src/shapes.rs
index ef01ed4d..a06d277b 100644
--- a/src/shapes.rs
+++ b/src/shapes.rs
@@ -51,8 +51,8 @@ fn draw_basic_shape(
     clipping: bool,
 ) -> Result<BoundingBox, RenderingError> {
     let values = cascaded.get();
-    let view_params = draw_ctx.get_view_params();
-    let params = NormalizeParams::new(values, &view_params);
+    let viewport = draw_ctx.get_viewport();
+    let params = NormalizeParams::new(values, &viewport);
     let shape_def = basic_shape.make_shape(&params, values);
 
     let is_visible = values.is_visible();
@@ -120,8 +120,8 @@ fn draw_basic_shape(
 
     let normalize_values = NormalizeValues::new(values);
 
-    let stroke_paint = stroke_paint.to_user_space(&extents, &view_params, &normalize_values);
-    let fill_paint = fill_paint.to_user_space(&extents, &view_params, &normalize_values);
+    let stroke_paint = stroke_paint.to_user_space(&extents, &viewport, &normalize_values);
+    let fill_paint = fill_paint.to_user_space(&extents, &viewport, &normalize_values);
 
     let shape = Box::new(Shape {
         path: shape_def.path,
diff --git a/src/structure.rs b/src/structure.rs
index 8700bcb4..ad06253b 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -6,7 +6,7 @@ use crate::aspect_ratio::*;
 use crate::bbox::BoundingBox;
 use crate::coord_units::CoordUnits;
 use crate::document::{AcquiredNodes, NodeId};
-use crate::drawing_ctx::{ClipMode, DrawingCtx, ViewParams};
+use crate::drawing_ctx::{ClipMode, DrawingCtx, Viewport};
 use crate::element::{set_attribute, ElementData, ElementTrait};
 use crate::error::*;
 use crate::href::{is_href, set_href};
@@ -219,11 +219,11 @@ impl Svg {
         node: &Node,
         cascaded: &CascadedValues<'_>,
         draw_ctx: &mut DrawingCtx,
-    ) -> Option<ViewParams> {
+    ) -> Option<Viewport> {
         let values = cascaded.get();
 
-        let view_params = draw_ctx.get_view_params();
-        let params = NormalizeParams::new(values, &view_params);
+        let current_viewport = draw_ctx.get_viewport();
+        let params = NormalizeParams::new(values, &current_viewport);
 
         let has_parent = node.parent().is_some();
 
@@ -381,8 +381,8 @@ impl ElementTrait for Use {
     ) -> Result<BoundingBox, RenderingError> {
         if let Some(link) = self.link.as_ref() {
             let values = cascaded.get();
-            let view_params = draw_ctx.get_view_params();
-            let params = NormalizeParams::new(values, &view_params);
+            let viewport = draw_ctx.get_viewport();
+            let params = NormalizeParams::new(values, &viewport);
             let rect = self.get_rect(&params);
 
             let stroke_paint = values.stroke().0.resolve(
diff --git a/src/text.rs b/src/text.rs
index a47c2de4..203bb490 100644
--- a/src/text.rs
+++ b/src/text.rs
@@ -9,7 +9,7 @@ use std::sync::Arc;
 
 use crate::bbox::BoundingBox;
 use crate::document::{AcquiredNodes, NodeId};
-use crate::drawing_ctx::{create_pango_context, DrawingCtx, FontOptions, ViewParams};
+use crate::drawing_ctx::{create_pango_context, DrawingCtx, FontOptions, Viewport};
 use crate::element::{set_attribute, ElementData, ElementTrait};
 use crate::error::*;
 use crate::layout::{self, FontProperties, Layer, LayerKind, StackingContext, Stroke, TextSpan};
@@ -39,7 +39,7 @@ struct LayoutContext {
     font_options: FontOptions,
 
     /// For normalizing lengths.
-    view_params: ViewParams,
+    viewport: Viewport,
 
     /// Session metadata for the document
     session: Session,
@@ -193,7 +193,7 @@ impl PositionedChunk {
         let mut chunk_bounds: Option<Rect> = None;
 
         for mspan in &measured.spans {
-            let params = NormalizeParams::new(&mspan.values, &layout_context.view_params);
+            let params = NormalizeParams::new(&mspan.values, &layout_context.viewport);
 
             let layout = mspan.layout.clone();
             let layout_size = mspan.layout_size;
@@ -359,7 +359,7 @@ impl MeasuredSpan {
     fn from_span(layout_context: &LayoutContext, span: &Span) -> Option<MeasuredSpan> {
         let values = span.values.clone();
 
-        let params = NormalizeParams::new(&values, &layout_context.view_params);
+        let params = NormalizeParams::new(&values, &layout_context.viewport);
 
         let properties = FontProperties::new(&values, &params);
 
@@ -454,7 +454,7 @@ impl PositionedSpan {
         layout_context: &LayoutContext,
         acquired_nodes: &mut AcquiredNodes<'_>,
     ) -> LayoutSpan {
-        let params = NormalizeParams::new(&self.values, &layout_context.view_params);
+        let params = NormalizeParams::new(&self.values, &layout_context.viewport);
 
         let layout = self.layout.clone();
         let is_visible = self.values.is_visible();
@@ -726,7 +726,7 @@ impl Text {
         let mut chunks = Vec::new();
 
         let values = cascaded.get();
-        let params = NormalizeParams::new(values, &layout_context.view_params);
+        let params = NormalizeParams::new(values, &layout_context.viewport);
 
         chunks.push(Chunk::new(values, Some(x), Some(y)));
 
@@ -770,8 +770,8 @@ impl ElementTrait for Text {
         clipping: bool,
     ) -> Result<BoundingBox, RenderingError> {
         let values = cascaded.get();
-        let view_params = draw_ctx.get_view_params();
-        let params = NormalizeParams::new(values, &view_params);
+        let viewport = draw_ctx.get_viewport();
+        let params = NormalizeParams::new(values, &viewport);
 
         let elt = node.borrow_element();
 
@@ -790,7 +790,7 @@ impl ElementTrait for Text {
                 writing_mode: values.writing_mode(),
                 transform,
                 font_options: draw_ctx.get_font_options(),
-                view_params,
+                viewport,
                 session: draw_ctx.session().clone(),
             };
 
@@ -841,12 +841,12 @@ impl ElementTrait for Text {
 
                 let stroke_paint = span.stroke_paint.to_user_space(
                     &text_bbox.rect,
-                    &layout_context.view_params,
+                    &layout_context.viewport,
                     &normalize_values,
                 );
                 let fill_paint = span.fill_paint.to_user_space(
                     &text_bbox.rect,
-                    &layout_context.view_params,
+                    &layout_context.viewport,
                     &normalize_values,
                 );
 
@@ -977,7 +977,7 @@ impl TSpan {
             return;
         }
 
-        let params = NormalizeParams::new(values, &layout_context.view_params);
+        let params = NormalizeParams::new(values, &layout_context.viewport);
 
         let x = self.x.map(|l| l.to_user(&params));
         let y = self.y.map(|l| l.to_user(&params));