feat: Add a function for retrieving the window contents

This function is useful for testing the window contents in certain cases. In addition,
this means that we can now have reliable tests for softbuffer's actual functionality.

Signed-off-by: John Nunley <jtnunley01@gmail.com>
Co-authored-by: dAxpeDDa <daxpedda@gmail.com>

src/cg.rs

@@ -69,6 +69,11 @@ impl CGImpl {
             imp: self,
         })
     }
+
+    /// Fetch the buffer from the window.
+    pub fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
+        Err(SoftBufferError::Unimplemented)
+    }
 }
 
 pub struct BufferImpl<'a> {

src/error.rs

@@ -38,6 +38,9 @@ pub enum SoftBufferError {
 
     #[error("Platform error")]
     PlatformError(Option<String>, Option<Box<dyn Error>>),
+
+    #[error("This function is unimplemented on this platform")]
+    Unimplemented,
 }
 
 /// Convenient wrapper to cast errors into SoftBufferError.

src/lib.rs

@@ -98,6 +98,15 @@ macro_rules! make_dispatch {
                     )*
                 }
             }
+
+            pub fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.fetch(),
+                    )*
+                }
+            }
         }
 
         enum BufferDispatch<'a> {
@@ -306,6 +315,18 @@ impl Surface {
         self.surface_impl.resize(width, height)
     }
 
+    /// Copies the window contents into a buffer.
+    ///
+    /// ## Platform Dependent Behavior
+    ///
+    /// - On X11, the window must be visible.
+    /// - On macOS, Redox and Wayland, this function is unimplemented.
+    /// - On Web, this will fail if the content was supplied by
+    ///   a different origin depending on the sites CORS rules.
+    pub fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
+        self.surface_impl.fetch()
+    }
+
     /// Return a [`Buffer`] that the next frame should be rendered into. The size must
     /// be set with [`Surface::resize`] first. The initial contents of the buffer may be zeroed, or
     /// may contain a previous frame.

src/orbital.rs

@@ -143,6 +143,11 @@ impl OrbitalImpl {
         // Tell orbital to show the latest window data
         syscall::fsync(self.window_fd()).expect("failed to sync orbital window");
     }
+
+    /// Fetch the buffer from the window.
+    pub fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
+        Err(SoftBufferError::Unimplemented)
+    }
 }
 
 enum Pixels {

src/wayland/mod.rs

@@ -129,6 +129,11 @@ impl WaylandImpl {
             Ok(unsafe { buffer.buffers.as_mut().unwrap().1.mapped_mut() })
         })?))
     }
+
+    /// Fetch the buffer from the window.
+    pub fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
+        Err(SoftBufferError::Unimplemented)
+    }
 }
 
 pub struct BufferImpl<'a>(util::BorrowStack<'a, WaylandImpl, [u32]>);

src/web.rs

@@ -24,9 +24,9 @@ pub struct WebDisplayImpl {
 impl WebDisplayImpl {
     pub(super) fn new() -> Result<Self, SoftBufferError> {
         let document = web_sys::window()
-            .swbuf_err("`window` is not present in this runtime")?
+            .swbuf_err("`Window` is not present in this runtime")?
             .document()
-            .swbuf_err("`document` is not present in this runtime")?;
+            .swbuf_err("`Document` is not present in this runtime")?;
 
         Ok(Self { document })
     }
@@ -44,6 +44,9 @@ pub struct WebImpl {
 
     /// The current width of the canvas.
     width: u32,
+
+    /// The current height of the canvas.
+    height: u32,
 }
 
 impl WebImpl {
@@ -76,6 +79,7 @@ impl WebImpl {
             ctx,
             buffer: Vec::new(),
             width: 0,
+            height: 0,
         })
     }
 
@@ -92,6 +96,7 @@ impl WebImpl {
         self.canvas.set_width(width);
         self.canvas.set_height(height);
         self.width = width;
+        self.height = height;
         Ok(())
     }
 
@@ -99,11 +104,32 @@ impl WebImpl {
     pub(crate) fn buffer_mut(&mut self) -> Result<BufferImpl, SoftBufferError> {
         Ok(BufferImpl { imp: self })
     }
+
+    /// Fetch the buffer from the window.
+    pub fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
+        let image_data = self
+            .ctx
+            .get_image_data(0., 0., self.width.into(), self.height.into())
+            .ok()
+            // TODO: Can also error if width or height are 0.
+            .swbuf_err("`Canvas` contains pixels from a different origin")?;
+
+        Ok(image_data
+            .data()
+            .0
+            .chunks_exact(4)
+            .map(|chunk| u32::from_be_bytes([0, chunk[0], chunk[1], chunk[2]]))
+            .collect())
+    }
 }
 
 /// Extension methods for the Wasm target on [`Surface`](crate::Surface).
 pub trait SurfaceExtWeb: Sized {
     /// Creates a new instance of this struct, using the provided [`HtmlCanvasElement`].
+    ///
+    /// # Errors
+    /// - If the canvas was already controlled by an `OffscreenCanvas`.
+    /// - If a another context then "2d" was already created for this canvas.
     fn from_canvas(canvas: HtmlCanvasElement) -> Result<Self, SoftBufferError>;
 }
 
@@ -171,7 +197,7 @@ impl<'a> BufferImpl<'a> {
         let image_data = result.unwrap();
 
         // This can only throw an error if `data` is detached, which is impossible.
-        self.imp.ctx.put_image_data(&image_data, 0.0, 0.0).unwrap();
+        self.imp.ctx.put_image_data(&image_data, 0., 0.).unwrap();
 
         Ok(())
     }

src/win32.rs

@@ -202,6 +202,34 @@ impl Win32Impl {
 
         Ok(BufferImpl(self))
     }
+
+    /// Fetch the buffer from the window.
+    pub fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
+        let buffer = self.buffer.as_ref().unwrap();
+        let temp_buffer = Buffer::new(self.dc, buffer.width, buffer.height);
+
+        // Just go the other way.
+        unsafe {
+            Gdi::BitBlt(
+                temp_buffer.dc,
+                0,
+                0,
+                temp_buffer.width.get(),
+                temp_buffer.height.get(),
+                self.dc,
+                0,
+                0,
+                Gdi::SRCCOPY,
+            );
+        }
+
+        // Flush the operation so that it happens immediately.
+        unsafe {
+            Gdi::GdiFlush();
+        }
+
+        Ok(temp_buffer.pixels().to_vec())
+    }
 }
 
 pub struct BufferImpl<'a>(&'a mut Win32Impl);

src/x11.rs

@@ -104,6 +104,9 @@ pub struct X11Impl {
     /// The depth (bits per pixel) of the drawing context.
     depth: u8,
 
+    /// The visual ID of the drawing context.
+    visual_id: u32,
+
     /// The buffer we draw to.
     buffer: Buffer,
 
@@ -178,11 +181,26 @@ impl X11Impl {
 
         let window = window_handle.window;
 
-        // Run in parallel: start getting the window depth.
-        let geometry_token = display
-            .connection
-            .get_geometry(window)
-            .swbuf_err("Failed to send geometry request")?;
+        // Run in parallel: start getting the window depth and (if necessary) visual.
+        let display2 = display.clone();
+        let tokens = {
+            let geometry_token = display2
+                .connection
+                .get_geometry(window)
+                .swbuf_err("Failed to send geometry request")?;
+            let window_attrs_token = if window_handle.visual_id == 0 {
+                Some(
+                    display2
+                        .connection
+                        .get_window_attributes(window)
+                        .swbuf_err("Failed to send window attributes request")?,
+                )
+            } else {
+                None
+            };
+
+            (geometry_token, window_attrs_token)
+        };
 
         // Create a new graphics context to draw to.
         let gc = display
@@ -201,9 +219,23 @@ impl X11Impl {
             .swbuf_err("Failed to create GC")?;
 
         // Finish getting the depth of the window.
-        let geometry_reply = geometry_token
-            .reply()
-            .swbuf_err("Failed to get geometry reply")?;
+        let (geometry_reply, visual_id) = {
+            let (geometry_token, window_attrs_token) = tokens;
+            let geometry_reply = geometry_token
+                .reply()
+                .swbuf_err("Failed to get geometry reply")?;
+            let visual_id = match window_attrs_token {
+                None => window_handle.visual_id,
+                Some(window_attrs) => {
+                    window_attrs
+                        .reply()
+                        .swbuf_err("Failed to get window attributes reply")?
+                        .visual
+                }
+            };
+
+            (geometry_reply, visual_id)
+        };
 
         // See if SHM is available.
         let buffer = if display.is_shm_available {
@@ -222,6 +254,7 @@ impl X11Impl {
             window,
             gc,
             depth: geometry_reply.depth,
+            visual_id,
             buffer,
             width: 0,
             height: 0,
@@ -277,6 +310,39 @@ impl X11Impl {
         // We can now safely call `buffer_mut` on the buffer.
         Ok(BufferImpl(self))
     }
+
+    /// Fetch the buffer from the window.
+    pub fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
+        log::trace!("fetch: window={:X}", self.window);
+
+        // TODO: Is it worth it to do SHM here? Probably not.
+        let reply = self
+            .display
+            .connection
+            .get_image(
+                xproto::ImageFormat::Z_PIXMAP,
+                self.window,
+                0,
+                0,
+                self.width,
+                self.height,
+                u32::MAX,
+            )
+            .swbuf_err("Failed to send image fetching request")?
+            .reply()
+            .swbuf_err("Failed to fetch image from window")?;
+
+        if reply.depth == self.depth && reply.visual == self.visual_id {
+            let mut out = vec![0u32; reply.data.len() / 4];
+            bytemuck::cast_slice_mut::<u32, u8>(&mut out).copy_from_slice(&reply.data);
+            Ok(out)
+        } else {
+            Err(SoftBufferError::PlatformError(
+                Some("Mismatch between reply and window data".into()),
+                None,
+            ))
+        }
+    }
 }
 
 pub struct BufferImpl<'a>(&'a mut X11Impl);