wl_surface: add jay_sync_file_surface extension

src/ifs/wl_surface/commit_timeline.rs

@@ -203,18 +203,18 @@ impl CommitTimeline {
         let mut collector = CommitDataCollector {
             acquire_points: Default::default(),
             shm_uploads: 0,
-            implicit_dmabufs: Default::default(),
+            acquire_files: Default::default(),
             commit_time: Default::default(),
         };
         collector.collect(pending);
         let points = collector.acquire_points;
         let pending_uploads = collector.shm_uploads;
-        let implicit_dmabufs = collector.implicit_dmabufs;
+        let acquire_files = collector.acquire_files;
         let commit_time = collector.commit_time;
         let has_commit_time = commit_time > 0;
         let has_dependencies = points.is_not_empty()
             || pending_uploads > 0
-            || implicit_dmabufs.is_not_empty()
+            || acquire_files.is_not_empty()
             || has_commit_time;
         let must_be_queued = has_dependencies
             || self.own_timeline.entries.is_not_empty()
@@ -242,7 +242,7 @@ impl CommitTimeline {
                 wait_handles: Cell::new(Default::default()),
                 pending_uploads: NumCell::new(pending_uploads),
                 shm_upload: RefCell::new(ShmUploadState::None),
-                num_pending_polls: NumCell::new(implicit_dmabufs.len()),
+                num_pending_polls: NumCell::new(acquire_files.len()),
                 pending_polls: Cell::new(Default::default()),
                 fifo_state: Cell::new(commit_fifo_state),
                 commit_times: RefCell::new(CommitTimesState::Ready),
@@ -270,9 +270,9 @@ impl CommitTimeline {
                 *commit.shm_upload.borrow_mut() = ShmUploadState::Todo(noderef.clone());
                 needs_flush = true;
             }
-            if implicit_dmabufs.is_not_empty() {
+            if acquire_files.is_not_empty() {
                 let mut pending_polls = SmallVec::new();
-                for fd in implicit_dmabufs {
+                for fd in acquire_files {
                     let handle = self
                         .shared
                         .ring
@@ -692,7 +692,7 @@ type Point = (Rc<Syncobj>, SyncobjPoint);
 struct CommitDataCollector {
     acquire_points: SmallVec<[Point; 1]>,
     shm_uploads: usize,
-    implicit_dmabufs: SmallVec<[Rc<OwnedFd>; 1]>,
+    acquire_files: SmallVec<[Rc<OwnedFd>; 1]>,
     commit_time: u64,
 }
 
@@ -703,14 +703,18 @@ impl CommitDataCollector {
             if buffer.is_shm() {
                 self.shm_uploads += 1;
             }
-            if !pending.explicit_sync
+            if !pending.syncobj_sync
+                && pending.sync_file_acquire.is_none()
                 && let Some(dmabuf) = &buffer.client_dmabuf
             {
                 for plane in &dmabuf.planes {
-                    self.implicit_dmabufs.push(plane.fd.clone());
+                    self.acquire_files.push(plane.fd.clone());
                 }
             }
         }
+        if let Some(Some(sf)) = pending.sync_file_acquire.take() {
+            self.acquire_files.push(sf.0);
+        }
         if let Some(point) = pending.acquire_point.take() {
             self.acquire_points.push(point);
         }

src/ifs/wl_surface/jay_sync_file_release.rs

@@ -0,0 +1,92 @@
+use {
+    crate::{
+        client::{Client, ClientError},
+        gfx_api::SyncFile,
+        leaks::Tracker,
+        object::{Object, Version},
+        wire::{JaySyncFileReleaseId, jay_sync_file_release::*},
+    },
+    std::{cell::Cell, rc::Rc},
+    thiserror::Error,
+};
+
+pub struct SyncFileRelease {
+    pub release: Option<Rc<JaySyncFileRelease>>,
+}
+
+impl SyncFileRelease {
+    pub fn done(&mut self, sync_file: Option<&SyncFile>) {
+        if let Some(release) = self.release.take() {
+            release.done(sync_file);
+        }
+    }
+}
+
+impl Drop for SyncFileRelease {
+    fn drop(&mut self) {
+        self.done(None);
+    }
+}
+
+pub struct JaySyncFileRelease {
+    pub id: JaySyncFileReleaseId,
+    pub client: Rc<Client>,
+    pub tracker: Tracker<Self>,
+    pub version: Version,
+    pub destroyed: Cell<bool>,
+}
+
+impl JaySyncFileRelease {
+    pub fn new(client: &Rc<Client>, id: JaySyncFileReleaseId, version: Version) -> Self {
+        Self {
+            id,
+            client: client.clone(),
+            tracker: Default::default(),
+            version,
+            destroyed: Cell::new(false),
+        }
+    }
+
+    pub fn done(&self, sync_file: Option<&SyncFile>) {
+        if self.destroyed.get() {
+            return;
+        }
+        match sync_file {
+            None => {
+                self.client.event(ReleaseImmediate { self_id: self.id });
+            }
+            Some(fd) => {
+                self.client.event(ReleaseAsync {
+                    self_id: self.id,
+                    sync_file: fd.0.clone(),
+                });
+            }
+        }
+    }
+}
+
+impl JaySyncFileReleaseRequestHandler for JaySyncFileRelease {
+    type Error = JaySyncFileReleaseError;
+
+    fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.destroyed.set(true);
+        self.client.remove_obj(self)?;
+        Ok(())
+    }
+}
+
+object_base! {
+    self = JaySyncFileRelease;
+    version = self.version;
+}
+
+impl Object for JaySyncFileRelease {}
+
+simple_add_obj!(JaySyncFileRelease);
+
+#[derive(Debug, Error)]
+pub enum JaySyncFileReleaseError {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(JaySyncFileReleaseError, ClientError);

src/ifs/wl_surface/jay_sync_file_surface.rs

@@ -0,0 +1,92 @@
+use {
+    crate::{
+        client::{Client, ClientError},
+        gfx_api::SyncFile,
+        ifs::wl_surface::{
+            WlSurface,
+            jay_sync_file_release::{JaySyncFileRelease, SyncFileRelease},
+        },
+        leaks::Tracker,
+        object::{Object, Version},
+        wire::{JaySyncFileSurfaceId, jay_sync_file_surface::*},
+    },
+    std::rc::Rc,
+    thiserror::Error,
+};
+
+pub struct JaySyncFileSurface {
+    pub id: JaySyncFileSurfaceId,
+    pub client: Rc<Client>,
+    pub surface: Rc<WlSurface>,
+    pub tracker: Tracker<Self>,
+    pub version: Version,
+}
+
+impl JaySyncFileSurface {
+    pub fn new(id: JaySyncFileSurfaceId, version: Version, surface: &Rc<WlSurface>) -> Self {
+        Self {
+            id,
+            client: surface.client.clone(),
+            surface: surface.clone(),
+            tracker: Default::default(),
+            version,
+        }
+    }
+}
+
+impl JaySyncFileSurfaceRequestHandler for JaySyncFileSurface {
+    type Error = JaySyncFileSurfaceError;
+
+    fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.client.remove_obj(self)?;
+        Ok(())
+    }
+
+    fn set_acquire_immediate(
+        &self,
+        _req: SetAcquireImmediate,
+        _slf: &Rc<Self>,
+    ) -> Result<(), Self::Error> {
+        self.surface.pending.borrow_mut().sync_file_acquire = Some(None);
+        Ok(())
+    }
+
+    fn set_acquire_async(&self, req: SetAcquireAsync, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.surface.pending.borrow_mut().sync_file_acquire = Some(Some(SyncFile(req.sync_file)));
+        Ok(())
+    }
+
+    fn get_release(&self, req: GetRelease, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        let obj = Rc::new(JaySyncFileRelease::new(
+            &self.client,
+            req.release,
+            self.version,
+        ));
+        track!(self.client, obj);
+        self.client.add_client_obj(&obj)?;
+        let pending = &mut *self.surface.pending.borrow_mut();
+        if pending.sync_file_release.is_some() {
+            return Err(JaySyncFileSurfaceError::HasRelease);
+        }
+        pending.sync_file_release = Some(SyncFileRelease { release: Some(obj) });
+        Ok(())
+    }
+}
+
+object_base! {
+    self = JaySyncFileSurface;
+    version = self.version;
+}
+
+impl Object for JaySyncFileSurface {}
+
+simple_add_obj!(JaySyncFileSurface);
+
+#[derive(Debug, Error)]
+pub enum JaySyncFileSurfaceError {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("The content update already has a release object")]
+    HasRelease,
+}
+efrom!(JaySyncFileSurfaceError, ClientError);