Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

9 files changed, 903 insertions, 0 deletions

diff --git a/third_party/rust/raw-window-handle/src/android.rs b/third_party/rust/raw-window-handle/src/android.rs
new file mode 100644
index 0000000000..e4504cebf2
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/android.rs
@@ -0,0 +1,43 @@
+use core::ffi::c_void;
+use core::ptr;
+
+/// Raw display handle for Android.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::AndroidDisplayHandle;
+/// let mut display_handle = AndroidDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AndroidDisplayHandle;
+
+impl AndroidDisplayHandle {
+    pub fn empty() -> Self {
+        Self {}
+    }
+}
+
+/// Raw window handle for Android NDK.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::AndroidNdkWindowHandle;
+/// let mut window_handle = AndroidNdkWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AndroidNdkWindowHandle {
+    /// A pointer to an `ANativeWindow`.
+    pub a_native_window: *mut c_void,
+}
+
+impl AndroidNdkWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            a_native_window: ptr::null_mut(),
+        }
+    }
+}
diff --git a/third_party/rust/raw-window-handle/src/appkit.rs b/third_party/rust/raw-window-handle/src/appkit.rs
new file mode 100644
index 0000000000..1023aa038b
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/appkit.rs
@@ -0,0 +1,47 @@
+use core::ffi::c_void;
+use core::ptr;
+
+/// Raw display handle for AppKit.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::AppKitDisplayHandle;
+/// let mut display_handle = AppKitDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AppKitDisplayHandle;
+
+impl AppKitDisplayHandle {
+    pub fn empty() -> Self {
+        Self {}
+    }
+}
+
+/// Raw window handle for AppKit.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::AppKitWindowHandle;
+/// let mut window_handle = AppKitWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AppKitWindowHandle {
+    /// A pointer to an `NSWindow` object.
+    pub ns_window: *mut c_void,
+    /// A pointer to an `NSView` object.
+    pub ns_view: *mut c_void,
+    // TODO: WHAT ABOUT ns_window_controller and ns_view_controller?
+}
+
+impl AppKitWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            ns_window: ptr::null_mut(),
+            ns_view: ptr::null_mut(),
+        }
+    }
+}
diff --git a/third_party/rust/raw-window-handle/src/haiku.rs b/third_party/rust/raw-window-handle/src/haiku.rs
new file mode 100644
index 0000000000..d44e8c2017
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/haiku.rs
@@ -0,0 +1,46 @@
+use core::ffi::c_void;
+use core::ptr;
+
+/// Raw display handle for Haiku.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::HaikuDisplayHandle;
+/// let mut display_handle = HaikuDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct HaikuDisplayHandle;
+
+impl HaikuDisplayHandle {
+    pub fn empty() -> Self {
+        Self {}
+    }
+}
+
+/// Raw window handle for Haiku.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::HaikuWindowHandle;
+/// let mut window_handle = HaikuWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct HaikuWindowHandle {
+    /// A pointer to a BWindow object
+    pub b_window: *mut c_void,
+    /// A pointer to a BDirectWindow object that might be null
+    pub b_direct_window: *mut c_void,
+}
+
+impl HaikuWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            b_window: ptr::null_mut(),
+            b_direct_window: ptr::null_mut(),
+        }
+    }
+}
diff --git a/third_party/rust/raw-window-handle/src/lib.rs b/third_party/rust/raw-window-handle/src/lib.rs
new file mode 100644
index 0000000000..01c70a5775
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/lib.rs
@@ -0,0 +1,307 @@
+#![no_std]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
+//! Interoperability library for Rust Windowing applications.
+//!
+//! This library provides standard types for accessing a window's platform-specific raw window
+//! handle and platforms display handle. This does not provide any utilities for creating and
+//! managing windows; instead, it provides a common interface that window creation libraries (e.g.
+//! Winit, SDL) can use to easily talk with graphics libraries (e.g. gfx-hal).
+//!
+//! ## Safety guarantees
+//!
+//! Please see the docs of [`HasRawWindowHandle`] and [`HasRawDisplayHandle`].
+//!
+//! ## Platform handle initialization
+//!
+//! Each platform handle struct is purposefully non-exhaustive, so that additional fields may be
+//! added without breaking backwards compatibility. Each struct provides an `empty` method that may
+//! be used along with the struct update syntax to construct it. See each specific struct for
+//! examples.
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+mod android;
+mod appkit;
+mod haiku;
+mod redox;
+mod uikit;
+mod unix;
+mod web;
+mod windows;
+
+pub use android::{AndroidDisplayHandle, AndroidNdkWindowHandle};
+pub use appkit::{AppKitDisplayHandle, AppKitWindowHandle};
+pub use haiku::{HaikuDisplayHandle, HaikuWindowHandle};
+pub use redox::{OrbitalDisplayHandle, OrbitalWindowHandle};
+pub use uikit::{UiKitDisplayHandle, UiKitWindowHandle};
+pub use unix::{
+    DrmDisplayHandle, DrmWindowHandle, GbmDisplayHandle, GbmWindowHandle, WaylandDisplayHandle,
+    WaylandWindowHandle, XcbDisplayHandle, XcbWindowHandle, XlibDisplayHandle, XlibWindowHandle,
+};
+pub use web::{WebDisplayHandle, WebWindowHandle};
+pub use windows::{Win32WindowHandle, WinRtWindowHandle, WindowsDisplayHandle};
+
+/// Window that wraps around a raw window handle.
+///
+/// # Safety
+///
+/// Users can safely assume that non-`null`/`0` fields are valid handles, and it is up to the
+/// implementer of this trait to ensure that condition is upheld.
+///
+/// Despite that qualification, implementers should still make a best-effort attempt to fill in all
+/// available fields. If an implementation doesn't, and a downstream user needs the field, it should
+/// try to derive the field from other fields the implementer *does* provide via whatever methods the
+/// platform provides.
+///
+/// The exact handles returned by `raw_window_handle` must remain consistent between multiple calls
+/// to `raw_window_handle` as long as not indicated otherwise by platform specific events.
+pub unsafe trait HasRawWindowHandle {
+    fn raw_window_handle(&self) -> RawWindowHandle;
+}
+
+unsafe impl<'a, T: HasRawWindowHandle + ?Sized> HasRawWindowHandle for &'a T {
+    fn raw_window_handle(&self) -> RawWindowHandle {
+        (*self).raw_window_handle()
+    }
+}
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+unsafe impl<T: HasRawWindowHandle + ?Sized> HasRawWindowHandle for alloc::rc::Rc<T> {
+    fn raw_window_handle(&self) -> RawWindowHandle {
+        (**self).raw_window_handle()
+    }
+}
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+unsafe impl<T: HasRawWindowHandle + ?Sized> HasRawWindowHandle for alloc::sync::Arc<T> {
+    fn raw_window_handle(&self) -> RawWindowHandle {
+        (**self).raw_window_handle()
+    }
+}
+
+/// An enum to simply combine the different possible raw window handle variants.
+///
+/// # Variant Availability
+///
+/// Note that all variants are present on all targets (none are disabled behind
+/// `#[cfg]`s), but see the "Availability Hints" section on each variant for
+/// some hints on where this variant might be expected.
+///
+/// Note that these "Availability Hints" are not normative. That is to say, a
+/// [`HasRawWindowHandle`] implementor is completely allowed to return something
+/// unexpected. (For example, it's legal for someone to return a
+/// [`RawWindowHandle::Xlib`] on macOS, it would just be weird, and probably
+/// requires something like XQuartz be used).
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum RawWindowHandle {
+    /// A raw window handle for UIKit (Apple's non-macOS windowing library).
+    ///
+    /// ## Availability Hints
+    /// This variant is likely to be used on iOS, tvOS, (in theory) watchOS, and
+    /// Mac Catalyst (`$arch-apple-ios-macabi` targets, which can notably use
+    /// UIKit *or* AppKit), as these are the targets that (currently) support
+    /// UIKit.
+    UiKit(UiKitWindowHandle),
+    /// A raw window handle for AppKit.
+    ///
+    /// ## Availability Hints
+    /// This variant is likely to be used on macOS, although Mac Catalyst
+    /// (`$arch-apple-ios-macabi` targets, which can notably use UIKit *or*
+    /// AppKit) can also use it despite being `target_os = "ios"`.
+    AppKit(AppKitWindowHandle),
+    /// A raw window handle for the Redox operating system.
+    ///
+    /// ## Availability Hints
+    /// This variant is used by the Orbital Windowing System in the Redox
+    /// operating system.
+    Orbital(OrbitalWindowHandle),
+    /// A raw window handle for Xlib.
+    ///
+    /// ## Availability Hints
+    /// This variant is likely to show up anywhere someone manages to get X11
+    /// working that Xlib can be built for, which is to say, most (but not all)
+    /// Unix systems.
+    Xlib(XlibWindowHandle),
+    /// A raw window handle for Xcb.
+    ///
+    /// ## Availability Hints
+    /// This variant is likely to show up anywhere someone manages to get X11
+    /// working that XCB can be built for, which is to say, most (but not all)
+    /// Unix systems.
+    Xcb(XcbWindowHandle),
+    /// A raw window handle for Wayland.
+    ///
+    /// ## Availability Hints
+    /// This variant should be expected anywhere Wayland works, which is
+    /// currently some subset of unix systems.
+    Wayland(WaylandWindowHandle),
+    /// A raw window handle for the Linux Kernel Mode Set/Direct Rendering Manager
+    ///
+    /// ## Availability Hints
+    /// This variant is used on Linux when neither X nor Wayland are available
+    Drm(DrmWindowHandle),
+    /// A raw window handle for the Linux Generic Buffer Manager.
+    ///
+    /// ## Availability Hints
+    /// This variant is present regardless of windowing backend and likely to be used with
+    /// EGL_MESA_platfrom_gbm or EGL_KHR_platfrom_gbm.
+    Gbm(GbmWindowHandle),
+    /// A raw window handle for Win32.
+    ///
+    /// ## Availability Hints
+    /// This variant is used on Windows systems.
+    Win32(Win32WindowHandle),
+    /// A raw window handle for WinRT.
+    ///
+    /// ## Availability Hints
+    /// This variant is used on Windows systems.
+    WinRt(WinRtWindowHandle),
+    /// A raw window handle for the Web.
+    ///
+    /// ## Availability Hints
+    /// This variant is used on Wasm or asm.js targets when targeting the Web/HTML5.
+    Web(WebWindowHandle),
+    /// A raw window handle for Android NDK.
+    ///
+    /// ## Availability Hints
+    /// This variant is used on Android targets.
+    AndroidNdk(AndroidNdkWindowHandle),
+    /// A raw window handle for Haiku.
+    ///
+    /// ## Availability Hints
+    /// This variant is used on HaikuOS.
+    Haiku(HaikuWindowHandle),
+}
+
+/// Display that wraps around a raw display handle.
+///
+/// # Safety
+///
+/// Users can safely assume that non-`null`/`0` fields are valid handles, and it is up to the
+/// implementer of this trait to ensure that condition is upheld.
+///
+/// Despite that qualification, implementers should still make a best-effort attempt to fill in all
+/// available fields. If an implementation doesn't, and a downstream user needs the field, it should
+/// try to derive the field from other fields the implementer *does* provide via whatever methods the
+/// platform provides.
+///
+/// The exact handles returned by `raw_display_handle` must remain consistent between multiple calls
+/// to `raw_display_handle` as long as not indicated otherwise by platform specific events.
+pub unsafe trait HasRawDisplayHandle {
+    fn raw_display_handle(&self) -> RawDisplayHandle;
+}
+
+unsafe impl<'a, T: HasRawDisplayHandle + ?Sized> HasRawDisplayHandle for &'a T {
+    fn raw_display_handle(&self) -> RawDisplayHandle {
+        (*self).raw_display_handle()
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+unsafe impl<T: HasRawDisplayHandle + ?Sized> HasRawDisplayHandle for alloc::rc::Rc<T> {
+    fn raw_display_handle(&self) -> RawDisplayHandle {
+        (**self).raw_display_handle()
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
+unsafe impl<T: HasRawDisplayHandle + ?Sized> HasRawDisplayHandle for alloc::sync::Arc<T> {
+    fn raw_display_handle(&self) -> RawDisplayHandle {
+        (**self).raw_display_handle()
+    }
+}
+
+/// An enum to simply combine the different possible raw display handle variants.
+///
+/// # Variant Availability
+///
+/// Note that all variants are present on all targets (none are disabled behind
+/// `#[cfg]`s), but see the "Availability Hints" section on each variant for
+/// some hints on where this variant might be expected.
+///
+/// Note that these "Availability Hints" are not normative. That is to say, a
+/// [`HasRawDisplayHandle`] implementor is completely allowed to return something
+/// unexpected. (For example, it's legal for someone to return a
+/// [`RawDisplayHandle::Xlib`] on macOS, it would just be weird, and probably
+/// requires something like XQuartz be used).
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum RawDisplayHandle {
+    /// A raw display handle for UIKit (Apple's non-macOS windowing library).
+    ///
+    /// ## Availability Hints
+    /// This variant is likely to be used on iOS, tvOS, (in theory) watchOS, and
+    /// Mac Catalyst (`$arch-apple-ios-macabi` targets, which can notably use
+    /// UIKit *or* AppKit), as these are the targets that (currently) support
+    /// UIKit.
+    UiKit(UiKitDisplayHandle),
+    /// A raw display handle for AppKit.
+    ///
+    /// ## Availability Hints
+    /// This variant is likely to be used on macOS, although Mac Catalyst
+    /// (`$arch-apple-ios-macabi` targets, which can notably use UIKit *or*
+    /// AppKit) can also use it despite being `target_os = "ios"`.
+    AppKit(AppKitDisplayHandle),
+    /// A raw display handle for the Redox operating system.
+    ///
+    /// ## Availability Hints
+    /// This variant is used by the Orbital Windowing System in the Redox
+    /// operating system.
+    Orbital(OrbitalDisplayHandle),
+    /// A raw display handle for Xlib.
+    ///
+    /// ## Availability Hints
+    /// This variant is likely to show up anywhere someone manages to get X11
+    /// working that Xlib can be built for, which is to say, most (but not all)
+    /// Unix systems.
+    Xlib(XlibDisplayHandle),
+    /// A raw display handle for Xcb.
+    ///
+    /// ## Availability Hints
+    /// This variant is likely to show up anywhere someone manages to get X11
+    /// working that XCB can be built for, which is to say, most (but not all)
+    /// Unix systems.
+    Xcb(XcbDisplayHandle),
+    /// A raw display handle for Wayland.
+    ///
+    /// ## Availability Hints
+    /// This variant should be expected anywhere Wayland works, which is
+    /// currently some subset of unix systems.
+    Wayland(WaylandDisplayHandle),
+    /// A raw display handle for the Linux Kernel Mode Set/Direct Rendering Manager
+    ///
+    /// ## Availability Hints
+    /// This variant is used on Linux when neither X nor Wayland are available
+    Drm(DrmDisplayHandle),
+    /// A raw display handle for the Linux Generic Buffer Manager.
+    ///
+    /// ## Availability Hints
+    /// This variant is present regardless of windowing backend and likely to be used with
+    /// EGL_MESA_platfrom_gbm or EGL_KHR_platfrom_gbm.
+    Gbm(GbmDisplayHandle),
+    /// A raw display handle for Win32.
+    ///
+    /// ## Availability Hints
+    /// This variant is used on Windows systems.
+    Windows(WindowsDisplayHandle),
+    /// A raw display handle for the Web.
+    ///
+    /// ## Availability Hints
+    /// This variant is used on Wasm or asm.js targets when targeting the Web/HTML5.
+    Web(WebDisplayHandle),
+    /// A raw display handle for Android NDK.
+    ///
+    /// ## Availability Hints
+    /// This variant is used on Android targets.
+    Android(AndroidDisplayHandle),
+    /// A raw display handle for Haiku.
+    ///
+    /// ## Availability Hints
+    /// This variant is used on HaikuOS.
+    Haiku(HaikuDisplayHandle),
+}
diff --git a/third_party/rust/raw-window-handle/src/redox.rs b/third_party/rust/raw-window-handle/src/redox.rs
new file mode 100644
index 0000000000..5faa98501d
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/redox.rs
@@ -0,0 +1,43 @@
+use core::ffi::c_void;
+use core::ptr;
+
+/// Raw display handle for the Redox operating system.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::OrbitalDisplayHandle;
+/// let mut display_handle = OrbitalDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct OrbitalDisplayHandle;
+
+impl OrbitalDisplayHandle {
+    pub fn empty() -> Self {
+        Self {}
+    }
+}
+
+/// Raw window handle for the Redox operating system.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::OrbitalWindowHandle;
+/// let mut window_handle = OrbitalWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct OrbitalWindowHandle {
+    /// A pointer to an orbclient window.
+    pub window: *mut c_void,
+}
+
+impl OrbitalWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            window: ptr::null_mut(),
+        }
+    }
+}
diff --git a/third_party/rust/raw-window-handle/src/uikit.rs b/third_party/rust/raw-window-handle/src/uikit.rs
new file mode 100644
index 0000000000..bee3a9a71b
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/uikit.rs
@@ -0,0 +1,49 @@
+use core::ffi::c_void;
+use core::ptr;
+
+/// Raw display handle for UIKit.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::UiKitDisplayHandle;
+/// let mut display_handle = UiKitDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct UiKitDisplayHandle;
+
+impl UiKitDisplayHandle {
+    pub fn empty() -> Self {
+        Self {}
+    }
+}
+
+/// Raw window handle for UIKit.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::UiKitWindowHandle;
+/// let mut window_handle = UiKitWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct UiKitWindowHandle {
+    /// A pointer to an `UIWindow` object.
+    pub ui_window: *mut c_void,
+    /// A pointer to an `UIView` object.
+    pub ui_view: *mut c_void,
+    /// A pointer to an `UIViewController` object.
+    pub ui_view_controller: *mut c_void,
+}
+
+impl UiKitWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            ui_window: ptr::null_mut(),
+            ui_view: ptr::null_mut(),
+            ui_view_controller: ptr::null_mut(),
+        }
+    }
+}
diff --git a/third_party/rust/raw-window-handle/src/unix.rs b/third_party/rust/raw-window-handle/src/unix.rs
new file mode 100644
index 0000000000..9035fc2563
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/unix.rs
@@ -0,0 +1,252 @@
+use core::ffi::c_void;
+use core::ptr;
+
+use cty::{c_int, c_ulong};
+
+/// Raw display handle for Xlib.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::XlibDisplayHandle;
+/// let display_handle = XlibDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XlibDisplayHandle {
+    /// A pointer to an Xlib `Display`.
+    pub display: *mut c_void,
+
+    /// An X11 screen to use with this display handle.
+    ///
+    /// Note, that X11 could have multiple screens, however
+    /// graphics APIs could work only with one screen at the time,
+    /// given that multiple screens usually reside on different GPUs.
+    pub screen: c_int,
+}
+
+/// Raw window handle for Xlib.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::XlibWindowHandle;
+/// let window_handle = XlibWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XlibWindowHandle {
+    /// An Xlib `Window`.
+    pub window: c_ulong,
+    /// An Xlib visual ID, or 0 if unknown.
+    pub visual_id: c_ulong,
+}
+
+/// Raw display handle for Xcb.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::XcbDisplayHandle;
+/// let display_handle = XcbDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XcbDisplayHandle {
+    /// A pointer to an X server `xcb_connection_t`.
+    pub connection: *mut c_void,
+
+    /// An X11 screen to use with this display handle.
+    ///
+    /// Note, that X11 could have multiple screens, however
+    /// graphics APIs could work only with one screen at the time,
+    /// given that multiple screens usually reside on different GPUs.
+    pub screen: c_int,
+}
+
+/// Raw window handle for Xcb.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::XcbWindowHandle;
+/// let window_handle = XcbWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct XcbWindowHandle {
+    /// An X11 `xcb_window_t`.
+    pub window: u32, // Based on xproto.h
+    /// An X11 `xcb_visualid_t`, or 0 if unknown.
+    pub visual_id: u32,
+}
+
+/// Raw display handle for Wayland.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::WaylandDisplayHandle;
+/// let display_handle = WaylandDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WaylandDisplayHandle {
+    /// A pointer to a `wl_display`.
+    pub display: *mut c_void,
+}
+
+/// Raw window handle for Wayland.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::WaylandWindowHandle;
+/// let window_handle = WaylandWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WaylandWindowHandle {
+    /// A pointer to a `wl_surface`.
+    pub surface: *mut c_void,
+}
+
+/// Raw display handle for the Linux Kernel Mode Set/Direct Rendering Manager.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::DrmDisplayHandle;
+/// let display_handle = DrmDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DrmDisplayHandle {
+    /// The drm file descriptor.
+    pub fd: i32,
+}
+
+/// Raw window handle for the Linux Kernel Mode Set/Direct Rendering Manager.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::DrmWindowHandle;
+/// let handle = DrmWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DrmWindowHandle {
+    /// The primary drm plane handle.
+    pub plane: u32,
+}
+
+/// Raw display handle for the Linux Generic Buffer Manager.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::GbmDisplayHandle;
+/// let display_handle = GbmDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GbmDisplayHandle {
+    /// The gbm device.
+    pub gbm_device: *mut c_void,
+}
+
+/// Raw window handle for the Linux Generic Buffer Manager.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::GbmWindowHandle;
+/// let handle = GbmWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GbmWindowHandle {
+    /// The gbm surface.
+    pub gbm_surface: *mut c_void,
+}
+
+impl XlibDisplayHandle {
+    pub fn empty() -> Self {
+        Self {
+            display: ptr::null_mut(),
+            screen: 0,
+        }
+    }
+}
+
+impl XlibWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            window: 0,
+            visual_id: 0,
+        }
+    }
+}
+
+impl XcbDisplayHandle {
+    pub fn empty() -> Self {
+        Self {
+            connection: ptr::null_mut(),
+            screen: 0,
+        }
+    }
+}
+
+impl XcbWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            window: 0,
+            visual_id: 0,
+        }
+    }
+}
+
+impl WaylandDisplayHandle {
+    pub fn empty() -> Self {
+        Self {
+            display: ptr::null_mut(),
+        }
+    }
+}
+
+impl WaylandWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            surface: ptr::null_mut(),
+        }
+    }
+}
+
+impl DrmDisplayHandle {
+    pub fn empty() -> Self {
+        Self { fd: 0 }
+    }
+}
+
+impl DrmWindowHandle {
+    pub fn empty() -> Self {
+        Self { plane: 0 }
+    }
+}
+
+impl GbmDisplayHandle {
+    pub fn empty() -> Self {
+        Self {
+            gbm_device: ptr::null_mut(),
+        }
+    }
+}
+
+impl GbmWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            gbm_surface: ptr::null_mut(),
+        }
+    }
+}
diff --git a/third_party/rust/raw-window-handle/src/web.rs b/third_party/rust/raw-window-handle/src/web.rs
new file mode 100644
index 0000000000..1e6908ffea
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/web.rs
@@ -0,0 +1,45 @@
+/// Raw display handle for the Web.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::WebDisplayHandle;
+/// let mut display_handle = WebDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WebDisplayHandle;
+
+impl WebDisplayHandle {
+    pub fn empty() -> Self {
+        Self {}
+    }
+}
+
+/// Raw window handle for the Web.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::WebWindowHandle;
+/// let mut window_handle = WebWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WebWindowHandle {
+    /// An ID value inserted into the [data attributes] of the canvas element as '`raw-handle`'.
+    ///
+    /// When accessing from JS, the attribute will automatically be called `rawHandle`.
+    ///
+    /// Each canvas created by the windowing system should be assigned their own unique ID.
+    /// 0 should be reserved for invalid / null IDs.
+    ///
+    /// [data attributes]: https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/data-*
+    pub id: u32,
+}
+
+impl WebWindowHandle {
+    pub fn empty() -> Self {
+        Self { id: 0 }
+    }
+}
diff --git a/third_party/rust/raw-window-handle/src/windows.rs b/third_party/rust/raw-window-handle/src/windows.rs
new file mode 100644
index 0000000000..32b1a88af7
--- /dev/null
+++ b/third_party/rust/raw-window-handle/src/windows.rs
@@ -0,0 +1,71 @@
+use core::ffi::c_void;
+use core::ptr;
+
+/// Raw display handle for Windows.
+///
+/// It could be used regardless of Windows window backend.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::WindowsDisplayHandle;
+/// let mut display_handle = WindowsDisplayHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WindowsDisplayHandle;
+
+impl WindowsDisplayHandle {
+    pub fn empty() -> Self {
+        Self
+    }
+}
+
+/// Raw window handle for Win32.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::Win32WindowHandle;
+/// let mut window_handle = Win32WindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct Win32WindowHandle {
+    /// A Win32 `HWND` handle.
+    pub hwnd: *mut c_void,
+    /// The `HINSTANCE` associated with this type's `HWND`.
+    pub hinstance: *mut c_void,
+}
+
+impl Win32WindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            hwnd: ptr::null_mut(),
+            hinstance: ptr::null_mut(),
+        }
+    }
+}
+
+/// Raw window handle for WinRT.
+///
+/// ## Construction
+/// ```
+/// # use raw_window_handle::WinRtWindowHandle;
+/// let mut window_handle = WinRtWindowHandle::empty();
+/// /* set fields */
+/// ```
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct WinRtWindowHandle {
+    /// A WinRT `CoreWindow` handle.
+    pub core_window: *mut c_void,
+}
+
+impl WinRtWindowHandle {
+    pub fn empty() -> Self {
+        Self {
+            core_window: ptr::null_mut(),
+        }
+    }
+}