Replace renderer() with with_primary_renderer()

5 files changed, 48 insertions, 39 deletions

diff --git a/src/backend/mod.rs b/src/backend/mod.rs
index a23cc36a..54b504ca 100644
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -45,10 +45,13 @@ impl Backend {
         }
     }
 
-    pub fn renderer(&mut self) -> Option<&mut GlesRenderer> {
+    pub fn with_primary_renderer<T>(
+        &mut self,
+        f: impl FnOnce(&mut GlesRenderer) -> T,
+    ) -> Option<T> {
         match self {
-            Backend::Tty(tty) => tty.renderer(),
-            Backend::Winit(winit) => Some(winit.renderer()),
+            Backend::Tty(tty) => tty.with_primary_renderer(f),
+            Backend::Winit(winit) => winit.with_primary_renderer(f),
         }
     }
 
diff --git a/src/backend/tty.rs b/src/backend/tty.rs
index 7c2a35b0..67aa6af0 100644
--- a/src/backend/tty.rs
+++ b/src/backend/tty.rs
@@ -860,8 +860,11 @@ impl Tty {
         self.session.seat()
     }
 
-    pub fn renderer(&mut self) -> Option<&mut GlesRenderer> {
-        self.output_device.as_mut().map(|d| &mut d.gles)
+    pub fn with_primary_renderer<T>(
+        &mut self,
+        f: impl FnOnce(&mut GlesRenderer) -> T,
+    ) -> Option<T> {
+        self.output_device.as_mut().map(|d| f(&mut d.gles))
     }
 
     pub fn render(
diff --git a/src/backend/winit.rs b/src/backend/winit.rs
index 0bda3984..b3c89e17 100644
--- a/src/backend/winit.rs
+++ b/src/backend/winit.rs
@@ -129,8 +129,11 @@ impl Winit {
         "winit".to_owned()
     }
 
-    pub fn renderer(&mut self) -> &mut GlesRenderer {
-        self.backend.renderer()
+    pub fn with_primary_renderer<T>(
+        &mut self,
+        f: impl FnOnce(&mut GlesRenderer) -> T,
+    ) -> Option<T> {
+        Some(f(self.backend.renderer()))
     }
 
     pub fn render(&mut self, niri: &mut Niri, output: &Output) -> RenderResult {
diff --git a/src/input.rs b/src/input.rs
index 117b212d..7b58ad1e 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -252,15 +252,15 @@ impl State {
             Action::ScreenshotScreen => {
                 let active = self.niri.layout.active_output().cloned();
                 if let Some(active) = active {
-                    if let Some(renderer) = self.backend.renderer() {
+                    self.backend.with_primary_renderer(|renderer| {
                         if let Err(err) = self.niri.screenshot(renderer, &active) {
                             warn!("error taking screenshot: {err:?}");
                         }
-                    }
+                    });
                 }
             }
             Action::ConfirmScreenshot => {
-                if let Some(renderer) = self.backend.renderer() {
+                self.backend.with_primary_renderer(|renderer| {
                     match self.niri.screenshot_ui.capture(renderer) {
                         Ok((size, pixels)) => {
                             if let Err(err) = self.niri.save_screenshot(size, pixels) {
@@ -271,7 +271,7 @@ impl State {
                             warn!("error capturing screenshot: {err:?}");
                         }
                     }
-                }
+                });
 
                 self.niri.screenshot_ui.close();
                 self.niri
@@ -287,18 +287,18 @@ impl State {
                 self.niri.queue_redraw_all();
             }
             Action::Screenshot => {
-                if let Some(renderer) = self.backend.renderer() {
+                self.backend.with_primary_renderer(|renderer| {
                     self.niri.open_screenshot_ui(renderer);
-                }
+                });
             }
             Action::ScreenshotWindow => {
                 let active = self.niri.layout.active_window();
                 if let Some((window, output)) = active {
-                    if let Some(renderer) = self.backend.renderer() {
+                    self.backend.with_primary_renderer(|renderer| {
                         if let Err(err) = self.niri.screenshot_window(renderer, output, window) {
                             warn!("error taking screenshot: {err:?}");
                         }
-                    }
+                    });
                 }
             }
             Action::CloseWindow => {
diff --git a/src/niri.rs b/src/niri.rs
index fb8c3c9d..c07bb081 100644
--- a/src/niri.rs
+++ b/src/niri.rs
@@ -580,31 +580,32 @@ impl State {
         let ScreenshotToNiri::TakeScreenshot { include_cursor } = msg;
         let _span = tracy_client::span!("TakeScreenshot");
 
-        let Some(renderer) = self.backend.renderer() else {
-            let msg = NiriToScreenshot::ScreenshotResult(None);
-            if let Err(err) = to_screenshot.send_blocking(msg) {
-                warn!("error sending None to screenshot: {err:?}");
-            }
-            return;
-        };
+        let rv = self.backend.with_primary_renderer(|renderer| {
+            let on_done = {
+                let to_screenshot = to_screenshot.clone();
+                move |path| {
+                    let msg = NiriToScreenshot::ScreenshotResult(Some(path));
+                    if let Err(err) = to_screenshot.send_blocking(msg) {
+                        warn!("error sending path to screenshot: {err:?}");
+                    }
+                }
+            };
+
+            let res = self
+                .niri
+                .screenshot_all_outputs(renderer, include_cursor, on_done);
 
-        let on_done = {
-            let to_screenshot = to_screenshot.clone();
-            move |path| {
-                let msg = NiriToScreenshot::ScreenshotResult(Some(path));
+            if let Err(err) = res {
+                warn!("error taking a screenshot: {err:?}");
+
+                let msg = NiriToScreenshot::ScreenshotResult(None);
                 if let Err(err) = to_screenshot.send_blocking(msg) {
-                    warn!("error sending path to screenshot: {err:?}");
+                    warn!("error sending None to screenshot: {err:?}");
                 }
             }
-        };
-
-        let res = self
-            .niri
-            .screenshot_all_outputs(renderer, include_cursor, on_done);
-
-        if let Err(err) = res {
-            warn!("error taking a screenshot: {err:?}");
+        });
 
+        if rv.is_none() {
             let msg = NiriToScreenshot::ScreenshotResult(None);
             if let Err(err) = to_screenshot.send_blocking(msg) {
                 warn!("error sending None to screenshot: {err:?}");
@@ -1717,10 +1718,9 @@ impl Niri {
         // Render and send to PipeWire screencast streams.
         #[cfg(feature = "xdp-gnome-screencast")]
         {
-            let renderer = backend
-                .renderer()
-                .expect("renderer must not have disappeared");
-            self.render_for_screen_cast(renderer, output, target_presentation_time);
+            backend.with_primary_renderer(|renderer| {
+                self.render_for_screen_cast(renderer, output, target_presentation_time);
+            });
         }
     }