selection: instantly notify clients when source dies

Smithay uses lazy notify when there's actual interaction, which is
unexpected and doesn't properly reflect the state of the clipboard to
clipboard managers. Instead immediately notify clients when the source
was destroyed by sending `null`.

Links: YaLTeR/niri#1831

Author: kchibisov

anvil/src/state.rs

@@ -188,8 +188,8 @@ pub struct DndIcon {
 delegate_compositor!(@<BackendData: Backend + 'static> AnvilState<BackendData>);
 
 impl<BackendData: Backend> DataDeviceHandler for AnvilState<BackendData> {
-    fn data_device_state(&self) -> &DataDeviceState {
-        &self.data_device_state
+    fn data_device_state(&mut self) -> &mut DataDeviceState {
+        &mut self.data_device_state
     }
 }
 
@@ -255,15 +255,15 @@ impl<BackendData: Backend> SelectionHandler for AnvilState<BackendData> {
 }
 
 impl<BackendData: Backend> PrimarySelectionHandler for AnvilState<BackendData> {
-    fn primary_selection_state(&self) -> &PrimarySelectionState {
-        &self.primary_selection_state
+    fn primary_selection_state(&mut self) -> &mut PrimarySelectionState {
+        &mut self.primary_selection_state
     }
 }
 delegate_primary_selection!(@<BackendData: Backend + 'static> AnvilState<BackendData>);
 
 impl<BackendData: Backend> DataControlHandler for AnvilState<BackendData> {
-    fn data_control_state(&self) -> &DataControlState {
-        &self.data_control_state
+    fn data_control_state(&mut self) -> &mut DataControlState {
+        &mut self.data_control_state
     }
 }
 

examples/minimal.rs

@@ -77,8 +77,8 @@ impl SelectionHandler for App {
 }
 
 impl DataDeviceHandler for App {
-    fn data_device_state(&self) -> &DataDeviceState {
-        &self.data_device_state
+    fn data_device_state(&mut self) -> &mut DataDeviceState {
+        &mut self.data_device_state
     }
 }
 

smallvil/src/handlers/mod.rs

@@ -46,8 +46,8 @@ impl SelectionHandler for Smallvil {
 }
 
 impl DataDeviceHandler for Smallvil {
-    fn data_device_state(&self) -> &DataDeviceState {
-        &self.data_device_state
+    fn data_device_state(&mut self) -> &mut DataDeviceState {
+        &mut self.data_device_state
     }
 }
 

src/wayland/selection/data_device/device.rs

@@ -67,6 +67,22 @@ where
                 icon,
                 serial,
             } => {
+                // Each source can only be used once.
+                if let Some(source) = source.as_ref() {
+                    if handler
+                        .data_device_state()
+                        .used_sources
+                        .insert(source.clone(), data.wl_seat.clone())
+                        .is_some()
+                    {
+                        resource.post_error(
+                            wl_data_device::Error::UsedSource,
+                            "selection source can be used only once.",
+                        );
+                        return;
+                    }
+                }
+
                 let serial = Serial::from(serial);
                 if let Some(pointer) = seat.get_pointer() {
                     if pointer.has_grab(serial) {
@@ -129,6 +145,23 @@ where
                         return;
                     }
                 };
+
+                // Each source can only be used once.
+                if let Some(source) = source.as_ref() {
+                    if handler
+                        .data_device_state()
+                        .used_sources
+                        .insert(source.clone(), data.wl_seat.clone())
+                        .is_some()
+                    {
+                        resource.post_error(
+                            wl_data_device::Error::UsedSource,
+                            "selection source can be used only once.",
+                        );
+                        return;
+                    }
+                }
+
                 let source = source.map(SelectionSourceProvider::DataDevice);
 
                 handler.new_selection(

src/wayland/selection/data_device/mod.rs

@@ -60,7 +60,7 @@
 //!     type SelectionUserData = ();
 //! }
 //! impl DataDeviceHandler for State {
-//!     fn data_device_state(&self) -> &DataDeviceState { &self.data_device_state }
+//!     fn data_device_state(&mut self) -> &mut DataDeviceState { &mut self.data_device_state }
 //!     // ... override default implementations here to customize handling ...
 //! }
 //! delegate_data_device!(State);
@@ -70,6 +70,7 @@
 
 use std::{
     cell::{Ref, RefCell},
+    collections::HashMap,
     os::unix::io::OwnedFd,
 };
 
@@ -79,6 +80,7 @@ use wayland_server::{
     protocol::{
         wl_data_device_manager::{DndAction, WlDataDeviceManager},
         wl_data_source::WlDataSource,
+        wl_seat::WlSeat,
         wl_surface::WlSurface,
     },
     Client, DisplayHandle, GlobalDispatch,
@@ -113,7 +115,7 @@ use super::{
 #[allow(unused_variables)]
 pub trait DataDeviceHandler: Sized + SelectionHandler + ClientDndGrabHandler + ServerDndGrabHandler {
     /// [DataDeviceState] getter
-    fn data_device_state(&self) -> &DataDeviceState;
+    fn data_device_state(&mut self) -> &mut DataDeviceState;
 
     /// Action chooser for DnD negociation
     fn action_choice(&mut self, available: DndAction, preferred: DndAction) -> DndAction {
@@ -195,6 +197,11 @@ pub trait ServerDndGrabHandler: SeatHandler {
 #[derive(Debug)]
 pub struct DataDeviceState {
     manager_global: GlobalId,
+    /// Used sources.
+    ///
+    /// Protocol states that each source can only be used once. We
+    /// also use it during destruction to get seat data.
+    pub(crate) used_sources: HashMap<WlDataSource, WlSeat>,
 }
 
 impl DataDeviceState {
@@ -206,7 +213,10 @@ impl DataDeviceState {
     {
         let manager_global = display.create_global::<D, WlDataDeviceManager, _>(3, ());
 
-        Self { manager_global }
+        Self {
+            manager_global,
+            used_sources: Default::default(),
+        }
     }
 
     /// [WlDataDeviceManager] GlobalId getter
@@ -467,12 +477,12 @@ mod handlers {
             _resource: &WlDataDeviceManager,
             request: wl_data_device_manager::Request,
             _data: &(),
-            _dhandle: &DisplayHandle,
+            dhandle: &DisplayHandle,
             data_init: &mut wayland_server::DataInit<'_, D>,
         ) {
             match request {
                 wl_data_device_manager::Request::CreateDataSource { id } => {
-                    data_init.init(id, DataSourceUserData::new());
+                    data_init.init(id, DataSourceUserData::new(dhandle.clone()));
                 }
                 wl_data_device_manager::Request::GetDataDevice { id, seat: wl_seat } => {
                     match Seat::<D>::from_resource(&wl_seat) {

src/wayland/selection/data_device/source.rs

@@ -1,4 +1,4 @@
-use std::sync::Mutex;
+use std::{cell::RefCell, sync::Mutex};
 use tracing::error;
 
 use wayland_server::{
@@ -8,7 +8,11 @@ use wayland_server::{
     Dispatch, DisplayHandle, Resource,
 };
 
+use crate::input::Seat;
 use crate::utils::{alive_tracker::AliveTracker, IsAlive};
+use crate::wayland::selection::offer::OfferReplySource;
+use crate::wayland::selection::seat_data::SeatData;
+use crate::wayland::selection::source::SelectionSourceProvider;
 
 use super::{DataDeviceHandler, DataDeviceState};
 
@@ -35,13 +39,15 @@ impl Default for SourceMetadata {
 pub struct DataSourceUserData {
     pub(crate) inner: Mutex<SourceMetadata>,
     alive_tracker: AliveTracker,
+    display_handle: DisplayHandle,
 }
 
 impl DataSourceUserData {
-    pub(super) fn new() -> Self {
+    pub(super) fn new(display_handle: DisplayHandle) -> Self {
         Self {
             inner: Default::default(),
             alive_tracker: Default::default(),
+            display_handle,
         }
     }
 }
@@ -80,8 +86,35 @@ where
         }
     }
 
-    fn destroyed(_state: &mut D, _client: ClientId, _resource: &WlDataSource, data: &DataSourceUserData) {
+    fn destroyed(state: &mut D, _client: ClientId, source: &WlDataSource, data: &DataSourceUserData) {
         data.alive_tracker.destroy_notify();
+
+        // Remove the source from the used ones.
+        let seat = match state
+            .data_device_state()
+            .used_sources
+            .remove(source)
+            .as_ref()
+            .and_then(Seat::<D>::from_resource)
+        {
+            Some(seat) => seat,
+            None => return,
+        };
+
+        let mut seat_data = seat
+            .user_data()
+            .get::<RefCell<SeatData<D::SelectionUserData>>>()
+            .unwrap()
+            .borrow_mut();
+
+        match seat_data.get_clipboard_selection() {
+            Some(OfferReplySource::Client(SelectionSourceProvider::DataDevice(set_source)))
+                if set_source == source =>
+            {
+                seat_data.set_clipboard_selection::<D>(&data.display_handle, None)
+            }
+            _ => (),
+        }
     }
 }
 

src/wayland/selection/ext_data_control/device.rs

@@ -4,6 +4,7 @@ use wayland_protocols::ext::data_control::v1::server::ext_data_control_device_v1
     self, ExtDataControlDeviceV1,
 };
 use wayland_server::protocol::wl_seat::WlSeat;
+use wayland_server::Resource;
 use wayland_server::{Client, Dispatch, DisplayHandle};
 
 use crate::input::Seat;
@@ -44,6 +45,22 @@ where
 
         match request {
             ext_data_control_device_v1::Request::SetSelection { source, .. } => {
+                // Each source can only be used once.
+                if let Some(source) = source.as_ref() {
+                    if handler
+                        .data_control_state()
+                        .used_sources
+                        .insert(source.clone(), data.wl_seat.clone())
+                        .is_some()
+                    {
+                        resource.post_error(
+                            ext_data_control_device_v1::Error::UsedSource,
+                            "selection source can be used only once.",
+                        );
+                        return;
+                    }
+                }
+
                 seat.user_data()
                     .insert_if_missing(|| RefCell::new(SeatData::<D::SelectionUserData>::new()));
 

src/wayland/selection/ext_data_control/mod.rs

@@ -36,7 +36,7 @@
 //!     type SelectionUserData = ();
 //! }
 //! impl DataControlHandler for State {
-//!     fn data_control_state(&self) -> &DataControlState { &self.data_control_state }
+//!     fn data_control_state(&mut self) -> &mut DataControlState { &mut self.data_control_state }
 //!     // ... override default implementations here to customize handling ...
 //! }
 //! delegate_ext_data_control!(State);
@@ -47,8 +47,12 @@
 //! Be aware that data control clients rely on other selection providers to be implemneted, like
 //! wl_data_device or zwp_primary_selection.
 
+use std::collections::HashMap;
+
 use wayland_protocols::ext::data_control::v1::server::ext_data_control_manager_v1::ExtDataControlManagerV1;
+use wayland_protocols::ext::data_control::v1::server::ext_data_control_source_v1::ExtDataControlSourceV1;
 use wayland_server::backend::GlobalId;
+use wayland_server::protocol::wl_seat::WlSeat;
 use wayland_server::{Client, DisplayHandle, GlobalDispatch};
 
 mod device;
@@ -63,13 +67,18 @@ use super::SelectionHandler;
 /// Access the data control state.
 pub trait DataControlHandler: Sized + SelectionHandler {
     /// [`DataControlState`] getter.
-    fn data_control_state(&self) -> &DataControlState;
+    fn data_control_state(&mut self) -> &mut DataControlState;
 }
 
 /// State of the data control.
 #[derive(Debug)]
 pub struct DataControlState {
     manager_global: GlobalId,
+    /// Used sources.
+    ///
+    /// Protocol states that each source can only be used once. We
+    /// also use it during destruction to get seat data.
+    pub(crate) used_sources: HashMap<ExtDataControlSourceV1, WlSeat>,
 }
 
 impl DataControlState {
@@ -90,7 +99,10 @@ impl DataControlState {
             filter: Box::new(filter),
         };
         let manager_global = display.create_global::<D, ExtDataControlManagerV1, _>(1, data);
-        Self { manager_global }
+        Self {
+            manager_global,
+            used_sources: Default::default(),
+        }
     }
 
     /// [ExtDataControlManagerV1]  GlobalId getter.
@@ -188,7 +200,7 @@ mod handlers {
         ) {
             match request {
                 ext_data_control_manager_v1::Request::CreateDataSource { id } => {
-                    data_init.init(id, ExtDataControlSourceUserData::new());
+                    data_init.init(id, ExtDataControlSourceUserData::new(dh.clone()));
                 }
                 ext_data_control_manager_v1::Request::GetDataDevice { id, seat: wl_seat } => {
                     match Seat::<D>::from_resource(&wl_seat) {