server: allow accessing resource in Dispatch::destroyed

wayland-backend/CHANGELOG.md

@@ -10,6 +10,7 @@
   needs to be dispatched using `Backend::dispatch_inner_queue()`, instead of trying to dispatch
   it by itself. This can only happen when using the `sys` backend, and allows the crate to
   behave properly when multiple threads try to read the socket using the libwayland API.
+- server: `ObjectData::destroyed` function signature has changed to pass the `Handle` and `self` as `Arc<Self>`.
 
 #### Additions
 

wayland-backend/src/rs/server_impl/common_poll.rs

@@ -74,7 +74,7 @@
     ) -> std::io::Result<usize> {
         let ret = self.dispatch_events_for(data, client_id);
         let cleanup = self.state.lock().unwrap().cleanup();
-        cleanup(data);
+        cleanup(&self.handle(), data);
         ret
     }
 
@@ -98,7 +98,7 @@
                 }
             }
             let cleanup = self.state.lock().unwrap().cleanup();
-            cleanup(data);
+            cleanup(&self.handle(), data);
         }
 
         Ok(dispatched)
@@ -137,7 +137,7 @@
                 }
             }
             let cleanup = self.state.lock().unwrap().cleanup();
-            cleanup(data);
+            cleanup(&self.handle(), data);
         }
 
         Ok(dispatched)
@@ -230,7 +230,8 @@
                         },
                     );
                     if is_destructor {
-                        object.data.user_data.destroyed(
+                        object.data.user_data.clone().destroyed(
+                            &handle.clone(),
                             data,
                             ClientId { id: client_id.clone() },
                             ObjectId { id: object_id.clone() },

wayland-backend/src/rs/server_impl/handle.rs

@@ -40,14 +40,19 @@ impl<D> State<D> {
         }
     }
 
-    pub(crate) fn cleanup(&mut self) -> impl FnOnce(&mut D) {
+    pub(crate) fn cleanup<'a>(&mut self) -> impl FnOnce(&super::Handle, &mut D) + 'a {
         let dead_clients = self.clients.cleanup(&mut self.pending_destructors);
         self.registry.cleanup(&dead_clients);
         // return a closure that will do the cleanup once invoked
         let pending_destructors = std::mem::take(&mut self.pending_destructors);
-        move |data| {
+        move |handle, data| {
             for (object_data, client_id, object_id) in pending_destructors {
-                object_data.destroyed(data, ClientId { id: client_id }, ObjectId { id: object_id });
+                object_data.clone().destroyed(
+                    handle,
+                    data,
+                    ClientId { id: client_id },
+                    ObjectId { id: object_id },
+                );
             }
         }
     }

wayland-backend/src/rs/server_impl/mod.rs

@@ -127,7 +127,7 @@ impl<D> ObjectData<D> for UninitObjectData {
     }
 
     #[cfg_attr(coverage, no_coverage)]
-    fn destroyed(&self, _: &mut D, _: ClientId, _: ObjectId) {}
+    fn destroyed(self: Arc<Self>, _: &Handle, _: &mut D, _: ClientId, _: ObjectId) {}
 
     #[cfg_attr(coverage, no_coverage)]
     fn debug(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

wayland-backend/src/server_api.rs

@@ -31,7 +31,13 @@ pub trait ObjectData<D>: downcast_rs::DowncastSync {
         msg: Message<ObjectId, OwnedFd>,
     ) -> Option<Arc<dyn ObjectData<D>>>;
     /// Notification that the object has been destroyed and is no longer active
-    fn destroyed(&self, data: &mut D, client_id: ClientId, object_id: ObjectId);
+    fn destroyed(
+        self: Arc<Self>,
+        handle: &Handle,
+        data: &mut D,
+        client_id: ClientId,
+        object_id: ObjectId,
+    );
     /// Helper for forwarding a Debug implementation of your `ObjectData` type
     ///
     /// By default will just print `ObjectData { ... }`
@@ -585,5 +591,12 @@ impl<D> ObjectData<D> for DumbObjectData {
     }
 
     #[cfg_attr(coverage, no_coverage)]
-    fn destroyed(&self, _: &mut D, _client_id: ClientId, _object_id: ObjectId) {}
+    fn destroyed(
+        self: Arc<Self>,
+        _handle: &Handle,
+        _: &mut D,
+        _client_id: ClientId,
+        _object_id: ObjectId,
+    ) {
+    }
 }

wayland-backend/src/sys/server_impl/mod.rs

@@ -413,7 +413,8 @@
         let pending_destructors =
             std::mem::take(&mut self.state.lock().unwrap().pending_destructors);
         for (object, client_id, object_id) in pending_destructors {
-            object.destroyed(data, client_id, object_id);
+            let handle = self.handle();
+            object.clone().destroyed(&handle, data, client_id, object_id);
         }
 
         if ret < 0 {
@@ -1601,10 +1602,15 @@
     let object_id =
         InnerObjectId { interface: udata.interface, ptr: resource, alive: udata.alive.clone(), id };
     if HANDLE.is_set() {
-        HANDLE.with(|&(_, data_ptr)| {
+        HANDLE.with(|&(ref state_arc, data_ptr)| {
             // Safety: the data pointer have been set by outside code and are valid
             let data = unsafe { &mut *(data_ptr as *mut D) };
-            udata.data.destroyed(data, ClientId { id: client_id }, ObjectId { id: object_id });
+            udata.data.destroyed(
+                &Handle { handle: InnerHandle { state: state_arc.clone() } },
+                data,
+                ClientId { id: client_id },
+                ObjectId { id: object_id },
+            );
         });
     } else {
         PENDING_DESTRUCTORS.with(|&pending_ptr| {
@@ -1639,7 +1645,7 @@
     }
 
     #[cfg_attr(coverage, no_coverage)]
-    fn destroyed(&self, _: &mut D, _: ClientId, _: ObjectId) {}
+    fn destroyed(self: Arc<Self>, _: &Handle, _: &mut D, _: ClientId, _: ObjectId) {}
 
     #[cfg_attr(coverage, no_coverage)]
     fn debug(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

wayland-backend/src/test/destructors.rs

@@ -24,7 +24,8 @@ macro_rules! impl_server_objectdata {
             }
 
             fn destroyed(
-                &self,
+                self: Arc<Self>,
+                _: &$server_backend::Handle,
                 _: &mut (),
                 _: $server_backend::ClientId,
                 _: $server_backend::ObjectId,

wayland-backend/src/test/many_args.rs

@@ -43,7 +43,14 @@ macro_rules! serverdata_impls {
                 None
             }
 
-            fn destroyed(&self, _: &mut (), _: $server_backend::ClientId, _: $server_backend::ObjectId) {}
+            fn destroyed(
+                self: Arc<Self>,
+                _: &$server_backend::Handle,
+                _: &mut (),
+                _: $server_backend::ClientId,
+                _: $server_backend::ObjectId
+            ) {
+            }
         }
 
         impl $server_backend::GlobalHandler<()> for ServerData {

wayland-backend/src/test/mod.rs

@@ -142,7 +142,14 @@ impl<D> server_rs::ObjectData<D> for DoNothingData {
         None
     }
 
-    fn destroyed(&self, _: &mut D, _: server_rs::ClientId, _: server_rs::ObjectId) {}
+    fn destroyed(
+        self: Arc<Self>,
+        _handle: &server_rs::Handle,
+        _: &mut D,
+        _: server_rs::ClientId,
+        _: server_rs::ObjectId,
+    ) {
+    }
 }
 
 impl<D> server_sys::ObjectData<D> for DoNothingData {
@@ -156,7 +163,14 @@ impl<D> server_sys::ObjectData<D> for DoNothingData {
         None
     }
 
-    fn destroyed(&self, _: &mut D, _: server_sys::ClientId, _: server_sys::ObjectId) {}
+    fn destroyed(
+        self: Arc<Self>,
+        _handle: &server_sys::Handle,
+        _: &mut D,
+        _: server_sys::ClientId,
+        _: server_sys::ObjectId,
+    ) {
+    }
 }
 
 // Client Object Data

wayland-backend/src/test/object_args.rs

@@ -68,7 +68,14 @@ macro_rules! impl_server_objectdata {
                 None
             }
 
-            fn destroyed(&self, _: &mut (), _: $server_backend::ClientId, _: $server_backend::ObjectId) {}
+            fn destroyed(
+                self: Arc<Self>,
+                _: &$server_backend::Handle,
+                _: &mut (),
+                _: $server_backend::ClientId,
+                _: $server_backend::ObjectId
+            ) {
+            }
         }
 
         impl $server_backend::GlobalHandler<()> for ServerData {

wayland-backend/src/test/protocol_error.rs

@@ -223,7 +223,14 @@ impl<D> server_rs::ObjectData<D> for ProtocolErrorServerData {
         None
     }
 
-    fn destroyed(&self, _: &mut D, _: server_rs::ClientId, _: server_rs::ObjectId) {}
+    fn destroyed(
+        self: Arc<Self>,
+        _handle: &server_rs::Handle,
+        _: &mut D,
+        _: server_rs::ClientId,
+        _: server_rs::ObjectId,
+    ) {
+    }
 }
 
 impl<D> server_sys::ObjectData<D> for ProtocolErrorServerData {
@@ -238,7 +245,14 @@ impl<D> server_sys::ObjectData<D> for ProtocolErrorServerData {
         None
     }
 
-    fn destroyed(&self, _: &mut D, _: server_sys::ClientId, _: server_sys::ObjectId) {}
+    fn destroyed(
+        self: Arc<Self>,
+        _handle: &server_sys::Handle,
+        _: &mut D,
+        _: server_sys::ClientId,
+        _: server_sys::ObjectId,
+    ) {
+    }
 }
 
 expand_test!(protocol_error_in_request_without_object_init, {

wayland-server/CHANGELOG.md

@@ -2,14 +2,17 @@
 
 ## Unreleased
 
-- Add `flush_clients` method to server `DisplayHandle`.
-- Implement `AsFd` for `Display` so it can easily be used in a `calloop` source.
-
 #### Breaking changes
 
 - Bump bitflags to 2.0
 - Updated wayland-backend to 0.2
 - Use `BorrowedFd<'_>` arguments instead of `RawFd`
+- `Resource::destroyed` now passes the resource type instead of the `ObjectId`.
+
+#### Additions
+
+- Add `flush_clients` method to server `DisplayHandle`.
+- Implement `AsFd` for `Display` so it can easily be used in a `calloop` source.
 
 #### Bugfixes
 

wayland-server/src/dispatch.rs

@@ -31,7 +31,7 @@
 ///
 /// To provide generic handlers for downstream usage, it is possible to make an implementation of the trait
 /// that is generic over the last type argument, as illustrated below. Users will then be able to
 /// automatically delegate their implementation to yours using the [`delegate_dispatch!`] macro.
 ///
 /// As a result, when your implementation is instanciated, the last type parameter `State` will be the state
 /// struct of the app using your generic implementation. You can put additional trait constraints on it to
@@ -111,7 +111,13 @@
     /// convenience.
     ///
     /// By default this method does nothing.
-    fn destroyed(_state: &mut State, _client: ClientId, _resource: ObjectId, _data: &UserData) {}
+    fn destroyed(
+        _state: &mut State,
+        _client: wayland_backend::server::ClientId,
+        _resource: &I,
+        _data: &UserData,
+    ) {
+    }
 }
 
 /// The [`ObjectData`] implementation that is internally used by this crate
@@ -270,12 +276,20 @@
     }
 
     fn destroyed(
-        &self,
+        self: Arc<Self>,
+        handle: &wayland_backend::server::Handle,
         data: &mut D,
-        client_id: wayland_backend::server::ClientId,
-        object_id: wayland_backend::server::ObjectId,
+        client_id: ClientId,
+        object_id: ObjectId,
     ) {
-        <D as Dispatch<I, U>>::destroyed(data, client_id, object_id, &self.udata)
+        let dhandle = DisplayHandle::from(handle.clone());
+        let mut resource = I::from_id(&dhandle, object_id).unwrap();
+
+        // Proxy::from_id will return an inert protocol object wrapper inside of ObjectData::destroyed,
+        // therefore manually initialize the data associated with protocol object wrapper.
+        resource.__set_object_data(self.clone());
+
+        <D as Dispatch<I, U>>::destroyed(data, client_id, &resource, &self.udata)
     }
 }
 
@@ -349,7 +363,7 @@
                 <$dispatch_to as $crate::Dispatch<$interface, $udata, Self>>::request(state, client, resource, request, data, dhandle, data_init)
             }
 
-            fn destroyed(state: &mut Self, client: $crate::backend::ClientId, resource: $crate::backend::ObjectId, data: &$udata) {
+            fn destroyed(state: &mut Self, client: $crate::backend::ClientId, resource: &$interface, data: &$udata) {
                 <$dispatch_to as $crate::Dispatch<$interface, $udata, Self>>::destroyed(state, client, resource, data)
             }
         }

wayland-server/src/global.rs

@@ -78,7 +78,14 @@ impl<D> ObjectData<D> for ProtocolErrorData {
         None
     }
 
-    fn destroyed(&self, _data: &mut D, _client_id: ClientId, _object_id: ObjectId) {}
+    fn destroyed(
+        self: Arc<Self>,
+        _handle: &Handle,
+        _data: &mut D,
+        _client_id: ClientId,
+        _object_id: ObjectId,
+    ) {
+    }
 }
 
 /// A trait which provides an implementation for handling advertisement of a global to clients with some type

wayland-tests/tests/destructors.rs

@@ -163,8 +163,8 @@ impl ways::Dispatch<ways::protocol::wl_output::WlOutput, ServerUData> for Server
 
     fn destroyed(
         _: &mut Self,
-        _client: wayland_backend::server::ClientId,
-        _resource: wayland_backend::server::ObjectId,
+        _: ways::backend::ClientId,
+        _resource: &ways::protocol::wl_output::WlOutput,
         data: &ServerUData,
     ) {
         data.0.store(true, Ordering::Release);