Upgrade Smithay to pinned upstream Git

Pin 8a270232f1bfc416c781273c98a3f52a812a0bba and adapt protocol dispatch, input timestamps, configure state and rendering APIs. Preserve custom lock and toplevel validation, compositor-owned key repeats, and valid layer remapping sequences.

Add native icon-buffer lifecycle regressions for the GoLand and Spotify launch failure.

compositor/src/handlers/activation.rs

@@ -234,7 +234,11 @@ mod tests {
         use smithay::reexports::wayland_server::protocol::wl_compositor::WlCompositor;
         use smithay::wayland::shell::xdg::XdgWmBaseUserData;
         let compositor = recipient
-            .create_resource::<WlCompositor, (), Ferese>(&state.display_handle, 6, ())
+            .create_resource::<WlCompositor, smithay::wayland::GlobalData, Ferese>(
+                &state.display_handle,
+                6,
+                smithay::wayland::GlobalData,
+            )
             .unwrap();
         let shell = recipient
             .create_resource::<XdgWmBase, XdgWmBaseUserData, Ferese>(&state.display_handle, 6, Default::default())

compositor/src/handlers/dispatch.rs

@@ -0,0 +1,134 @@
+use crate::Ferese;
+use smithay::reexports::wayland_server::{
+    Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource, backend::ClientId, protocol as wl,
+};
+use smithay::reexports::{
+    wayland_protocols as protocols, wayland_protocols_misc as misc, wayland_protocols_wlr as wlr,
+};
+use smithay::wayland::{Dispatch2, GlobalDispatch2};
+
+// Forward stock protocol interfaces through Smithay's current dispatch API.
+// Keep xdg_toplevel and ext_session_lock_v1 explicit: Ferese validates their
+// requests before delegation, including ownership of the active session lock.
+macro_rules! delegate_protocols {
+    ($($interface:path),* $(,)?) => {
+        $(
+            impl<U: Dispatch2<$interface, Ferese>> Dispatch<$interface, U> for Ferese {
+                fn request(
+                    state: &mut Self,
+                    client: &Client,
+                    resource: &$interface,
+                    request: <$interface as Resource>::Request,
+                    data: &U,
+                    display: &DisplayHandle,
+                    init: &mut DataInit<'_, Self>,
+                ) {
+                    data.request(state, client, resource, request, display, init);
+                }
+
+                fn destroyed(state: &mut Self, client: ClientId, resource: &$interface, data: &U) {
+                    data.destroyed(state, client, resource);
+                }
+            }
+
+            impl<U: GlobalDispatch2<$interface, Ferese>> GlobalDispatch<$interface, U> for Ferese {
+                fn bind(
+                    state: &mut Self,
+                    display: &DisplayHandle,
+                    client: &Client,
+                    resource: New<$interface>,
+                    data: &U,
+                    init: &mut DataInit<'_, Self>,
+                ) {
+                    data.bind(state, display, client, resource, init);
+                }
+
+                fn can_view(client: Client, data: &U) -> bool {
+                    data.can_view(&client)
+                }
+            }
+        )*
+    };
+}
+
+delegate_protocols!(
+    protocols::wp::idle_inhibit::zv1::server::zwp_idle_inhibit_manager_v1::ZwpIdleInhibitManagerV1,
+    protocols::wp::idle_inhibit::zv1::server::zwp_idle_inhibitor_v1::ZwpIdleInhibitorV1,
+    protocols::ext::data_control::v1::server::ext_data_control_device_v1::ExtDataControlDeviceV1,
+    protocols::ext::data_control::v1::server::ext_data_control_manager_v1::ExtDataControlManagerV1,
+    protocols::ext::data_control::v1::server::ext_data_control_source_v1::ExtDataControlSourceV1,
+    protocols::ext::idle_notify::v1::server::ext_idle_notification_v1::ExtIdleNotificationV1,
+    protocols::ext::idle_notify::v1::server::ext_idle_notifier_v1::ExtIdleNotifierV1,
+    protocols::ext::session_lock::v1::server::ext_session_lock_manager_v1::ExtSessionLockManagerV1,
+    protocols::ext::session_lock::v1::server::ext_session_lock_surface_v1::ExtSessionLockSurfaceV1,
+    protocols::wp::alpha_modifier::v1::server::wp_alpha_modifier_surface_v1::WpAlphaModifierSurfaceV1,
+    protocols::wp::alpha_modifier::v1::server::wp_alpha_modifier_v1::WpAlphaModifierV1,
+    protocols::wp::cursor_shape::v1::server::wp_cursor_shape_device_v1::WpCursorShapeDeviceV1,
+    protocols::wp::cursor_shape::v1::server::wp_cursor_shape_manager_v1::WpCursorShapeManagerV1,
+    protocols::wp::fractional_scale::v1::server::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1,
+    protocols::wp::fractional_scale::v1::server::wp_fractional_scale_v1::WpFractionalScaleV1,
+    protocols::wp::keyboard_shortcuts_inhibit::zv1::server::zwp_keyboard_shortcuts_inhibit_manager_v1::ZwpKeyboardShortcutsInhibitManagerV1,
+    protocols::wp::keyboard_shortcuts_inhibit::zv1::server::zwp_keyboard_shortcuts_inhibitor_v1::ZwpKeyboardShortcutsInhibitorV1,
+    protocols::wp::linux_dmabuf::zv1::server::zwp_linux_buffer_params_v1::ZwpLinuxBufferParamsV1,
+    protocols::wp::linux_dmabuf::zv1::server::zwp_linux_dmabuf_feedback_v1::ZwpLinuxDmabufFeedbackV1,
+    protocols::wp::linux_dmabuf::zv1::server::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1,
+    protocols::wp::pointer_constraints::zv1::server::zwp_confined_pointer_v1::ZwpConfinedPointerV1,
+    protocols::wp::pointer_constraints::zv1::server::zwp_locked_pointer_v1::ZwpLockedPointerV1,
+    protocols::wp::pointer_constraints::zv1::server::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1,
+    protocols::wp::presentation_time::server::wp_presentation::WpPresentation,
+    protocols::wp::presentation_time::server::wp_presentation_feedback::WpPresentationFeedback,
+    protocols::wp::primary_selection::zv1::server::zwp_primary_selection_device_manager_v1::ZwpPrimarySelectionDeviceManagerV1,
+    protocols::wp::primary_selection::zv1::server::zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1,
+    protocols::wp::primary_selection::zv1::server::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1,
+    protocols::wp::relative_pointer::zv1::server::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1,
+    protocols::wp::relative_pointer::zv1::server::zwp_relative_pointer_v1::ZwpRelativePointerV1,
+    protocols::wp::security_context::v1::server::wp_security_context_manager_v1::WpSecurityContextManagerV1,
+    protocols::wp::security_context::v1::server::wp_security_context_v1::WpSecurityContextV1,
+    protocols::wp::single_pixel_buffer::v1::server::wp_single_pixel_buffer_manager_v1::WpSinglePixelBufferManagerV1,
+    protocols::wp::text_input::zv3::server::zwp_text_input_manager_v3::ZwpTextInputManagerV3,
+    protocols::wp::text_input::zv3::server::zwp_text_input_v3::ZwpTextInputV3,
+    protocols::wp::viewporter::server::wp_viewport::WpViewport,
+    protocols::wp::viewporter::server::wp_viewporter::WpViewporter,
+    protocols::xdg::activation::v1::server::xdg_activation_token_v1::XdgActivationTokenV1,
+    protocols::xdg::activation::v1::server::xdg_activation_v1::XdgActivationV1,
+    protocols::xdg::decoration::zv1::server::zxdg_decoration_manager_v1::ZxdgDecorationManagerV1,
+    protocols::xdg::decoration::zv1::server::zxdg_toplevel_decoration_v1::ZxdgToplevelDecorationV1,
+    protocols::xdg::foreign::zv2::server::zxdg_exported_v2::ZxdgExportedV2,
+    protocols::xdg::foreign::zv2::server::zxdg_exporter_v2::ZxdgExporterV2,
+    protocols::xdg::foreign::zv2::server::zxdg_imported_v2::ZxdgImportedV2,
+    protocols::xdg::foreign::zv2::server::zxdg_importer_v2::ZxdgImporterV2,
+    protocols::xdg::shell::server::xdg_popup::XdgPopup,
+    protocols::xdg::shell::server::xdg_positioner::XdgPositioner,
+    protocols::xdg::shell::server::xdg_surface::XdgSurface,
+    protocols::xdg::shell::server::xdg_wm_base::XdgWmBase,
+    protocols::xdg::toplevel_icon::v1::server::xdg_toplevel_icon_manager_v1::XdgToplevelIconManagerV1,
+    protocols::xdg::toplevel_icon::v1::server::xdg_toplevel_icon_v1::XdgToplevelIconV1,
+    protocols::xdg::xdg_output::zv1::server::zxdg_output_manager_v1::ZxdgOutputManagerV1,
+    protocols::xdg::xdg_output::zv1::server::zxdg_output_v1::ZxdgOutputV1,
+    misc::zwp_input_method_v2::server::zwp_input_method_keyboard_grab_v2::ZwpInputMethodKeyboardGrabV2,
+    misc::zwp_input_method_v2::server::zwp_input_method_manager_v2::ZwpInputMethodManagerV2,
+    misc::zwp_input_method_v2::server::zwp_input_method_v2::ZwpInputMethodV2,
+    misc::zwp_input_method_v2::server::zwp_input_popup_surface_v2::ZwpInputPopupSurfaceV2,
+    wlr::data_control::v1::server::zwlr_data_control_device_v1::ZwlrDataControlDeviceV1,
+    wlr::data_control::v1::server::zwlr_data_control_manager_v1::ZwlrDataControlManagerV1,
+    wlr::data_control::v1::server::zwlr_data_control_source_v1::ZwlrDataControlSourceV1,
+    wlr::layer_shell::v1::server::zwlr_layer_shell_v1::ZwlrLayerShellV1,
+    wlr::layer_shell::v1::server::zwlr_layer_surface_v1::ZwlrLayerSurfaceV1,
+    wl::wl_buffer::WlBuffer,
+    wl::wl_callback::WlCallback,
+    wl::wl_compositor::WlCompositor,
+    wl::wl_data_device::WlDataDevice,
+    wl::wl_data_device_manager::WlDataDeviceManager,
+    wl::wl_data_source::WlDataSource,
+    wl::wl_keyboard::WlKeyboard,
+    wl::wl_output::WlOutput,
+    wl::wl_pointer::WlPointer,
+    wl::wl_region::WlRegion,
+    wl::wl_seat::WlSeat,
+    wl::wl_shm::WlShm,
+    wl::wl_shm_pool::WlShmPool,
+    wl::wl_subcompositor::WlSubcompositor,
+    wl::wl_subsurface::WlSubsurface,
+    wl::wl_surface::WlSurface,
+    wl::wl_touch::WlTouch,
+);

compositor/src/handlers/layer_shell/output_tests.rs

@@ -19,6 +19,7 @@ fn output(state: &mut Ferese, name: &str, x: i32) -> Output {
     let output = Output::new(
         name.into(),
         PhysicalProperties {
+            serial_number: String::new(),
             size: (0, 0).into(),
             subpixel: Subpixel::Unknown,
             make: "test".into(),
@@ -78,10 +79,18 @@ impl Client {
             .insert_client(server, Arc::new(ClientState::default()))
             .unwrap();
         let compositor = client
-            .create_resource::<WlCompositor, (), Ferese>(&state.display_handle, 6, ())
+            .create_resource::<WlCompositor, smithay::wayland::GlobalData, Ferese>(
+                &state.display_handle,
+                6,
+                smithay::wayland::GlobalData,
+            )
             .unwrap();
         let shell = client
-            .create_resource::<ZwlrLayerShellV1, (), Ferese>(&state.display_handle, 4, ())
+            .create_resource::<ZwlrLayerShellV1, smithay::wayland::GlobalData, Ferese>(
+                &state.display_handle,
+                4,
+                smithay::wayland::GlobalData,
+            )
             .unwrap();
         request(&mut wire, 1, 1, &[2], None); // Registry.
         request(&mut wire, compositor.id().protocol_id(), 0, &[3], None);
@@ -281,6 +290,7 @@ fn unregistered_output_is_not_a_creation_fallback() {
     let ghost = Output::new(
         "ghost".into(),
         PhysicalProperties {
+            serial_number: String::new(),
             size: (0, 0).into(),
             subpixel: Subpixel::Unknown,
             make: "test".into(),

compositor/src/handlers/mod.rs

@@ -1,5 +1,6 @@
 pub(crate) mod activation;
 mod compositor;
+mod dispatch;
 pub(crate) mod gamma_control;
 mod input_method;
 mod layer_shell;
@@ -7,13 +8,15 @@ pub(crate) mod screencopy;
 pub(crate) mod screenshot;
 pub(crate) mod screenshot_worker;
 pub(crate) mod security_context;
+#[cfg(test)]
+mod toplevel_icon_tests;
 pub(crate) mod window_capture;
 mod xdg_shell;
 
 use smithay::desktop::{PopupManager, layer_map_for_output};
 use smithay::input::pointer::{CursorImageStatus, PointerHandle};
+use smithay::input::tablet::TabletSeatHandler;
 use smithay::input::{Seat, SeatHandler, SeatState};
-use smithay::reexports::wayland_protocols::xdg::shell::server::{xdg_popup, xdg_positioner, xdg_surface, xdg_wm_base};
 use smithay::reexports::wayland_server::Resource;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::wayland::compositor::{TraversalAction, with_states, with_surface_tree_downward};
@@ -28,15 +31,11 @@ use smithay::wayland::output::OutputHandler;
 use smithay::wayland::pointer_constraints::{PointerConstraint, PointerConstraintsHandler, with_pointer_constraint};
 use smithay::wayland::selection::SelectionHandler;
 use smithay::wayland::selection::data_device::{
-    ClientDndGrabHandler, DataDeviceHandler, DataDeviceState, ServerDndGrabHandler, set_data_device_focus,
+    DataDeviceHandler, DataDeviceState, WaylandDndGrabHandler, set_data_device_focus,
 };
 use smithay::wayland::selection::primary_selection::{
     PrimarySelectionHandler, PrimarySelectionState, set_primary_focus,
 };
-use smithay::wayland::shell::xdg::{
-    XdgPositionerUserData, XdgShellState, XdgShellSurfaceUserData, XdgSurfaceUserData, XdgWmBaseUserData,
-};
-use smithay::wayland::tablet_manager::TabletSeatHandler;
 use smithay::wayland::xdg_foreign::{XdgForeignHandler, XdgForeignState};
 use smithay::wayland::xdg_toplevel_icon::XdgToplevelIconHandler;
 
@@ -99,6 +98,7 @@ impl SeatHandler for Ferese {
 }
 
 impl OutputHandler for Ferese {}
+impl smithay::wayland::text_input::TextInputActivation for Ferese {}
 
 impl FractionalScaleHandler for Ferese {
     fn new_fractional_scale(&mut self, surface: WlSurface) {
@@ -285,31 +285,66 @@ impl SelectionHandler for Ferese {
     type SelectionUserData = ();
 }
 
-impl ClientDndGrabHandler for Ferese {}
-impl ServerDndGrabHandler for Ferese {}
-impl TabletSeatHandler for Ferese {}
+impl smithay::input::dnd::DndGrabHandler for Ferese {}
+
+impl WaylandDndGrabHandler for Ferese {
+    fn dnd_requested<S: smithay::input::dnd::Source>(
+        &mut self,
+        source: S,
+        _icon: Option<WlSurface>,
+        seat: Seat<Self>,
+        serial: smithay::utils::Serial,
+        type_: smithay::input::dnd::GrabType,
+    ) {
+        use smithay::input::dnd::{DnDGrab, GrabType};
+        match type_ {
+            GrabType::Pointer => {
+                let pointer = seat.get_pointer().expect("validated pointer drag");
+                let start = pointer.grab_start_data().expect("validated pointer grab");
+                pointer.set_grab(
+                    self,
+                    DnDGrab::new_pointer(&self.display_handle, start, source, seat),
+                    serial,
+                    smithay::input::pointer::Focus::Keep,
+                );
+            }
+            GrabType::Touch => {
+                let touch = seat.get_touch().expect("validated touch drag");
+                let start = touch.grab_start_data().expect("validated touch grab");
+                touch.set_grab(
+                    self,
+                    DnDGrab::new_touch(&self.display_handle, start, source, seat),
+                    serial,
+                );
+            }
+        }
+    }
+}
+impl TabletSeatHandler for Ferese {
+    type ToolFocus = WlSurface;
+}
 
 impl DataDeviceHandler for Ferese {
-    fn data_device_state(&self) -> &DataDeviceState {
-        &self.data_device_state
+    fn data_device_state(&mut self) -> &mut DataDeviceState {
+        &mut self.data_device_state
     }
 }
 
 impl PrimarySelectionHandler for Ferese {
-    fn primary_selection_state(&self) -> &PrimarySelectionState {
-        &self.primary_selection_state
+    fn primary_selection_state(&mut self) -> &mut PrimarySelectionState {
+        &mut self.primary_selection_state
     }
 }
 
 impl smithay::wayland::selection::wlr_data_control::DataControlHandler for Ferese {
-    fn data_control_state(&self) -> &smithay::wayland::selection::wlr_data_control::DataControlState {
-        &self.wlr_data_control_state
+    fn data_control_state(&mut self) -> &mut smithay::wayland::selection::wlr_data_control::DataControlState {
+        &mut self.wlr_data_control_state
     }
 }
 
 impl smithay::wayland::selection::ext_data_control::DataControlHandler for Ferese {
-    fn data_control_state(&self) -> &smithay::wayland::selection::ext_data_control::DataControlState {
-        &self.ext_data_control_state
+    fn data_control_state(&mut self) -> &mut smithay::wayland::selection::ext_data_control::DataControlState {
+        &mut self.ext_data_control_state
     }
 }
 
@@ -320,47 +355,3 @@ impl XdgForeignHandler for Ferese {
 }
 
 impl XdgToplevelIconHandler for Ferese {}
-
-smithay::delegate_compositor!(Ferese);
-smithay::delegate_alpha_modifier!(Ferese);
-smithay::delegate_cursor_shape!(Ferese);
-smithay::delegate_data_device!(Ferese);
-smithay::delegate_dmabuf!(Ferese);
-smithay::delegate_fractional_scale!(Ferese);
-smithay::delegate_idle_inhibit!(Ferese);
-smithay::delegate_idle_notify!(Ferese);
-smithay::delegate_input_method_manager!(Ferese);
-smithay::delegate_keyboard_shortcuts_inhibit!(Ferese);
-smithay::delegate_layer_shell!(Ferese);
-smithay::delegate_output!(Ferese);
-smithay::delegate_pointer_constraints!(Ferese);
-smithay::delegate_presentation!(Ferese);
-smithay::delegate_primary_selection!(Ferese);
-smithay::delegate_relative_pointer!(Ferese);
-smithay::delegate_seat!(Ferese);
-smithay::delegate_shm!(Ferese);
-smithay::delegate_single_pixel_buffer!(Ferese);
-smithay::delegate_text_input_manager!(Ferese);
-smithay::delegate_viewporter!(Ferese);
-smithay::delegate_xdg_activation!(Ferese);
-smithay::delegate_xdg_decoration!(Ferese);
-smithay::delegate_xdg_foreign!(Ferese);
-smithay::reexports::wayland_server::delegate_global_dispatch!(
-    Ferese: [xdg_wm_base::XdgWmBase: ()] => XdgShellState
-);
-smithay::reexports::wayland_server::delegate_dispatch!(
-    Ferese: [xdg_wm_base::XdgWmBase: XdgWmBaseUserData] => XdgShellState
-);
-smithay::reexports::wayland_server::delegate_dispatch!(
-    Ferese: [xdg_positioner::XdgPositioner: XdgPositionerUserData] => XdgShellState
-);
-smithay::reexports::wayland_server::delegate_dispatch!(
-    Ferese: [xdg_popup::XdgPopup: XdgShellSurfaceUserData] => XdgShellState
-);
-smithay::reexports::wayland_server::delegate_dispatch!(
-    Ferese: [xdg_surface::XdgSurface: XdgSurfaceUserData] => XdgShellState
-);
-smithay::delegate_xdg_toplevel_icon!(Ferese);
-
-smithay::delegate_data_control!(Ferese);
-smithay::delegate_ext_data_control!(Ferese);

compositor/src/handlers/security_context.rs

@@ -27,5 +27,3 @@ impl SecurityContextHandler for Ferese {
         }
     }
 }
-
-smithay::delegate_security_context!(Ferese);

compositor/src/handlers/toplevel_icon_tests.rs

@@ -0,0 +1,109 @@
+use std::io::{Read, Write};
+use std::os::fd::AsRawFd;
+use std::os::unix::net::UnixStream;
+use std::sync::Arc;
+
+use smithay::reexports::calloop::EventLoop;
+use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_wm_base::XdgWmBase;
+use smithay::reexports::wayland_protocols::xdg::toplevel_icon::v1::server::xdg_toplevel_icon_manager_v1::XdgToplevelIconManagerV1;
+use smithay::reexports::wayland_server::Resource;
+use smithay::reexports::wayland_server::protocol::{wl_compositor::WlCompositor, wl_shm::WlShm};
+use smithay::wayland::GlobalData;
+use smithay::wayland::shell::xdg::XdgWmBaseUserData;
+
+use crate::Ferese;
+use crate::state::{ClientState, dispatch_test_client, test_client_request as request};
+
+// Replay the native JetBrains lifecycle: assign an icon, destroy the icon
+// object, then free its SHM buffer. The next sync must still reach the client.
+fn icon_cleanup_messages(destroy_icon: bool) -> Vec<(u32, u16, Vec<u32>)> {
+    let mut events = EventLoop::try_new().unwrap();
+    let mut state = crate::startup_tests::state(&mut events);
+    let (server, mut wire) = UnixStream::pair().unwrap();
+    let client = state
+        .display_handle
+        .insert_client(server, Arc::new(ClientState::default()))
+        .unwrap();
+    let compositor = client
+        .create_resource::<WlCompositor, GlobalData, Ferese>(&state.display_handle, 6, GlobalData)
+        .unwrap();
+    let shell = client
+        .create_resource::<XdgWmBase, XdgWmBaseUserData, Ferese>(&state.display_handle, 6, Default::default())
+        .unwrap();
+    let shm = client
+        .create_resource::<WlShm, GlobalData, Ferese>(&state.display_handle, 1, GlobalData)
+        .unwrap();
+    let manager = client
+        .create_resource::<XdgToplevelIconManagerV1, GlobalData, Ferese>(&state.display_handle, 1, GlobalData)
+        .unwrap();
+    request(&mut wire, compositor.id().protocol_id(), 0, &[2], None);
+    request(&mut wire, shell.id().protocol_id(), 2, &[3, 2], None);
+    request(&mut wire, 3, 1, &[4], None);
+    let mut file = tempfile::tempfile().unwrap();
+    file.write_all(&0xff112233u32.to_ne_bytes().repeat(32 * 32)).unwrap();
+    request(
+        &mut wire,
+        shm.id().protocol_id(),
+        0,
+        &[5, 32 * 32 * 4],
+        Some(file.as_raw_fd()),
+    );
+    request(&mut wire, 5, 0, &[6, 0, 32, 32, 128, 0], None);
+    request(&mut wire, manager.id().protocol_id(), 1, &[7], None);
+    request(&mut wire, 7, 2, &[6, 1], None);
+    request(&mut wire, manager.id().protocol_id(), 2, &[4, 7], None);
+    if destroy_icon {
+        request(&mut wire, 7, 0, &[], None);
+    }
+    request(&mut wire, 6, 0, &[], None);
+    request(&mut wire, 1, 0, &[8], None);
+    dispatch_test_client(&mut events, &mut state);
+    wire.set_nonblocking(true).unwrap();
+    let mut bytes = Vec::new();
+    let _ = wire.read_to_end(&mut bytes);
+    let mut messages = Vec::new();
+    let mut offset = 0;
+    while offset < bytes.len() {
+        let object = u32::from_ne_bytes(bytes[offset..offset + 4].try_into().unwrap());
+        let header = u32::from_ne_bytes(bytes[offset + 4..offset + 8].try_into().unwrap());
+        let size = (header >> 16) as usize;
+        let arguments = bytes[offset + 8..offset + size]
+            .chunks_exact(4)
+            .map(|word| u32::from_ne_bytes(word.try_into().unwrap()))
+            .collect();
+        messages.push((object, header as u16, arguments));
+        offset += size;
+    }
+    messages
+}
+
+#[test]
+fn destroying_an_assigned_icon_before_its_buffer_keeps_the_client_connected() {
+    if !crate::startup_tests::private_runtime(
+        "handlers::toplevel_icon_tests::destroying_an_assigned_icon_before_its_buffer_keeps_the_client_connected",
+    ) {
+        return;
+    }
+    let messages = icon_cleanup_messages(true);
+    assert!(!messages.iter().any(|(object, opcode, _)| *object == 1 && *opcode == 0));
+    assert!(
+        messages.iter().any(|(object, opcode, _)| *object == 8 && *opcode == 0),
+        "valid icon cleanup disconnected the client before its sync reply: {messages:?}"
+    );
+}
+
+#[test]
+fn destroying_a_buffer_while_its_icon_is_alive_still_reports_no_buffer() {
+    if !crate::startup_tests::private_runtime(
+        "handlers::toplevel_icon_tests::destroying_a_buffer_while_its_icon_is_alive_still_reports_no_buffer",
+    ) {
+        return;
+    }
+    let messages = icon_cleanup_messages(false);
+    assert!(
+        messages.iter().any(|(object, opcode, args)| {
+            *object == 1 && *opcode == 0 && args.first() == Some(&7) && args.get(1) == Some(&3)
+        }),
+        "destroying a live icon's buffer must report the protocol error: {messages:?}"
+    );
+}

compositor/src/handlers/xdg_shell.rs

@@ -490,9 +490,7 @@ impl Dispatch<xdg_toplevel::XdgToplevel, XdgShellSurfaceUserData> for Ferese {
             return;
         }
 
-        <XdgShellState as Dispatch<xdg_toplevel::XdgToplevel, XdgShellSurfaceUserData, Ferese>>::request(
-            state, client, resource, request, data, dhandle, data_init,
-        );
+        smithay::wayland::Dispatch2::request(data, state, client, resource, request, dhandle, data_init);
     }
 
     fn destroyed(
@@ -501,9 +499,7 @@ impl Dispatch<xdg_toplevel::XdgToplevel, XdgShellSurfaceUserData> for Ferese {
         resource: &xdg_toplevel::XdgToplevel,
         data: &XdgShellSurfaceUserData,
     ) {
-        <XdgShellState as Dispatch<xdg_toplevel::XdgToplevel, XdgShellSurfaceUserData, Ferese>>::destroyed(
-            state, client, resource, data,
-        );
+        smithay::wayland::Dispatch2::destroyed(data, state, client, resource);
     }
 }