user/qt5: Update to 5.15.4

This includes KDE LTS patches when available.

2 files changed, 584 insertions, 5 deletions

diff --git a/user/qt5-qtwebchannel/APKBUILD b/user/qt5-qtwebchannel/APKBUILD
index 1ed8fd199..e54ea70c3 100644
--- a/user/qt5-qtwebchannel/APKBUILD
+++ b/user/qt5-qtwebchannel/APKBUILD
@@ -1,8 +1,8 @@
 # Contributor: A. Wilcox <awilfox@adelielinux.org>
 # Maintainer: A. Wilcox <awilfox@adelielinux.org>
 pkgname=qt5-qtwebchannel
-_pkgname=qtwebchannel-everywhere-src
-pkgver=5.12.9
+_pkgname=qtwebchannel-everywhere
+pkgver=5.15.4
 pkgrel=0
 pkgdesc="Connect Qt applications to WebSockets"
 url="https://www.qt.io/"
@@ -12,8 +12,10 @@ license="LGPL-3.0-only WITH Qt-LGPL-exception-1.1 OR GPL-3.0-only WITH Qt-GPL-ex
 depends=""
 makedepends="qt5-qtbase-dev qt5-qtdeclarative-dev"
 subpackages="$pkgname-dev"
-source="https://download.qt.io/official_releases/qt/${pkgver%.*}/$pkgver/submodules/$_pkgname-$pkgver.tar.xz"
-builddir="$srcdir"/$_pkgname-$pkgver
+source="https://download.qt.io/official_releases/qt/${pkgver%.*}/$pkgver/submodules/$_pkgname-opensource-src-$pkgver.tar.xz
+	kde-lts.patch
+	"
+builddir="$srcdir"/$_pkgname-src-$pkgver
 
 build() {
 	qmake
@@ -24,4 +26,5 @@ package() {
 	make install INSTALL_ROOT="$pkgdir"
 }
 
-sha512sums="d906875bb1a164d7abfeb079b0efcdd321cf345b87e5dd1fbc3a2bc58bbfea43779cf844addb24036cf8bd2c24256aed835418038ad460e46f5b6be5b6d5e0e2  qtwebchannel-everywhere-src-5.12.9.tar.xz"
+sha512sums="18d5e6f44b780c7dfc94e1620ba76d7b0731d671df537b2e29fef062a0775e8dc973deb6c949b37000f5e8a49bdd31a723aa069bafcb9ecdc3259d0bf97e5a26  qtwebchannel-everywhere-opensource-src-5.15.4.tar.xz
+3a797ea504343c321e8ff29bb143a3305bbc1ec0bfecd484974acab7597b8b8f5bbcd6b9fb8c5bf47d25e8de4801d4d9a5c0a38b7e4f135174f2393c924af782  kde-lts.patch"
diff --git a/user/qt5-qtwebchannel/kde-lts.patch b/user/qt5-qtwebchannel/kde-lts.patch
new file mode 100644
index 000000000..352a4a906
--- /dev/null
+++ b/user/qt5-qtwebchannel/kde-lts.patch
@@ -0,0 +1,576 @@
+From adfc4bacdf18d9876a1ea908ce6aeb43555b0dbd Mon Sep 17 00:00:00 2001
+From: Milian Wolff <milian.wolff@kdab.com>
+Date: Fri, 13 Dec 2019 18:07:26 +0100
+Subject: [PATCH 1/3] Handle signals in the registered object's thread
+
+Do not call `sender()` from a different thread. As the API documentation
+indicates, that is not supported and can lead to crashes as experienced
+on the CI frequently.
+
+Instead, we now have per-thread SignalHandlers and use those to get
+notified about signals and metacall events.
+
+Moving a registered object into a different thread isn't supported once
+it was registered. But the object can be deregistered, moved, and then
+re-registered.
+
+[ChangeLog] Signals from objects living in a different thread than the
+QWebChannel are now handled correctly.
+
+Task-number: QTBUG-51366
+Change-Id: I1edb0694b946a494b6c0d4a8a6dc6b452dcb2c7a
+Reviewed-by: Arno Rehn <a.rehn@menlosystems.com>
+Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
+(cherry picked from commit 28455e59c0b940200fe0223472a80104ce1a02dd)
+---
+ src/webchannel/qmetaobjectpublisher.cpp  | 23 +++++++++++++++++------
+ src/webchannel/qmetaobjectpublisher_p.h  |  5 ++++-
+ src/webchannel/signalhandler_p.h         |  3 +++
+ tests/auto/webchannel/tst_webchannel.cpp |  4 +---
+ 4 files changed, 25 insertions(+), 10 deletions(-)
+
+diff --git a/src/webchannel/qmetaobjectpublisher.cpp b/src/webchannel/qmetaobjectpublisher.cpp
+index 536eb5c..e997b75 100644
+--- a/src/webchannel/qmetaobjectpublisher.cpp
++++ b/src/webchannel/qmetaobjectpublisher.cpp
+@@ -186,7 +186,6 @@ Q_DECLARE_TYPEINFO(OverloadResolutionCandidate, Q_MOVABLE_TYPE);
+ QMetaObjectPublisher::QMetaObjectPublisher(QWebChannel *webChannel)
+     : QObject(webChannel)
+     , webChannel(webChannel)
+-    , signalHandler(this)
+     , clientIsIdle(false)
+     , blockUpdates(false)
+     , propertyUpdatesInitialized(false)
+@@ -333,6 +332,7 @@ QJsonObject QMetaObjectPublisher::initializeClient(QWebChannelAbstractTransport
+ 
+ void QMetaObjectPublisher::initializePropertyUpdates(const QObject *const object, const QJsonObject &objectInfo)
+ {
++    auto *signalHandler = signalHandlerFor(object);
+     foreach (const QJsonValue &propertyInfoVar, objectInfo[KEY_PROPERTIES].toArray()) {
+         const QJsonArray &propertyInfo = propertyInfoVar.toArray();
+         if (propertyInfo.size() < 2) {
+@@ -353,14 +353,14 @@ void QMetaObjectPublisher::initializePropertyUpdates(const QObject *const object
+ 
+         // Only connect for a property update once
+         if (connectedProperties.isEmpty()) {
+-            signalHandler.connectTo(object, signalIndex);
++            signalHandler->connectTo(object, signalIndex);
+         }
+ 
+         connectedProperties.insert(propertyIndex);
+     }
+ 
+     // also always connect to destroyed signal
+-    signalHandler.connectTo(object, s_destroyedSignalIndex);
++    signalHandler->connectTo(object, s_destroyedSignalIndex);
+ }
+ 
+ void QMetaObjectPublisher::sendPendingPropertyUpdates()
+@@ -590,7 +590,7 @@ void QMetaObjectPublisher::objectDestroyed(const QObject *object)
+     // only remove from handler when we initialized the property updates
+     // cf: https://bugreports.qt.io/browse/QTBUG-60250
+     if (propertyUpdatesInitialized) {
+-        signalHandler.remove(object);
++        signalHandlerFor(object)->remove(object);
+         signalToPropertyMap.remove(object);
+     }
+     pendingPropertyUpdates.remove(object);
+@@ -913,9 +913,9 @@ void QMetaObjectPublisher::handleMessage(const QJsonObject &message, QWebChannel
+                 return;
+             transport->sendMessage(createResponse(message.value(KEY_ID), wrapResult(result, transport)));
+         } else if (type == TypeConnectToSignal) {
+-            signalHandler.connectTo(object, message.value(KEY_SIGNAL).toInt(-1));
++            signalHandlerFor(object)->connectTo(object, message.value(KEY_SIGNAL).toInt(-1));
+         } else if (type == TypeDisconnectFromSignal) {
+-            signalHandler.disconnectFrom(object, message.value(KEY_SIGNAL).toInt(-1));
++            signalHandlerFor(object)->disconnectFrom(object, message.value(KEY_SIGNAL).toInt(-1));
+         } else if (type == TypeSetProperty) {
+             setProperty(object, message.value(KEY_PROPERTY).toInt(-1),
+                         message.value(KEY_VALUE));
+@@ -948,4 +948,15 @@ void QMetaObjectPublisher::timerEvent(QTimerEvent *event)
+     }
+ }
+ 
++SignalHandler<QMetaObjectPublisher> *QMetaObjectPublisher::signalHandlerFor(const QObject *object)
++{
++    auto thread = object->thread();
++    auto it = signalHandlers.find(thread);
++    if (it == signalHandlers.end()) {
++        it = signalHandlers.emplace(thread, this).first;
++        it->second.moveToThread(thread);
++    }
++    return &it->second;
++}
++
+ QT_END_NAMESPACE
+diff --git a/src/webchannel/qmetaobjectpublisher_p.h b/src/webchannel/qmetaobjectpublisher_p.h
+index bbd9875..ded0d33 100644
+--- a/src/webchannel/qmetaobjectpublisher_p.h
++++ b/src/webchannel/qmetaobjectpublisher_p.h
+@@ -60,6 +60,8 @@
+ #include <QPointer>
+ #include <QJsonObject>
+ 
++#include <unordered_map>
++
+ #include "qwebchannelglobal.h"
+ 
+ QT_BEGIN_NAMESPACE
+@@ -272,7 +274,8 @@ private:
+     friend class TestWebChannel;
+ 
+     QWebChannel *webChannel;
+-    SignalHandler<QMetaObjectPublisher> signalHandler;
++    std::unordered_map<const QThread*, SignalHandler<QMetaObjectPublisher>> signalHandlers;
++    SignalHandler<QMetaObjectPublisher> *signalHandlerFor(const QObject *object);
+ 
+     // true when the client is idle, false otherwise
+     bool clientIsIdle;
+diff --git a/src/webchannel/signalhandler_p.h b/src/webchannel/signalhandler_p.h
+index 27afadb..d77373c 100644
+--- a/src/webchannel/signalhandler_p.h
++++ b/src/webchannel/signalhandler_p.h
+@@ -56,6 +56,7 @@
+ #include <QVector>
+ #include <QMetaMethod>
+ #include <QDebug>
++#include <QThread>
+ 
+ QT_BEGIN_NAMESPACE
+ 
+@@ -71,6 +72,7 @@ static const int s_destroyedSignalIndex = QObject::staticMetaObject.indexOfMetho
+ template<class Receiver>
+ class SignalHandler : public QObject
+ {
++    Q_DISABLE_COPY(SignalHandler)
+ public:
+     SignalHandler(Receiver *receiver, QObject *parent = 0);
+ 
+@@ -268,6 +270,7 @@ int SignalHandler<Receiver>::qt_metacall(QMetaObject::Call call, int methodId, v
+     if (call == QMetaObject::InvokeMetaMethod) {
+         const QObject *object = sender();
+         Q_ASSERT(object);
++        Q_ASSERT(QThread::currentThread() == object->thread());
+         Q_ASSERT(senderSignalIndex() == methodId);
+         Q_ASSERT(m_connectionsCounter.contains(object));
+         Q_ASSERT(m_connectionsCounter.value(object).contains(methodId));
+diff --git a/tests/auto/webchannel/tst_webchannel.cpp b/tests/auto/webchannel/tst_webchannel.cpp
+index 181da9e..7f846f5 100644
+--- a/tests/auto/webchannel/tst_webchannel.cpp
++++ b/tests/auto/webchannel/tst_webchannel.cpp
+@@ -943,8 +943,6 @@ void TestWebChannel::testInfiniteRecursion()
+ 
+ void TestWebChannel::testAsyncObject()
+ {
+-    QSKIP("This test is broken. See QTBUG-80729");
+-
+     QWebChannel channel;
+     channel.connectTo(m_dummyTransport);
+ 
+@@ -1082,7 +1080,7 @@ void TestWebChannel::benchInitializeClients()
+ 
+         publisher->propertyUpdatesInitialized = false;
+         publisher->signalToPropertyMap.clear();
+-        publisher->signalHandler.clear();
++        publisher->signalHandlers.clear();
+     }
+ }
+ 
+-- 
+2.36.0
+
+From 01803a64b0a0b03eb8d9add60008829bc9d5c11e Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?=C3=98ystein=20Heskestad?= <oystein.heskestad@qt.io>
+Date: Fri, 7 May 2021 15:23:38 +0200
+Subject: [PATCH 2/3] Handle per-transport client idle status
+
+[ChangeLog][QMetaObjectPublisher] Handle per-transport client idle status
+
+Task-number: QTBUG-92927
+Change-Id: I5a06261e6dddb0fc0fae9f73b280c61cf5a2b52d
+Reviewed-by: Arno Rehn <a.rehn@menlosystems.com>
+(cherry picked from commit a7199de7d90f48ce3d95cae795bd9209c39516ce)
+---
+ src/webchannel/qmetaobjectpublisher.cpp  | 71 ++++++++++++++++++------
+ src/webchannel/qmetaobjectpublisher_p.h  | 39 +++++++++++--
+ tests/auto/qml/testwebchannel.cpp        |  6 +-
+ tests/auto/webchannel/tst_webchannel.cpp | 48 +++++++++++++++-
+ tests/auto/webchannel/tst_webchannel.h   |  1 +
+ 5 files changed, 138 insertions(+), 27 deletions(-)
+
+diff --git a/src/webchannel/qmetaobjectpublisher.cpp b/src/webchannel/qmetaobjectpublisher.cpp
+index e997b75..3897c07 100644
+--- a/src/webchannel/qmetaobjectpublisher.cpp
++++ b/src/webchannel/qmetaobjectpublisher.cpp
+@@ -186,7 +186,6 @@ Q_DECLARE_TYPEINFO(OverloadResolutionCandidate, Q_MOVABLE_TYPE);
+ QMetaObjectPublisher::QMetaObjectPublisher(QWebChannel *webChannel)
+     : QObject(webChannel)
+     , webChannel(webChannel)
+-    , clientIsIdle(false)
+     , blockUpdates(false)
+     , propertyUpdatesInitialized(false)
+ {
+@@ -300,17 +299,17 @@ QJsonObject QMetaObjectPublisher::classInfoForObject(const QObject *object, QWeb
+     return data;
+ }
+ 
+-void QMetaObjectPublisher::setClientIsIdle(bool isIdle)
++void QMetaObjectPublisher::setClientIsIdle(bool isIdle, QWebChannelAbstractTransport *transport)
+ {
+-    if (clientIsIdle == isIdle) {
+-        return;
+-    }
+-    clientIsIdle = isIdle;
+-    if (!isIdle && timer.isActive()) {
+-        timer.stop();
+-    } else if (isIdle && !timer.isActive()) {
+-        timer.start(PROPERTY_UPDATE_INTERVAL, this);
+-    }
++    transportState[transport].clientIsIdle = isIdle;
++    if (isIdle)
++        sendEnqueuedPropertyUpdates(transport);
++}
++
++bool QMetaObjectPublisher::isClientIdle(QWebChannelAbstractTransport *transport)
++{
++    auto found = transportState.find(transport);
++    return found != transportState.end() && found.value().clientIsIdle;
+ }
+ 
+ QJsonObject QMetaObjectPublisher::initializeClient(QWebChannelAbstractTransport *transport)
+@@ -365,7 +364,7 @@ void QMetaObjectPublisher::initializePropertyUpdates(const QObject *const object
+ 
+ void QMetaObjectPublisher::sendPendingPropertyUpdates()
+ {
+-    if (blockUpdates || !clientIsIdle || pendingPropertyUpdates.isEmpty()) {
++    if (blockUpdates) {
+         return;
+     }
+ 
+@@ -415,18 +414,19 @@ void QMetaObjectPublisher::sendPendingPropertyUpdates()
+ 
+     // data does not contain specific updates
+     if (!data.isEmpty()) {
+-        setClientIsIdle(false);
+-
+         message[KEY_DATA] = data;
+-        broadcastMessage(message);
++        enqueueBroadcastMessage(message);
+     }
+ 
+     // send every property update which is not supposed to be broadcasted
+     const QHash<QWebChannelAbstractTransport*, QJsonArray>::const_iterator suend = specificUpdates.constEnd();
+     for (QHash<QWebChannelAbstractTransport*, QJsonArray>::const_iterator it = specificUpdates.constBegin(); it != suend; ++it) {
+         message[KEY_DATA] = it.value();
+-        it.key()->sendMessage(message);
++        enqueueMessage(message, it.key());
+     }
++
++    for (auto state = transportState.begin(); state != transportState.end(); ++state)
++        sendEnqueuedPropertyUpdates(state.key());
+ }
+ 
+ QVariant QMetaObjectPublisher::invokeMethod(QObject *const object, const QMetaMethod &method,
+@@ -572,7 +572,7 @@ void QMetaObjectPublisher::signalEmitted(const QObject *object, const int signal
+         }
+     } else {
+         pendingPropertyUpdates[object][signalIndex] = arguments;
+-        if (clientIsIdle && !blockUpdates && !timer.isActive()) {
++        if (!blockUpdates && !timer.isActive()) {
+             timer.start(PROPERTY_UPDATE_INTERVAL, this);
+         }
+     }
+@@ -852,6 +852,40 @@ void QMetaObjectPublisher::broadcastMessage(const QJsonObject &message) const
+     }
+ }
+ 
++void QMetaObjectPublisher::enqueueBroadcastMessage(const QJsonObject &message)
++{
++    if (webChannel->d_func()->transports.isEmpty()) {
++        qWarning("QWebChannel is not connected to any transports, cannot send message: %s",
++                 QJsonDocument(message).toJson().constData());
++        return;
++    }
++
++    for (auto *transport : webChannel->d_func()->transports) {
++        auto &state = transportState[transport];
++        state.queuedMessages.append(message);
++    }
++}
++
++void QMetaObjectPublisher::enqueueMessage(const QJsonObject &message,
++                                          QWebChannelAbstractTransport *transport)
++{
++    auto &state = transportState[transport];
++    state.queuedMessages.append(message);
++}
++
++void QMetaObjectPublisher::sendEnqueuedPropertyUpdates(QWebChannelAbstractTransport *transport)
++{
++    auto found = transportState.find(transport);
++    if (found != transportState.end() && found.value().clientIsIdle
++        && !found.value().queuedMessages.isEmpty()) {
++        for (auto message : found.value().queuedMessages) {
++            transport->sendMessage(message);
++        }
++        found.value().queuedMessages.clear();
++        found.value().clientIsIdle = false;
++    }
++}
++
+ void QMetaObjectPublisher::handleMessage(const QJsonObject &message, QWebChannelAbstractTransport *transport)
+ {
+     if (!webChannel->d_func()->transports.contains(transport)) {
+@@ -866,7 +900,7 @@ void QMetaObjectPublisher::handleMessage(const QJsonObject &message, QWebChannel
+ 
+     const MessageType type = toType(message.value(KEY_TYPE));
+     if (type == TypeIdle) {
+-        setClientIsIdle(true);
++        setClientIsIdle(true, transport);
+     } else if (type == TypeInit) {
+         if (!message.contains(KEY_ID)) {
+             qWarning("JSON message object is missing the id property: %s",
+@@ -931,6 +965,7 @@ void QMetaObjectPublisher::setBlockUpdates(bool block)
+     blockUpdates = block;
+ 
+     if (!blockUpdates) {
++        timer.start(PROPERTY_UPDATE_INTERVAL, this);
+         sendPendingPropertyUpdates();
+     } else if (timer.isActive()) {
+         timer.stop();
+diff --git a/src/webchannel/qmetaobjectpublisher_p.h b/src/webchannel/qmetaobjectpublisher_p.h
+index ded0d33..4713ef1 100644
+--- a/src/webchannel/qmetaobjectpublisher_p.h
++++ b/src/webchannel/qmetaobjectpublisher_p.h
+@@ -59,6 +59,7 @@
+ #include <QBasicTimer>
+ #include <QPointer>
+ #include <QJsonObject>
++#include <QQueue>
+ 
+ #include <unordered_map>
+ 
+@@ -111,17 +112,36 @@ public:
+      */
+     void broadcastMessage(const QJsonObject &message) const;
+ 
++    /**
++     * Enqueue the given @p message to all known transports.
++     */
++    void enqueueBroadcastMessage(const QJsonObject &message);
++
++    /**
++     * Enqueue the given @p message to @p transport.
++     */
++    void enqueueMessage(const QJsonObject &message, QWebChannelAbstractTransport *transport);
++
++    /**
++     * If client for given @p transport is idle, send queued messaged to @p transport and then mark
++     * the client as not idle.
++     */
++    void sendEnqueuedPropertyUpdates(QWebChannelAbstractTransport *transport);
++
+     /**
+      * Serialize the QMetaObject of @p object and return it in JSON form.
+      */
+     QJsonObject classInfoForObject(const QObject *object, QWebChannelAbstractTransport *transport);
+ 
+     /**
+-     * Set the client to idle or busy, based on the value of @p isIdle.
+-     *
+-     * When the value changed, start/stop the property update timer accordingly.
++     * Set the client to idle or busy for a single @p transport, based on the value of @p isIdle.
+      */
+-    void setClientIsIdle(bool isIdle);
++    void setClientIsIdle(bool isIdle, QWebChannelAbstractTransport *transport);
++
++    /**
++     * Check that client is idle for @p transport.
++     */
++    bool isClientIdle(QWebChannelAbstractTransport *transport);
+ 
+     /**
+      * Initialize clients by sending them the class information of the registered objects.
+@@ -277,8 +297,15 @@ private:
+     std::unordered_map<const QThread*, SignalHandler<QMetaObjectPublisher>> signalHandlers;
+     SignalHandler<QMetaObjectPublisher> *signalHandlerFor(const QObject *object);
+ 
+-    // true when the client is idle, false otherwise
+-    bool clientIsIdle;
++    struct TransportState
++    {
++        TransportState() : clientIsIdle(false) { }
++        // true when the client is idle, false otherwise
++        bool clientIsIdle;
++        // messages to send
++        QQueue<QJsonObject> queuedMessages;
++    };
++    QHash<QWebChannelAbstractTransport *, TransportState> transportState;
+ 
+     // true when no property updates should be sent, false otherwise
+     bool blockUpdates;
+diff --git a/tests/auto/qml/testwebchannel.cpp b/tests/auto/qml/testwebchannel.cpp
+index 9891687..3ca81c2 100644
+--- a/tests/auto/qml/testwebchannel.cpp
++++ b/tests/auto/qml/testwebchannel.cpp
+@@ -46,7 +46,11 @@ TestWebChannel::~TestWebChannel()
+ 
+ bool TestWebChannel::clientIsIdle() const
+ {
+-    return QWebChannel::d_func()->publisher->clientIsIdle;
++    for (auto *transport : QWebChannel::d_func()->transports) {
++        if (QWebChannel::d_func()->publisher->isClientIdle(transport))
++            return true;
++    }
++    return false;
+ }
+ 
+ QT_END_NAMESPACE
+diff --git a/tests/auto/webchannel/tst_webchannel.cpp b/tests/auto/webchannel/tst_webchannel.cpp
+index 7f846f5..37f989a 100644
+--- a/tests/auto/webchannel/tst_webchannel.cpp
++++ b/tests/auto/webchannel/tst_webchannel.cpp
+@@ -785,7 +785,7 @@ void TestWebChannel::testTransportWrapObjectProperties()
+     DummyTransport *dummyTransport = new DummyTransport(this);
+     channel.connectTo(dummyTransport);
+     channel.d_func()->publisher->initializeClient(dummyTransport);
+-    channel.d_func()->publisher->setClientIsIdle(true);
++    channel.d_func()->publisher->setClientIsIdle(true, dummyTransport);
+ 
+     QCOMPARE(channel.d_func()->publisher->transportedWrappedObjects.size(), 0);
+ 
+@@ -988,6 +988,50 @@ void TestWebChannel::testAsyncObject()
+     thread.wait();
+ }
+ 
++void TestWebChannel::testPropertyMultipleTransports()
++{
++    DummyTransport transport1;
++    DummyTransport transport2;
++
++    QWebChannel channel;
++    QMetaObjectPublisher *publisher = channel.d_func()->publisher;
++
++    TestObject testObj;
++    testObj.setObjectName("testObject");
++    channel.registerObject(testObj.objectName(), &testObj);
++    channel.connectTo(&transport1);
++    channel.connectTo(&transport2);
++
++    testObj.setProp("Hello");
++
++    publisher->initializeClient(&transport1);
++    publisher->initializeClient(&transport2);
++    publisher->setClientIsIdle(true, &transport1);
++    QCOMPARE(publisher->isClientIdle(&transport1), true);
++    QCOMPARE(publisher->isClientIdle(&transport2), false);
++    QVERIFY(transport1.messagesSent().isEmpty());
++    QVERIFY(transport2.messagesSent().isEmpty());
++
++    testObj.setProp("World");
++    QTRY_COMPARE_WITH_TIMEOUT(transport1.messagesSent().size(), 1u, 2000);
++    QCOMPARE(transport2.messagesSent().size(), 0u);
++    publisher->setClientIsIdle(true, &transport2);
++    QTRY_COMPARE_WITH_TIMEOUT(transport2.messagesSent().size(), 1u, 2000);
++    QCOMPARE(publisher->isClientIdle(&transport1), false);
++    QCOMPARE(publisher->isClientIdle(&transport2), false);
++
++    testObj.setProp("!!!");
++    publisher->setClientIsIdle(true, &transport2);
++    QCOMPARE(publisher->isClientIdle(&transport2), true);
++    QCOMPARE(publisher->isClientIdle(&transport1), false);
++    QTRY_COMPARE_WITH_TIMEOUT(transport2.messagesSent().size(), 2u, 2000);
++    QCOMPARE(transport1.messagesSent().size(), 1u);
++    publisher->setClientIsIdle(true, &transport1);
++    QTRY_COMPARE_WITH_TIMEOUT(transport1.messagesSent().size(), 2u, 2000);
++    QCOMPARE(publisher->isClientIdle(&transport1), false);
++    QCOMPARE(publisher->isClientIdle(&transport2), false);
++}
++
+ class FunctionWrapper : public QObject
+ {
+     Q_OBJECT
+@@ -1105,7 +1149,7 @@ void TestWebChannel::benchPropertyUpdates()
+             obj->change();
+         }
+ 
+-        channel.d_func()->publisher->clientIsIdle = true;
++        channel.d_func()->publisher->setClientIsIdle(true, m_dummyTransport);
+         channel.d_func()->publisher->sendPendingPropertyUpdates();
+     }
+ }
+diff --git a/tests/auto/webchannel/tst_webchannel.h b/tests/auto/webchannel/tst_webchannel.h
+index eae21f4..dd4e690 100644
+--- a/tests/auto/webchannel/tst_webchannel.h
++++ b/tests/auto/webchannel/tst_webchannel.h
+@@ -348,6 +348,7 @@ private slots:
+     void testJsonToVariant();
+     void testInfiniteRecursion();
+     void testAsyncObject();
++    void testPropertyMultipleTransports();
+     void testDeletionDuringMethodInvocation_data();
+     void testDeletionDuringMethodInvocation();
+ 
+-- 
+2.36.0
+
+From 8c842152da613f941892481d62267c73c4a4f006 Mon Sep 17 00:00:00 2001
+From: Arno Rehn <a.rehn@menlosystems.com>
+Date: Wed, 8 Dec 2021 22:44:49 +0100
+Subject: [PATCH 3/3] QMetaObjectPublisher: Never send stale queued messages
+
+If the client is connected with an in-process transport, it can happen
+that a transmitted message triggers a subsequent property change.
+In that case, we need to ensure that the queued messages have already
+been cleared; otherwise the recursive call will send everythig again.
+
+Case in point: The qmlwebchannel tests fail if we don't clear the
+queued messages before sending them out.
+
+For that same reason set the client to "busy" (aka non-idle) just right
+before sending out the messages; otherwise a potential "Idle" type
+message will not correctly restore the Idle state.
+
+Pick-to: 6.2
+Pick-to: 6.3
+Change-Id: Idc4afdd5cf4b4e03b8de8953a03d28442d74a3ab
+Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
+(cherry picked from commit b4bf8f5e043120341cd9caa59f25a2beecd94ad0)
+---
+ src/webchannel/qmetaobjectpublisher.cpp | 18 +++++++++++++++---
+ 1 file changed, 15 insertions(+), 3 deletions(-)
+
+diff --git a/src/webchannel/qmetaobjectpublisher.cpp b/src/webchannel/qmetaobjectpublisher.cpp
+index 3897c07..898d769 100644
+--- a/src/webchannel/qmetaobjectpublisher.cpp
++++ b/src/webchannel/qmetaobjectpublisher.cpp
+@@ -878,11 +878,23 @@ void QMetaObjectPublisher::sendEnqueuedPropertyUpdates(QWebChannelAbstractTransp
+     auto found = transportState.find(transport);
+     if (found != transportState.end() && found.value().clientIsIdle
+         && !found.value().queuedMessages.isEmpty()) {
+-        for (auto message : found.value().queuedMessages) {
++
++        // If the client is connected with an in-process transport, it can
++        // happen that a message triggers a subsequent property change. In
++        // that case, we need to ensure that the queued messages have already
++        // been cleared; otherwise the recursive call will send everythig again.
++        // Case in point: The qmlwebchannel tests fail if we don't clear the
++        // queued messages before sending them out.
++        // For that same reason set the client to "busy" (aka non-idle) just
++        // right before sending out the messages; otherwise a potential
++        // "Idle" type message will not correctly restore the Idle state.
++        const auto messages = std::move(found.value().queuedMessages);
++        Q_ASSERT(found.value().queuedMessages.isEmpty());
++        found.value().clientIsIdle = false;
++
++        for (const auto &message : messages) {
+             transport->sendMessage(message);
+         }
+-        found.value().queuedMessages.clear();
+-        found.value().clientIsIdle = false;
+     }
+ }
+ 
+-- 
+2.36.0
+