egl: move eglSwapBuffers call into NativeSurface

src/backend/drm/gbm/egl.rs

@@ -7,7 +7,9 @@
 use crate::backend::drm::{Device, RawDevice, Surface};
 use crate::backend::egl::native::{Backend, NativeDisplay, NativeSurface};
 use crate::backend::egl::{display::EGLDisplayHandle, ffi};
-use crate::backend::egl::{wrap_egl_call, EGLError, Error as EglBackendError, SurfaceCreationError};
+use crate::backend::egl::{
+    wrap_egl_call, EGLError, Error as EglBackendError, SurfaceCreationError, SwapBuffersError,
+};
 
 use super::{Error, GbmDevice, GbmSurface};
 
@@ -109,9 +111,15 @@ unsafe impl<D: RawDevice + 'static> NativeSurface for GbmSurface<D> {
         self.needs_recreation()
     }
 
-    fn swap_buffers(&self) -> Result<(), Self::Error> {
+    fn swap_buffers(
+        &self,
+        display: &Arc<EGLDisplayHandle>,
+        surface: ffi::egl::types::EGLSurface,
+    ) -> Result<(), SwapBuffersError<Self::Error>> {
+        wrap_egl_call(|| unsafe { ffi::egl::SwapBuffers(***display, surface as *const _) })
+            .map_err(SwapBuffersError::EGLSwapBuffers)?;
         // this is safe since `eglSwapBuffers` will have been called exactly once
         // if this is used by our egl module, which is why this trait is unsafe.
-        unsafe { self.page_flip() }
+        unsafe { self.page_flip() }.map_err(SwapBuffersError::Underlying)
     }
 }

src/backend/egl/native.rs

@@ -1,6 +1,8 @@
 //! Type safe native types for safe context/surface creation
 
-use super::{display::EGLDisplayHandle, ffi, wrap_egl_call, EGLError, Error, SurfaceCreationError};
+use super::{
+    display::EGLDisplayHandle, ffi, wrap_egl_call, EGLError, Error, SurfaceCreationError, SwapBuffersError,
+};
 use nix::libc::{c_int, c_void};
 
 #[cfg(feature = "backend_winit")]
@@ -228,8 +230,15 @@ pub unsafe trait NativeSurface {
     /// [EGLSurface::swap_buffers](::backend::egl::surface::EGLSurface::swap_buffers)
     ///
     /// Only implement if required by the backend.
-    fn swap_buffers(&self) -> Result<(), Self::Error> {
+    fn swap_buffers(
-        Ok(())
+        &self,
+        display: &Arc<EGLDisplayHandle>,
+        surface: ffi::egl::types::EGLSurface,
+    ) -> Result<(), SwapBuffersError<Self::Error>> {
+        wrap_egl_call(|| unsafe {
+            ffi::egl::SwapBuffers(***display, surface as *const _);
+        })
+        .map_err(SwapBuffersError::EGLSwapBuffers)
     }
 }
 

src/backend/egl/surface.rs

@@ -1,6 +1,6 @@
 //! EGL surface related structs
 
-use super::{ffi, native, wrap_egl_call, EGLError, SurfaceCreationError, SwapBuffersError};
+use super::{ffi, native, EGLError, SurfaceCreationError, SwapBuffersError};
 use crate::backend::egl::display::EGLDisplayHandle;
 use crate::backend::graphics::PixelFormat;
 use nix::libc::c_int;
@@ -93,9 +93,7 @@ impl<N: native::NativeSurface> EGLSurface<N> {
         let surface = self.surface.get();
 
         let result = if !surface.is_null() {
-            wrap_egl_call(|| unsafe { ffi::egl::SwapBuffers(**self.display, surface as *const _) })
+            self.native.swap_buffers(&self.display, surface)
-                .map_err(SwapBuffersError::EGLSwapBuffers)
-                .and_then(|_| self.native.swap_buffers().map_err(SwapBuffersError::Underlying))
         } else {
             Err(SwapBuffersError::EGLSwapBuffers(EGLError::BadSurface))
         };