Make Debug impls not output pixel data

Author: madsmtm

src/backends/android.rs

@@ -12,7 +12,7 @@ use raw_window_handle::AndroidNdkWindowHandle;
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawWindowHandle};
 
 use crate::error::InitError;
-use crate::{BufferInterface, Rect, SoftBufferError, SurfaceInterface};
+use crate::{util, BufferInterface, Rect, SoftBufferError, SurfaceInterface};
 
 /// The handle to a window for software buffering.
 #[derive(Debug)]
@@ -103,7 +103,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Android
 
         Ok(BufferImpl {
             native_window_buffer,
-            buffer,
+            buffer: util::PixelBuffer(buffer),
             marker: PhantomData,
         })
     }
@@ -117,7 +117,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Android
 #[derive(Debug)]
 pub struct BufferImpl<'a, D: ?Sized, W> {
     native_window_buffer: NativeWindowBufferLockGuard<'a>,
-    buffer: Vec<u32>,
+    buffer: util::PixelBuffer,
     marker: PhantomData<(&'a D, &'a W)>,
 }
 

src/backends/cg.rs

@@ -1,7 +1,7 @@
 //! Softbuffer implementation using CoreGraphics.
 use crate::backend_interface::*;
 use crate::error::InitError;
-use crate::{Rect, SoftBufferError};
+use crate::{util, Rect, SoftBufferError};
 use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, Bool};
 use objc2::{define_class, msg_send, AllocAnyThread, DefinedClass, MainThreadMarker, Message};
@@ -260,7 +260,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for CGImpl<
 
     fn buffer_mut(&mut self) -> Result<BufferImpl<'_, D, W>, SoftBufferError> {
         Ok(BufferImpl {
-            buffer: vec![0; self.width * self.height].into(),
+            buffer: util::PixelBuffer(vec![0; self.width * self.height]),
             imp: self,
         })
     }
@@ -269,7 +269,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for CGImpl<
 #[derive(Debug)]
 pub struct BufferImpl<'a, D, W> {
     imp: &'a mut CGImpl<D, W>,
-    buffer: Box<[u32]>,
+    buffer: util::PixelBuffer,
 }
 
 impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_, D, W> {
@@ -309,7 +309,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> BufferInterface for BufferImpl<'_,
 
         let data_provider = {
             let len = self.buffer.len() * size_of::<u32>();
-            let buffer: *mut [u32] = Box::into_raw(self.buffer);
+            let buffer: *mut [u32] = Box::into_raw(self.buffer.0.into_boxed_slice());
             // Convert slice pointer to thin pointer.
             let data_ptr = buffer.cast::<c_void>();
 

src/backends/orbital.rs

@@ -3,7 +3,7 @@ use raw_window_handle::{HasDisplayHandle, HasWindowHandle, OrbitalWindowHandle,
 use std::{cmp, marker::PhantomData, num::NonZeroU32, slice, str};
 
 use crate::backend_interface::*;
-use crate::{Rect, SoftBufferError};
+use crate::{util, Rect, SoftBufferError};
 
 #[derive(Debug)]
 struct OrbitalMap {
@@ -177,7 +177,11 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Orbital
                     .expect("failed to map orbital window"),
             )
         } else {
-            Pixels::Buffer(vec![0; self.width as usize * self.height as usize])
+            Pixels::Buffer(util::PixelBuffer(vec![
+                0;
+                self.width as usize
+                    * self.height as usize
+            ]))
         };
         Ok(BufferImpl { imp: self, pixels })
     }
@@ -186,7 +190,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for Orbital
 #[derive(Debug)]
 enum Pixels {
     Mapping(OrbitalMap),
-    Buffer(Vec<u32>),
+    Buffer(util::PixelBuffer),
 }
 
 #[derive(Debug)]

src/backends/web.rs

@@ -49,7 +49,7 @@ pub struct WebImpl<D, W> {
     canvas: Canvas,
 
     /// The buffer that we're drawing to.
-    buffer: Vec<u32>,
+    buffer: util::PixelBuffer,
 
     /// Buffer has been presented.
     buffer_presented: bool,
@@ -84,7 +84,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> WebImpl<D, W> {
 
         Ok(Self {
             canvas: Canvas::Canvas { canvas, ctx },
-            buffer: Vec::new(),
+            buffer: util::PixelBuffer(Vec::new()),
             buffer_presented: false,
             size: None,
             window_handle: window,
@@ -100,7 +100,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> WebImpl<D, W> {
 
         Ok(Self {
             canvas: Canvas::OffscreenCanvas { canvas, ctx },
-            buffer: Vec::new(),
+            buffer: util::PixelBuffer(Vec::new()),
             buffer_presented: false,
             size: None,
             window_handle: window,

src/backends/x11.rs

@@ -7,7 +7,7 @@
 
 use crate::backend_interface::*;
 use crate::error::{InitError, SwResultExt};
-use crate::{Rect, SoftBufferError};
+use crate::{util, Rect, SoftBufferError};
 use raw_window_handle::{
     HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle, XcbDisplayHandle,
     XcbWindowHandle,
@@ -163,7 +163,7 @@ enum Buffer {
     Shm(ShmBuffer),
 
     /// A normal buffer that we send over the wire.
-    Wire(Vec<u32>),
+    Wire(util::PixelBuffer),
 }
 
 #[derive(Debug)]
@@ -289,7 +289,7 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> SurfaceInterface<D, W> fo
             })
         } else {
             // SHM is not available.
-            Buffer::Wire(Vec::new())
+            Buffer::Wire(util::PixelBuffer(Vec::new()))
         };
 
         Ok(Self {
@@ -801,7 +801,10 @@ impl<D: ?Sized> Drop for X11DisplayImpl<D> {
 impl<D: ?Sized, W: ?Sized> Drop for X11Impl<D, W> {
     fn drop(&mut self) {
         // If we used SHM, make sure it's detached from the server.
-        if let Buffer::Shm(mut shm) = mem::replace(&mut self.buffer, Buffer::Wire(Vec::new())) {
+        if let Buffer::Shm(mut shm) = mem::replace(
+            &mut self.buffer,
+            Buffer::Wire(util::PixelBuffer(Vec::new())),
+        ) {
             // If we were in the middle of processing a buffer, wait for it to finish.
             shm.finish_wait(self.display.connection()).ok();
 

src/util.rs

@@ -4,6 +4,7 @@
 use std::cmp;
 use std::fmt;
 use std::num::NonZeroU32;
+use std::ops;
 
 use crate::Rect;
 use crate::SoftBufferError;
@@ -94,6 +95,29 @@ pub(crate) fn union_damage(damage: &[Rect]) -> Option<Rect> {
     })
 }
 
+/// A wrapper around a `Vec` of pixels that doesn't print the whole buffer on `Debug`.
+#[derive(PartialEq, Eq, Hash, Clone)]
+pub(crate) struct PixelBuffer(pub Vec<u32>);
+
+impl fmt::Debug for PixelBuffer {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PixelBuffer").finish_non_exhaustive()
+    }
+}
+
+impl ops::Deref for PixelBuffer {
+    type Target = Vec<u32>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl ops::DerefMut for PixelBuffer {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;