Get rid of unsafe on EGLContext

[JoHaHu]

I'm currently starting to learn much about wayland and the linux graphics stack.
My goal is to write my own wayland composer in Rust using smithay.
While studying the code base i've got some questions.

The EGLContext is only safe to Send under certain conditions.
A lot of functions in the egl module are unsafe for that reason.

// SAFETY: A context can be sent to another thread when this context is not current.
//
// If the context is made current, the safety requirements for calling `EGLDisplay::make_current` must be
// upheld. This means a context which is made current must be unbound (using `unbind`) in order to send this
// context to another thread.
unsafe impl Send for EGLContext {}

https://github.com/Smithay/smithay/blob/master/src/backend/egl/context.rs#L36C1-L41C35

With an API like this only UnboundEGLContext is Send and functions can be implemented on the types where there are safe to use.
Are there any reasons why this wouldn't work?
Are there more safety contraints I'm unaware of?

use smithay::backend::egl::ffi;

pub struct BoundEGLContext {
    pub context: ffi::egl::types::EGLContext,
}

pub struct UnboundEGLContext {
    pub context: ffi::egl::types::EGLContext,
}

unsafe impl Send for UnboundEGLContext {}
pub trait EGLContext {
    fn shared(&self) ;
}

impl BoundEGLContext {
    pub fn unbind(self) -> UnboundEGLContext {
        //...
        UnboundEGLContext {
            context: self.context,
        }
    }
    // operations only allowed on bound context
    pub fn unsafe_operation(&self) {}
}

impl UnboundEGLContext {
    pub fn bind(self) -> BoundEGLContext {
        // ...
        BoundEGLContext {
            context: self.context,
        }
    }
    // operations only allowed on unbound context
    pub fn unsafe_operation(&self) {}
}

impl EGLContext for UnboundEGLContext {
    fn shared(&self) {}
}

impl EGLContext for BoundEGLContext {
    fn shared(&self) {}
}