RFC: Could winit 0.27 optionally support raw_window_handle 0.4 (for compatibility with wgpu 0.13) perhaps?

[rib]

The recent introduction of the raw_window_handle 0.5 crate dependency has ended up blocking some projects from being able to update to winit 0.27 while they need to wait for it to permeate through other crates first (e.g. waiting for a wgpu 0.14 release which is estimated to happen around the end of September, ref: gfx-rs/wgpu#2918)

For reference, here is an Egui PR that looked at upgrading to Winit 0.27: emilk/egui#1877 which is blocked on wgpu 0.14.

Similarly a PR for Bevy: bevyengine/bevy#5347 that's also blocked on wgpu 0.14 (though the timing looks reasonable here because they only just released Bevy 0.8 anyway, so waiting for wgpu 0.14 isn't a huge deal)

More generally; considering how central wgpu is within the Rust ecosystem I wonder if Winit could strive to ensure, where possible, that new releases remain compatible with the most recent stable release of wgpu.

As it is I guess there will be quite some lag before developers really start using Winit 0.27 which might also mean that potential issues with a new release may not get discovered until quite late.

Maybe future changes similar to this could be phased in over two releases to avoid having to wait a full release cycle for crates like wgpu before a new version of winit can be adopted.

In this case I suppose it was also just unfortunate timing that wgpu was released so recently, just before winit 0.27 was released.

[kchibisov]

If someone has time and dedication to add a feature for old raw window handle, I can review and we can make a new bug fix release for that, not a big deal. But I don't have time to write it up myself.

In general that would be nice to have some communication in terms of bugs/winit releases, etc, with major consumers. Unfortunately only alacritty is present here and provide in time feedback due to me actively working on all related projects. I could be present on wgpu/whatever bug tracker/channels, but sadly I don't have infinite time to keep track of everything.

[maroider]

I'm very much interested in having better coordination around these sorts of things, and I'd be happy to spend the time required to facilitate this.

As for our current ecosystem woes, I did ask whether it was possible for us to pull the semver trick again, and I still don't see why it wouldn't possible (and I'm currently trying to verify that it is). As I understand it, the main thing that's required for it to work for our purposes is that we implement 0.4.3::HasRawWindowHandle for T: 0.5.0::HasRawWindowHandle + 0.5.0::HasRawDisplayHandle. Additionally, adding a HasRawDisplayHandle impl to a window type (if there exists some provider crate that updated but didn't add one) should be a non-breaking change.

[kchibisov]

I think what we can do is to handle that on winit level, and leave raw-window-handle as is? Don't really want to encourage anyone to still use old raw-window-handle, given that this will be a temporary feature.

[rib]

Yeah, I'm vaguely imagining it might be possible to add a "raw_window_handle_04" feature to winit 0.27 that could select a different raw_window_handle optional dependency - and then crates like egui or bevy could specify that winit feature until wgpu 0.14 is released. It's a little unusual though and I'm not sure if it might set things up to be more confusing with creating conflicts between crates expecting winit to work with raw_window_handle 0.5 and being surprised by something that adds this feature to force 0.4.

I'm not sure if the semver trick helps here while that's generally for situations where you have numerous APIs that aren't affected by a semver change that can continue to work as-is while different crates in the ecosystem stagger their upgrades (which can work for the crates that are only using apis that didn't change) but there's only really one API with raw_window_handle and since it a producer/consumer type API then both sides need to be in strict agreement about it.

It might even be that the time is passed to really do much here (I'm not exactly sure), and maybe it's just best to incorporate something into the CONTRIBUTING docs or something similar to try and check that winit master always remains compatible with the latest stable wgpu as part of its release processes. Maybe something that can be checked via CI.

[rib]

Thinking about @maroider's comment, I'm wondering now if there's anything that fundamentally stops winit from implementing the 0.4 and the 0.5 HasRawWindowHandle traits? No need for a feature flag - winit 0.27 could just have dependencies on both versions of the raw_window_handle crate for now - and the 0.4 dependency could be dropped for the next winit release.

Might be overlooking something though?

[rib]

It could be neat if winit can even blanket implement 0.4::HasWindowHandle in terms of the current 0.5::HasWindowHandle and 0.5::HasDisplayHandle (since Window currently implements the HasDisplayHandle trait so maybe everything needed is accessible in src/window.rs to implement the old trait.)

[maroider]

but there's only really one API with raw_window_handle and since it a producer/consumer type API then both sides need to be in strict agreement about it

While that may strictly speaking be true, I'd say it's also the case that:

1. winit updates raw-window-handle first
2. consumers update at their own pace
3. crates which depend on winit and a consumer can update to the latest winit version
4. other producers (e.g. SDL2, GLFW) end up updating to remain compatible with consumers

In this practical reality, we want to have the second and third steps here happen as fast as possible, but wgpu's release schedule keeps us from really passing the second step at the moment.

Additionally, we're still effectively providing the same information/data we did previously (ignoring the added GBM support), just shuffled around somewhat.

Don't really want to encourage anyone to still use old raw-window-handle, given that this will be a temporary feature.

Once consumers update (well, really, once wgpu updates) other producers will be pressured into updating as well. We wouldn't be doing the semver trick in such a way that old producers can be used with updated consumers, much like how we did it the last time around.

[rib]

Just experimenting it looks like we could have a self-contained implementation of the 0.4::HasWindowHandle in src/windows.rs that looks something like:

unsafe impl raw_window_handle_04::HasRawWindowHandle for Window {
    /// Returns a [`raw_window_handle_04::RawWindowHandle`] for the Window
    ///
    /// ## Platform-specific
    ///
    /// ### Android
    ///
    /// Only available after receiving [`Event::Resumed`] and before [`Event::Suspended`]. *If you
    /// try to get the handle outside of that period, this function will panic*!
    ///
    /// Make sure to release or destroy any resources created from this `RawWindowHandle` (ie. Vulkan
    /// or OpenGL surfaces) before returning from [`Event::Suspended`], at which point Android will
    /// release the underlying window/surface: any subsequent interaction is undefined behavior.
    ///
    /// [`Event::Resumed`]: crate::event::Event::Resumed
    /// [`Event::Suspended`]: crate::event::Event::Suspended
    fn raw_window_handle(&self) -> raw_window_handle_04::RawWindowHandle {
        use raw_window_handle_04::{
            UiKitHandle,
            AppKitHandle,
            OrbitalHandle,
            XlibHandle,
            XcbHandle,
            WaylandHandle,
            //DrmHandle,
            //GbmHandle,
            Win32Handle,
            WinRtHandle,
            WebHandle,
            AndroidNdkHandle,
            HaikuHandle
        };

        // XXX: Ideally this would be encapsulated either through a compatibility API from
        // raw_window_handle_05 or else within the backends but since this is only
        // to provide short-term backwards compatibility to make it easier to crates to
        // adopt Winit 0.27 then we just handle the full mapping inline here
        match self.window.raw_window_handle() {
            RawWindowHandle::UiKit(window_handle) => {
                let mut handle = UiKitHandle::empty();
                handle.ui_view = window_handle.ui_view;
                handle.ui_window = window_handle.ui_window;
                handle.ui_view_controller = window_handle.ui_view_controller;
                raw_window_handle_04::RawWindowHandle::UiKit(handle)
            },
            RawWindowHandle::AppKit(window_handle) => {
                let mut handle = AppKitHandle::empty();
                handle.ns_window = window_handle.ns_window;
                handle.ns_view = window_handle.ns_view;
                raw_window_handle_04::RawWindowHandle::AppKit(handle)
            },
            RawWindowHandle::Orbital(window_handle) => {
                let mut handle = OrbitalHandle::empty();
                handle.window = window_handle.window;
                raw_window_handle_04::RawWindowHandle::Orbital(handle)
            },
            RawWindowHandle::Xlib(window_handle) => {
                if let RawDisplayHandle::Xlib(display_handle) = self.window.raw_display_handle() {
                    let mut handle = XlibHandle::empty();
                    handle.display = display_handle.display;
                    handle.window = window_handle.window;
                    handle.visual_id = window_handle.visual_id;
                    raw_window_handle_04::RawWindowHandle::Xlib(handle)
                } else {
                    panic!("Unsupported display handle associated with Xlib window");
                }
            },
            RawWindowHandle::Xcb(window_handle) => {
                if let RawDisplayHandle::Xcb(display_handle) = self.window.raw_display_handle() {
                    let mut handle = XcbHandle::empty();
                    handle.connection = display_handle.connection;
                    handle.window = window_handle.window;
                    handle.visual_id = window_handle.visual_id;
                    raw_window_handle_04::RawWindowHandle::Xcb(handle)
                } else {
                    panic!("Unsupported display handle associated with Xcb window");
                }
            },
            RawWindowHandle::Wayland(window_handle) => {
                if let RawDisplayHandle::Wayland(display_handle) = self.window.raw_display_handle() {
                    let mut handle = WaylandHandle::empty();
                    handle.display = display_handle.display;
                    handle.surface = window_handle.surface;
                    raw_window_handle_04::RawWindowHandle::Wayland(handle)
                } else {
                    panic!("Unsupported display handle associated with Xcb window");
                }
            },
            /*
            RawWindowHandle::Drm(window_handle) => {
                let mut handle = FooHandle::empty();
                handle.foo = window_handle.foo;
                raw_window_handle_04::RawWindowHandle::Drm(handle);
            },
            RawWindowHandle::Gbm(window_handle) => {
                let mut handle = FooHandle::empty();
                handle.foo = window_handle.foo;
                raw_window_handle_04::RawWindowHandle::Gbm(handle);
            },
            */
            RawWindowHandle::Win32(window_handle) => {
                let mut handle = Win32Handle::empty();
                handle.hwnd = window_handle.hwnd;
                handle.hinstance = window_handle.hinstance;
                raw_window_handle_04::RawWindowHandle::Win32(handle)
            },
            RawWindowHandle::WinRt(window_handle) => {
                let mut handle = WinRtHandle::empty();
                handle.core_window = window_handle.core_window;
                raw_window_handle_04::RawWindowHandle::WinRt(handle)
            },
            RawWindowHandle::Web(window_handle) => {
                let mut handle = WebHandle::empty();
                handle.id = window_handle.id;
                raw_window_handle_04::RawWindowHandle::Web(handle)
            },
            RawWindowHandle::AndroidNdk(window_handle) => {
                let mut handle = AndroidNdkHandle::empty();
                handle.a_native_window = window_handle.a_native_window;
                raw_window_handle_04::RawWindowHandle::AndroidNdk(handle)
            },
            RawWindowHandle::Haiku(window_handle) => {
                let mut handle = HaikuHandle::empty();
                handle.b_window = window_handle.b_window;
                handle.b_direct_window = window_handle.b_direct_window;
                raw_window_handle_04::RawWindowHandle::Haiku(handle)
            },
            _ => panic!("No HasRawWindowHandle version 0.4 backwards compatibility for new Winit window type"),
        }
    }
}

With the dependencies declared like this in Cargo.toml

raw_window_handle_05 = { package = "raw-window-handle", version = "0.5" }
raw_window_handle_04 = { package = "raw-window-handle", version = "0.4" }