wayland: resolve session lock crashes on unlock, sleep, and output changes

- Destroys Wayland lock surface roles synchronously prior to sending unlock_and_destroy.
- Avoids creating lock surfaces on invalid/placeholder/removed outputs to prevent early initialization failures.
- Checks and stops server-side destruction of surfaces if the compositor has already unlocked or if the target output is invalid/placeholder.
- Fixes Qt 6.6.3 compilation compatibility when QPointer uses incomplete forward-declared types.
- Reverts memory cleanup to asynchronous deleteLater() for QML safety.

Author: Luke458

changelog/next.md

@@ -4,3 +4,4 @@
 - Fixed WlSessionLockSurface.visible crashing if accessed before backing surface creation.
 - Fixed mpris players returning `rate` for `minRate` and `maxRate`.
 - Fixed missing/wrong change signals on various properties.
+- Fixed multiple session lock client crashes on sleep, wake, DPMS, and unlocking.

src/wayland/session_lock.cpp

@@ -56,9 +56,12 @@ void WlSessionLock::updateSurfaces(bool show, WlSessionLock* old) {
 	auto screens = QGuiApplication::screens();
 
 	screens.removeIf([](QScreen* screen) {
-		if (dynamic_cast<QtWaylandClient::QWaylandScreen*>(screen->handle()) == nullptr) {
+		auto* waylandScreen = dynamic_cast<QtWaylandClient::QWaylandScreen*>(screen->handle());
+		if (waylandScreen == nullptr || waylandScreen->isPlaceholder()
+		    || waylandScreen->output() == nullptr)
+		{
 			qDebug() << "Not creating lock surface for screen" << screen
-			         << "as it is not backed by a wayland screen.";
+			         << "as it is not backed by a valid wayland output.";
 
 			return true;
 		}
@@ -139,14 +142,20 @@ void WlSessionLock::realizeLockTarget(WlSessionLock* old) {
 void WlSessionLock::unlock() {
 	if (this->isLocked()) {
 		this->lockTarget = false;
-		this->manager->unlock();
 
 		for (auto* surface: this->surfaces) {
-			surface->deleteLater();
+			if (surface->ext != nullptr) {
+				surface->ext->destroySurface();
+			}
 		}
 
+		for (auto* surface: this->surfaces) {
+			surface->deleteLater();
+		}
 		this->surfaces.clear();
 
+		this->manager->unlock();
+
 		emit this->lockStateChanged();
 	}
 }
@@ -206,7 +215,12 @@ WlSessionLockSurface::WlSessionLockSurface(QObject* parent)
 }
 
 WlSessionLockSurface::~WlSessionLockSurface() {
+	if (this->ext != nullptr) {
+		this->ext->destroySurface();
+	}
+
 	if (this->window != nullptr) {
+		this->window->destroy();
 		this->window->deleteLater();
 	}
 }

src/wayland/session_lock.hpp

@@ -185,4 +185,6 @@ private slots:
 	QScreen* mScreen = nullptr;
 	QColor mColor = Qt::white;
 	LockWindowExtension* ext;
+
+	friend class WlSessionLock;
 };

src/wayland/session_lock/session_lock.cpp

@@ -4,6 +4,7 @@
 #include <qlogging.h>
 #include <qobject.h>
 #include <qwindow.h>
+#include <wayland-client.h> // NOLINT(misc-include-cleaner)
 
 #include "lock.hpp"
 #include "manager.hpp"
@@ -117,3 +118,13 @@ void LockWindowExtension::setVisible() {
 	if (this->surface == nullptr) this->immediatelyVisible = true;
 	else this->surface->setVisible();
 }
+
+void LockWindowExtension::destroySurface() {
+	if (this->surface != nullptr) {
+		auto* lockObj = qobject_cast<QSWaylandSessionLock*>(this->lock.data());
+		if (lockObj != nullptr && lockObj->active()) {
+			this->surface->destroy();
+			this->surface = nullptr;
+		}
+	}
+}

src/wayland/session_lock/session_lock.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <qobject.h>
+#include <qpointer.h>
 #include <qtclasshelpermacros.h>
 #include <qtmetamacros.h>
 #include <qwindow.h>
@@ -73,6 +74,7 @@ class LockWindowExtension: public QObject {
 	// This must be called in place of QWindow::setVisible. Calling QWindow::setVisible will result in a crash.
 	// To make a window invisible, destroy it as it cannot be recovered.
 	void setVisible();
+	void destroySurface();
 
 	static LockWindowExtension* get(QWindow* window);
 
@@ -87,7 +89,7 @@ class LockWindowExtension: public QObject {
 
 private:
 	QSWaylandSessionLockSurface* surface = nullptr;
-	QSWaylandSessionLock* lock = nullptr;
+	QPointer<QObject> lock = nullptr;
 	bool immediatelyVisible = false;
 
 	friend class QSWaylandSessionLockSurface;

src/wayland/session_lock/surface.cpp

@@ -21,7 +21,8 @@ QSWaylandSessionLockSurface::QSWaylandSessionLockSurface(QtWaylandClient::QWayla
 		qFatal() << "QSWaylandSessionLockSurface created with null LockWindowExtension";
 	}
 
-	if (this->ext->lock == nullptr) {
+	auto* lock = qobject_cast<QSWaylandSessionLock*>(this->ext->lock.data());
+	if (lock == nullptr) {
 		qFatal() << "QSWaylandSessionLock for QSWaylandSessionLockSurface died";
 	}
 
@@ -34,12 +35,39 @@ QSWaylandSessionLockSurface::QSWaylandSessionLockSurface(QtWaylandClient::QWayla
 		qFatal() << "Session lock screen does not correspond to a real screen. Force closing window";
 	}
 
-	this->init(this->ext->lock->get_lock_surface(window->waylandSurface()->object(), output));
+	this->init(lock->get_lock_surface(window->waylandSurface()->object(), output));
 }
 
 QSWaylandSessionLockSurface::~QSWaylandSessionLockSurface() {
-	if (this->ext != nullptr) this->ext->surface = nullptr;
-	this->destroy();
+	if (this->object() == nullptr) {
+		return;
+	}
+
+	bool shouldDestroyOnServer = true;
+
+	if (this->ext != nullptr) {
+		this->ext->surface = nullptr;
+		auto* lock = qobject_cast<QSWaylandSessionLock*>(this->ext->lock.data());
+		if (lock == nullptr || !lock->active()) {
+			shouldDestroyOnServer = false;
+		} else {
+			auto* qwindow = this->window() ? this->window()->window() : nullptr;
+			auto* screen = qwindow ? qwindow->screen() : nullptr;
+			auto* waylandScreen =
+			    screen ? dynamic_cast<QtWaylandClient::QWaylandScreen*>(screen->handle()) : nullptr;
+			if (waylandScreen == nullptr || waylandScreen->isPlaceholder()
+			    || waylandScreen->output() == nullptr)
+			{
+				shouldDestroyOnServer = false;
+			}
+		}
+	} else {
+		shouldDestroyOnServer = false;
+	}
+
+	if (shouldDestroyOnServer) {
+		this->destroy();
+	}
 }
 
 bool QSWaylandSessionLockSurface::isExposed() const { return this->configured; }