From 001b5a8be1c82ad34fe97496307d2ba30f712fd1 Mon Sep 17 00:00:00 2001 From: Wisbendji Fimerlus Date: Sat, 14 Nov 2026 02:43:48 -0500 Subject: [PATCH] Complete a requested restore after its provider retires An explicit restore whose provider retired before the client answered it was never placed or completed. The placement script's teardown asks for the master's restore and releases the tree; then KWin destroys the script, and with it the writer's provider. When the client's answer arrived the restoration was no longer current: configurePlacementPolicy gave ContentOnly, so the window took its floating size at the tile's position, and completeTransientRestoration refused, so the record stayed Restoring until the window closed. A new provider could neither settle it nor admit the window again (plasma-fusion#174). The provider decides whether a restore starts. Once its request has returned, the target is the record's own floating frame, the configure is the client's to answer, and the writer keeps the restoring reservation through the retirement. requestTransientRestore now marks the attempt (requestReturned) at its success exit, after its own last check, and a provider that is not current refuses only an attempt without that mark. A retirement while the request is being made, its last check included, still supersedes it; writer loss, a newer manual action, close, context changes and the attempt's own state check stop it as before. The writer null check moves in front: the provider check no longer covers it. Tests: - testRestoreCompletion: the provider retires after the request returned, with the controller gone (row 8), with a replacement provider registered (row 9), and for the configure-less shape whose next plain commit completes it (row 10). Each completes: A placed, the record and the reservation cleared. While in flight a settle answers NotReleased, not StaleProvider, and the floating frame is A. - testTransientConfigurePlacement: row 10 (provider-retired-before-commit) expected the old rule, the configure unplaced and the record kept; it now expects A placed and the record completed, as rows 5, 6, 7 and 11. After a retirement, a manual resize (row 27) or move (row 28), or a minimum size that no longer admits A with no request at all (row 29), still leaves the configure unplaced and the record kept. - testTransientTilingFacadeRestoreAfterProviderRetired: #174 through the scripting facade, as the script's teardown runs it (restoreWindow, releaseTile, the provider destroyed, a new one registered): before the client answers, the new provider's admission is busy; after, the window is on A, the record is gone, and the new provider tiles it again. Rows 8, 9 and 10 of testRestoreCompletion, row 10 of testTransientConfigurePlacement and the facade test fail without the change. The rows that retire the provider during the request (provider-first-callback, provider-final-callback) and the other provider-retirement rows pass unchanged. Mutations, each run against the whole testXdgShellWindow binary: the old rule, no provider check for restores at all, the mark never set and no writer null check each fail rows or crash. A check that, once marked, skips the rest of the rule fails row 29 (its settle answer). Two are equivalent: the mark set in the scope guard before the post-request check (nothing can call back in between), and the exception also granted during the dispatch (the post-request check still applies the strict rule, before the mark). Signed-off-by: Wisbendji Fimerlus --- autotests/integration/xdgshellwindow_test.cpp | 188 +++++++++++++++++- src/window.cpp | 20 +- src/window.h | 4 + 3 files changed, 200 insertions(+), 12 deletions(-) diff --git a/autotests/integration/xdgshellwindow_test.cpp b/autotests/integration/xdgshellwindow_test.cpp index 5697bf0615..95b4b8b0cd 100644 --- a/autotests/integration/xdgshellwindow_test.cpp +++ b/autotests/integration/xdgshellwindow_test.cpp @@ -402,6 +402,7 @@ private Q_SLOTS: void testTransientTilingFacadeFractionalScale(); void testTransientTilingFacadeClosedSibling(); void testTransientTilingFacadeMasterClosed(); + void testTransientTilingFacadeRestoreAfterProviderRetired(); void testTransientTilingFacadeScales_data(); void testTransientTilingFacadeScales(); void testTransientTilingFacadeBordersChangeWhenTiled(); @@ -8042,6 +8043,9 @@ void TestXdgShellWindow::testRestoreCompletion_data() QTest::newRow("published-position-only-completes") << 5; QTest::newRow("completes-after-controller-destroyed") << 6; QTest::newRow("key-released-for-second-window") << 7; + QTest::newRow("completes-after-provider-retired") << 8; + QTest::newRow("completes-after-provider-replaced") << 9; + QTest::newRow("published-completes-after-provider-retired") << 10; } void TestXdgShellWindow::testRestoreCompletion() @@ -8051,7 +8055,7 @@ void TestXdgShellWindow::testRestoreCompletion() // restoring reservation completes. A superseded configure's late acknowledgement, a // cancelled attempt's configure, or no acknowledgement at all never completes anything. QFETCH(int, scenario); - const bool positionOnly = scenario == 5; + const bool positionOnly = scenario == 5 || scenario == 10; std::unique_ptr surface(Test::createSurface()); std::unique_ptr shell(Test::createXdgToplevelSurface(surface.get())); shell->set_app_id(QStringLiteral("org.example.restore-completion")); @@ -8067,8 +8071,8 @@ void TestXdgShellWindow::testRestoreCompletion() QTemporaryDir directory; QVERIFY(directory.isValid()); TransientPlacementWriter writer(directory.filePath(QStringLiteral("placementrc"))); - QObject provider; - const auto token = writer.registerProvider(&provider); + auto provider = std::make_unique(); + const auto token = writer.registerProvider(provider.get()); const auto id = window->internalId(); const auto key = QStringLiteral("org.example.restore-completion"); QVERIFY(writer.trackWindow(id, key)); @@ -8114,6 +8118,17 @@ void TestXdgShellWindow::testRestoreCompletion() QVERIFY(window->m_transientOwnership->restoreAttempt); QVERIFY(window->m_transientOwnership->restoreAttempt->publishedWithoutConfigure); QVERIFY(writer.isReserved(id)); + if (scenario == 10) { + // Row 8's retirement for the configure-less shape: the provider goes between the + // synchronous publication and the client's plain commit, which still completes it. + QVERIFY(window->m_transientOwnership->restoreAttempt->requestReturned); + controller.reset(); + provider.reset(); + QCoreApplication::processEvents(); // the writer's queued providerRetired + QVERIFY(!writer.isProviderRegistered(token)); + QCOMPARE(window->settleReleasedTransientOwnership(token), Window::TransientSettleResult::NotReleased); + QCOMPARE(QRectF(window->transientFloatingFrame()), QRectF(floating)); + } Test::render(surface.get(), managed.size().toSize(), Qt::green); QVERIFY(Test::waylandSync()); QVERIFY(!window->m_transientOwnership); @@ -8146,6 +8161,37 @@ void TestXdgShellWindow::testRestoreCompletion() // placement key for the next window of the same app. controller.reset(); } + std::unique_ptr replacement; + if (scenario == 8 || scenario == 9) { + // The policy that asked for the restore goes before the client answers it, as the + // placement script does when it is unloaded during a session (its teardown ends the + // session with the restore and the tree's release, then the script and with it the + // provider are destroyed; plasma-fusion#174). The request was made and returned while + // the provider was current: the restoration is the client's to answer, its target is + // the record's own floating frame, and the writer keeps the restoring reservation. + // It completes as any other: the floating frame with its position, the record and the + // reservation cleared. A replacement provider (a reloaded script) changes nothing. + QCOMPARE(window->m_transientOwnership->restoreAttempt->stage, Window::TransientRestoreStage::Returned); + QVERIFY(window->m_transientOwnership->restoreAttempt->requestReturned); + controller.reset(); + provider.reset(); + QCoreApplication::processEvents(); // the writer's queued providerRetired + QVERIFY(!writer.isProviderRegistered(token)); + QUuid replacementToken; + if (scenario == 9) { + replacement = std::make_unique(); + replacementToken = writer.registerProvider(replacement.get()); + QVERIFY(!replacementToken.isNull()); + } + QVERIFY(writer.isReserved(id)); + // The restoration is still live: a settle is refused as such (not as a stale provider), + // and the record's floating frame is the restoration's exact target. + QCOMPARE(window->settleReleasedTransientOwnership(token), Window::TransientSettleResult::NotReleased); + if (scenario == 9) { + QCOMPARE(window->settleReleasedTransientOwnership(replacementToken), Window::TransientSettleResult::NotReleased); + } + QCOMPARE(QRectF(window->transientFloatingFrame()), original); + } if (scenario == 2) { // An older configure (the admission tile configure's serial is long consumed; use the // maximize configure replayed through the event list as rows 16/37 do) acknowledged and @@ -8173,7 +8219,7 @@ void TestXdgShellWindow::testRestoreCompletion() shell->xdgSurface()->ack_configure(restoreSerial); Test::render(surface.get(), original.size().toSize(), Qt::green); QVERIFY(Test::waylandSync()); - if (scenario == 0 || scenario == 4 || scenario == 6 || scenario == 7) { + if (scenario == 0 || scenario == 4 || scenario == 6 || scenario == 7 || scenario == 8 || scenario == 9) { // The qualifying commit completed the restoration: the record cleared and the writer's // restoring reservation completed with it. QVERIFY(!window->m_transientOwnership); @@ -11321,6 +11367,99 @@ void TestXdgShellWindow::testTransientTilingFacadeMasterClosed() QCOMPARE(facade.generation(), 0); } +void TestXdgShellWindow::testTransientTilingFacadeRestoreAfterProviderRetired() +{ + // plasma-fusion#174 through the facade, as the placement script's teardown goes: the + // master's explicit restore and the tree's release, then the script and with it its + // provider are destroyed, and a reloaded script registers a new one - all before the client + // answers the restore. The answer lands the window on its floating frame and completes the + // record, so the new provider can tile the window again. Before, the window kept the tile's + // position with the floating size and every admission answered busy until it closed. + const TilingFacade facade; + QVERIFY(facade.api); + QVERIFY(!facade.hasTree()); + const auto releaseTree = qScopeGuard([&]() { + if (facade.hasTree()) { + facade.releaseTile(facade.generation()); + } + }); + const QString key = QStringLiteral("org.example.facade.retired"); + std::unique_ptr surface(Test::createSurface()); + std::unique_ptr shell(Test::createXdgToplevelSurface(surface.get())); + shell->set_app_id(key); + QSignalSpy configure(shell->xdgSurface(), &Test::XdgSurface::configureRequested); + QSignalSpy toplevelConfigure(shell.get(), &Test::XdgToplevel::configureRequested); + Window *window = Test::renderAndWaitForShown(surface.get(), QSize(200, 100), Qt::red); + QVERIFY(window); + QVERIFY(!configure.isEmpty() || configure.wait()); + shell->xdgSurface()->ack_configure(configure.last().at(0).toUInt()); + configure.clear(); + Test::render(surface.get(), QSize(200, 100), Qt::red); + QVERIFY(Test::waylandSync()); + const QRectF floating = window->frameGeometry(); + auto provider = std::make_unique(); + const QString token = facade.registerProvider(provider.get()); + QVERIFY(!token.isEmpty()); + QVERIFY(facade.trackWindow(window)); + QCOMPARE(facade.record(token, 1, window, scriptRecord(floating), 1), int(TransientPlacementWriter::Result::Accepted)); + auto output = window->moveResizeOutput(); + auto desktop = VirtualDesktopManager::self()->currentDesktop(output); + const QVariantMap tree = facade.createTile(output, desktop, QRectF(0, 0, 0.5, 1)); + QCOMPARE(tree.value(QStringLiteral("result")).toInt(), int(TransientTileController::Result::Accepted)); + const int generation = tree.value(QStringLiteral("generation")).toInt(); + QCOMPARE(facade.admitTile(generation, window, token), int(TransientTileController::Result::Accepted)); + QVERIFY(!configure.isEmpty() || configure.wait()); + shell->xdgSurface()->ack_configure(configure.last().at(0).toUInt()); + configure.clear(); + Test::render(surface.get(), toplevelConfigure.last().at(0).value(), Qt::blue); + QVERIFY(Test::waylandSync()); + QVERIFY(window->tile()); + QVERIFY(QRectF(window->frameGeometry()) != floating); + + // The script's teardown: the restore, then at once the tree's release (with the event loop + // run in between, the facade would end the vacated tree itself, queued). + QVERIFY(facade.restoreWindow(window)); + QCOMPARE(facade.releaseTile(generation), int(TransientTileController::Result::Accepted)); + QVERIFY(!facade.hasTree()); + QVERIFY(!configure.isEmpty() || configure.wait()); + const quint32 restoreSerial = configure.last().at(0).toUInt(); + const QSize restoreSize = toplevelConfigure.last().at(0).value(); + // The script goes, and a reloaded one registers. + provider.reset(); + QCoreApplication::processEvents(); // the writer's queued providerRetired + QObject replacement; + const QString replacementToken = facade.registerProvider(&replacement); + QVERIFY(!replacementToken.isEmpty()); + QVERIFY(replacementToken != token); + // Still in flight: the restoration holds the record, so a settle answers that it is not + // released, and the new provider cannot take the window over. + QCOMPARE(facade.settleWindow(window, replacementToken), int(Window::TransientSettleResult::NotReleased)); + QCOMPARE(facade.floatingFrame(window), floating); + const QVariantMap early = facade.createTile(output, desktop, QRectF(0, 0, 0.5, 1)); + QCOMPARE(early.value(QStringLiteral("result")).toInt(), int(TransientTileController::Result::Accepted)); + QCOMPARE(facade.admitTile(early.value(QStringLiteral("generation")).toInt(), window, replacementToken), int(TransientTileController::Result::Busy)); + QCOMPARE(facade.releaseTile(early.value(QStringLiteral("generation")).toInt()), int(TransientTileController::Result::Accepted)); + + // The client answers the restore. + shell->xdgSurface()->ack_configure(restoreSerial); + Test::render(surface.get(), restoreSize, Qt::green); + QVERIFY(Test::waylandSync()); + QCOMPARE(QRectF(window->frameGeometry()), floating); + QVERIFY(!window->m_transientOwnership); + QCOMPARE(facade.floatingFrame(window), QRectF()); + + // The new provider tiles the window again. + configure.clear(); + const QVariantMap again = facade.createTile(output, desktop, QRectF(0, 0, 0.5, 1)); + QCOMPARE(again.value(QStringLiteral("result")).toInt(), int(TransientTileController::Result::Accepted)); + QCOMPARE(facade.admitTile(again.value(QStringLiteral("generation")).toInt(), window, replacementToken), int(TransientTileController::Result::Accepted)); + QVERIFY(!configure.isEmpty() || configure.wait()); + shell->xdgSurface()->ack_configure(configure.last().at(0).toUInt()); + Test::render(surface.get(), toplevelConfigure.last().at(0).value(), Qt::blue); + QVERIFY(Test::waylandSync()); + QVERIFY(window->tile()); +} + void TestXdgShellWindow::testTransientTilingFacadeKeyConflict() { // A second window of the master's app: the provider tracks it, the key conflicts and the @@ -15076,6 +15215,9 @@ void TestXdgShellWindow::testTransientConfigurePlacement_data() QTest::newRow("ambiguous-ack-content-lineage") << 24; QTest::newRow("wrapped-admission-before-new-request") << 25; QTest::newRow("wrapped-restore-before-new-request") << 26; + QTest::newRow("manual-resize-after-provider-retired") << 27; + QTest::newRow("manual-move-after-provider-retired") << 28; + QTest::newRow("infeasible-after-provider-retired") << 29; } void TestXdgShellWindow::testTransientConfigurePlacement() @@ -15174,7 +15316,27 @@ void TestXdgShellWindow::testTransientConfigurePlacement() } const RectF manual(90, 120, 300, 200); std::unique_ptr heldOwnership; - if (scenario == 2 || scenario == 8 || scenario == 9 || scenario == 25 || scenario == 26) { + if (scenario == 27 || scenario == 28 || scenario == 29) { + // Row 10's retirement, then what still stops the restoration with the provider gone: a + // newer manual resize (as row 2) or move (as row 3), or a state that no longer admits A + // with no request at all - the client's minimum size grown past A's width, which only + // the attempt's own state check sees. The configure is not placed and the record stays. + provider.reset(); + QCoreApplication::processEvents(); // the writer's queued providerRetired + QVERIFY(!writer.isProviderRegistered(token)); + QVERIFY(window->m_transientOwnership->restoreAttempt->requestReturned); + } + if (scenario == 29) { + shell->set_min_size(int(original.width()) + 100, 0); + surface->commit(KWayland::Client::Surface::CommitFlag::None); + QVERIFY(Test::waylandSync()); + QVERIFY(window->minSize().width() > original.width()); + QVERIFY(!window->m_transientOwnership->restoreAttempt->cancelled); + // Not current any more by the attempt's own state check alone, which the exception does + // not skip: a settle finds no live restoration and answers as to a stale provider. + QCOMPARE(window->settleReleasedTransientOwnership(token), Window::TransientSettleResult::StaleProvider); + } + if (scenario == 2 || scenario == 8 || scenario == 9 || scenario == 25 || scenario == 26 || scenario == 27) { configure.clear(); window->moveResize(manual); QVERIFY(!configure.isEmpty() || configure.wait()); @@ -15187,9 +15349,15 @@ void TestXdgShellWindow::testTransientConfigurePlacement() if (scenario == 8 || scenario == 9) { serial = configure.last().at(0).value(); } - } else if (scenario == 3) { + } else if (scenario == 3 || scenario == 28) { window->move(manual.topLeft()); } else if (scenario == 10) { + // The provider goes after its restoration's request returned and before the client + // answers it (the placement script unloaded during a session, plasma-fusion#174). The + // restoration stays current: its configure places A and completes the record, as row + // 11's does after the tree is gone. A retirement while the request is being made still + // supersedes it (testTransientRestoreRequest, provider-first-callback and + // provider-final-callback). provider.reset(); } else if (scenario == 11) { delete root.data(); @@ -15214,7 +15382,7 @@ void TestXdgShellWindow::testTransientConfigurePlacement() } else if (scenario == 24) { xdg->m_configureEvents.append(new XdgToplevelConfigure(*static_cast(xdg->m_configureEvents.last()))); } - if (scenario == 2 || scenario == 3 || scenario == 8 || scenario == 9 || scenario == 25 || scenario == 26) { + if (scenario == 2 || scenario == 3 || scenario == 8 || scenario == 9 || scenario == 25 || scenario == 26 || scenario == 27 || scenario == 28) { QCOMPARE(window->m_geometryRequestOrigin.kind, Window::GeometryRequestOrigin::Kind::Ordinary); } Window::GeometryRequestOrigin expectedContentOrigin; @@ -15247,7 +15415,7 @@ void TestXdgShellWindow::testTransientConfigurePlacement() if (scenario == 5) { content += QSize(20, 10); } - if (scenario == 5 || scenario == 6 || scenario == 7 || scenario == 11) { + if (scenario == 5 || scenario == 6 || scenario == 7 || scenario == 10 || scenario == 11) { expectedOrigin = original.topLeft(); } else if (scenario == 8 || scenario == 9) { content = manual.size().toSize() + QSize(20, 10); @@ -15377,12 +15545,12 @@ void TestXdgShellWindow::testTransientConfigurePlacement() if (scenario == 23) { window->finishInteractiveMoveResize(false); } - // Rows 5, 6, 7 and 11 commit the current restoration's own configure with placement + // Rows 5, 6, 7, 10 and 11 commit the current restoration's own configure with placement // authority at the shared block, and rows 1 and 13 publish configure-less restorations // whose client's next commit settles them: both boundaries complete the restoration and // clear the record with its reservation (testRestoreCompletion owns the contracts). Every // other row - including row 16's later in-flight claim - keeps the pending record below. - const bool completed = scenario == 1 || scenario == 5 || scenario == 6 || scenario == 7 || scenario == 11 || scenario == 13; + const bool completed = scenario == 1 || scenario == 5 || scenario == 6 || scenario == 7 || scenario == 10 || scenario == 11 || scenario == 13; QCOMPARE(bool(window->m_transientOwnership), !completed); if (!completed) { QCOMPARE(window->m_transientOwnership->generation, owner); diff --git a/src/window.cpp b/src/window.cpp index a5ea542cce..24c4e45ed1 100644 --- a/src/window.cpp +++ b/src/window.cpp @@ -5208,8 +5208,19 @@ bool Window::transientRestoreAttemptIsCurrent(quint64 generation, quint64 sequen || ownership.progress != TransientRequestProgress::Requested || m_requestedTile || m_tile || m_requestedTransientTileGeneration) { return false; } - if (!transientProviderIsCurrent(ownership) - || !ownership.writer->ownsRestoringReservation(internalId(), QString::number(generation))) { + if (!ownership.writer || !ownership.writer->ownsRestoringReservation(internalId(), QString::number(generation))) { + return false; + } + // A retired provider's authority ends with it, except over a restoration whose request it + // already made: once that request returned current (requestReturned), the configure is the + // client's to answer, its target is the record's own floating frame and nothing the + // provider supplies, and the writer keeps the restoring reservation through the retirement. + // Its answer is placed and completes the record as any other's. Without this, a policy that + // ends its session and goes at once (the placement script unloaded during a tiling session, + // plasma-fusion#174) leaves the window at the tile's position with its floating size, and + // its record restoring until it closes. A retirement while the request is being made, its + // own last check included, still supersedes it; every other rule here still applies. + if (!transientProviderIsCurrent(ownership) && !attempt.requestReturned) { return false; } // Bind this Window's membership, not global desktop/activity navigation. The detached tree @@ -5558,6 +5569,11 @@ Window::AssignmentGeometryRequest Window::requestTransientRestore(TransientResto // client's next plain commit settles the landed frame and is that shape's boundary. m_transientOwnership->restoreAttempt->publishedWithoutConfigure = true; } + if (m_transientOwnership && m_transientOwnership->generation == generation && m_transientOwnership->restoreAttempt + && m_transientOwnership->restoreAttempt->sequence == sequence) { + // Current after the check above, which ran with the provider still deciding. + m_transientOwnership->restoreAttempt->requestReturned = true; + } return request; } diff --git a/src/window.h b/src/window.h index e0b8145b2c..ac2c8e6094 100644 --- a/src/window.h +++ b/src/window.h @@ -2168,6 +2168,10 @@ protected Q_SLOTS: const bool normalizeFullScreen; // A configure-less (published) restoration waits for the client's next plain commit. bool publishedWithoutConfigure = false; + // The request returned current: set at requestTransientRestore's success exit, after its + // last check. From then on the restoration is the client's to answer, and a provider + // that retires no longer supersedes it (transientRestoreAttemptIsCurrent). + bool requestReturned = false; // Backend state only: captured values, no record/stack references or retained Window. std::function stateIsCurrent; bool cancelled = false;