--- a/src/handlers/session_lock.rs +++ b/src/handlers/session_lock.rs @@ -117,9 +117,11 @@ impl Fht { pub fn is_locked(&self) -> bool { + // Fail closed: as soon as a lock is requested, session contents and input must be hidden, + // even if the lock client is slow (or never) providing surfaces. matches!( &self.lock_state, - LockState::Locked(_) | LockState::Locking(_) + LockState::Locked(_) | LockState::Locking(_) | LockState::WaitingForSurfaces(_) ) } @@ -130,8 +132,11 @@ let has_surfaces = self .output_state - .values() - .all(|state| state.lock_surface.is_some()); + .iter() + // State of disconnected outputs is never removed, and they will never get a lock + // surface, so only wait for outputs that still exist. + .filter(|(output, _)| self.space.outputs().any(|o| o == *output)) + .all(|(_, state)| state.lock_surface.is_some()); if !has_surfaces { trace!("not locking session, waiting for other lock surfaces"); // still didn't map everything. @@ -161,6 +166,14 @@ return; } + // Black while the lock client is still mapping its surfaces, red once locked, where it + // can only be seen if a lock surface is missing (the lock client died, new output, etc). + let backdrop_color = if matches!(self.lock_state, LockState::Locked(_)) { + [1., 0., 0., 1.] + } else { + [0., 0., 0., 1.] + }; + let output_state = self.output_state.get_mut(output).unwrap(); // Inform that we finally rendered this output with its designated lock surface. output_state.rendered_with_lock = true; @@ -176,6 +189,21 @@ &mut |e| push(e.into()), ); } + + // Always cover the output, so nothing leaks when there's no lock surface (yet), for + // example on a newly connected output or if the lock client died. + output_state + .lock_backdrop + .update(output.geometry().size, backdrop_color); + push(SessionLockRenderElement::ClearBackdrop( + SolidColorRenderElement::from_buffer( + &output_state.lock_backdrop, + Point::default(), + scale, + 1.0, + Kind::Unspecified, + ), + )); } } --- a/src/output.rs +++ b/src/output.rs @@ -1,4 +1,5 @@ use smithay::backend::renderer::damage::OutputDamageTracker; +use smithay::backend::renderer::element::solid::SolidColorBuffer; use smithay::output::Output; use smithay::reexports::calloop::RegistrationToken; use smithay::wayland::session_lock::LockSurface; @@ -57,6 +58,8 @@ pub lock_surface: Option, /// Whether the output rendered a frame with the [`lock_surface`] yet. pub rendered_with_lock: bool, + /// Backdrop drawn below the [`lock_surface`], covering the output while locked. + pub lock_backdrop: SolidColorBuffer, } /// A state machine to describe where an [`Output`](smithay::output::Output) in the redraw loop. --- a/src/renderer/mod.rs +++ b/src/renderer/mod.rs @@ -205,6 +205,8 @@ self.render_session_lock(renderer, output, &mut |e| { push(FhtRenderElement::SessionLock(e)) }); + // The lock covers everything, don't even render session contents below it. + return rv; } let layer_map = layer_map_for_output(output); --- a/src/state.rs +++ b/src/state.rs @@ -268,8 +268,10 @@ let all_locked = self .fht .output_state - .values() - .all(|state| state.rendered_with_lock); + .iter() + // Disconnected outputs will never render again, ignore them. + .filter(|(output, _)| self.fht.space.outputs().any(|o| o == *output)) + .all(|(_, state)| state.rendered_with_lock); if all_locked { // All outputs are locked, report success. @@ -1072,6 +1074,7 @@ lock_surface: None, // If we are already locked, the first frame should have the lock surface. rendered_with_lock: self.is_locked(), + lock_backdrop: smithay::backend::renderer::element::solid::SolidColorBuffer::new(output.geometry().size, [0., 0., 0., 1.]), }; self.output_state.insert(output.clone(), state); @@ -1107,6 +1110,10 @@ for layer in layer_map_for_output(output).layers() { layer.layer_surface().send_close() } + + // A pending session lock might have only been waiting on this output. + self.try_continue_locking(); + self.queue_redraw_all(); } pub fn focus_output(&mut self, output: &Output) {