screencopy: Use "buffer age" of 1 for capture

The logic `age_for_buffer` used seems to be a misinterpretation of the
protocol.

The wording is a little unclear, but it seems tracking buffer age is the
responsibility of the client, and the client is required to accumulate
damage and pass it in `damage_buffer`.

Our clients initially weren't doing that correctly. I updated
xdg-desktop-portal-cosmic to use `damage_buffer` after testing on
wlroots, and cosmic-workspaces was recently updated as well.

Author: ids1024

src/backend/kms/surface/mod.rs

@@ -1345,13 +1345,6 @@ impl SurfaceThreadState {
                                 (&session, frame, res),
                                 now.into(),
                             ) {
-                                session
-                                    .user_data()
-                                    .get::<SessionData>()
-                                    .unwrap()
-                                    .lock()
-                                    .unwrap()
-                                    .reset();
                                 tracing::warn!(?err, "Failed to screencopy");
                             }
                         }
@@ -1380,14 +1373,7 @@ impl SurfaceThreadState {
                         }
                     }
                     Err(err) => {
-                        for (session, frame, _) in frames {
-                            session
-                                .user_data()
-                                .get::<SessionData>()
-                                .unwrap()
-                                .lock()
-                                .unwrap()
-                                .reset();
+                        for (_session, frame, _) in frames {
                             frame.fail(FailureReason::Unknown);
                         }
                         return Err(err).with_context(|| "Failed to submit result for display");
@@ -1613,7 +1599,7 @@ fn take_screencopy_frames(
                 // TODO re-use offscreen buffer to damage track screencopy to shm
                 0
             } else {
-                damage_tracking.age_for_buffer(&buffer)
+                1
             };
 
             if !additional_damage.is_empty() {

src/wayland/handlers/screencopy/render.rs

@@ -223,7 +223,7 @@ where
         // TODO re-use offscreen buffer to damage track screencopy to shm
         0
     } else {
-        session_damage_tracking.age_for_buffer(&buffer)
+        1
     };
     let mut fb = offscreen
         .as_mut()

src/wayland/handlers/screencopy/user_data.rs

@@ -1,10 +1,6 @@
-use std::{cell::RefCell, collections::HashMap, sync::Mutex};
+use std::{cell::RefCell, sync::Mutex};
 
-use smithay::{
-    backend::renderer::{damage::OutputDamageTracker, utils::CommitCounter},
-    output::Output,
-    reexports::wayland_server::{protocol::wl_buffer::WlBuffer, Resource, Weak},
-};
+use smithay::{backend::renderer::damage::OutputDamageTracker, output::Output};
 
 use crate::{
     shell::{CosmicSurface, Workspace},
@@ -20,36 +16,11 @@ pub type SessionData = Mutex<SessionUserData>;
 
 pub struct SessionUserData {
     pub dt: OutputDamageTracker,
-    commit_counter: CommitCounter,
-    buffer_age: HashMap<Weak<WlBuffer>, CommitCounter>,
 }
 
 impl SessionUserData {
     pub fn new(tracker: OutputDamageTracker) -> SessionUserData {
-        SessionUserData {
-            dt: tracker,
-            commit_counter: CommitCounter::default(),
-            buffer_age: HashMap::new(),
-        }
-    }
-
-    pub fn age_for_buffer(&mut self, buffer: &WlBuffer) -> usize {
-        self.buffer_age.retain(|k, _| k.upgrade().is_ok());
-
-        let weak = buffer.downgrade();
-        let age = self
-            .commit_counter
-            .distance(self.buffer_age.get(&weak).copied())
-            .unwrap_or(0);
-        self.buffer_age.insert(weak, self.commit_counter);
-
-        self.commit_counter.increment();
-        age
-    }
-
-    pub fn reset(&mut self) {
-        self.commit_counter = CommitCounter::default();
-        self.buffer_age.clear();
+        SessionUserData { dt: tracker }
     }
 }