Do direct notification of backend nodeswip/refactor

Since aspect manager is now on main thread, we can directly update
backend nodes safely. Track nodes which have changed properties and
notify the backend nodes as part of the frame loop.
This avoid allocating and delivering many change messages.

To follow:
- implement on all nodes
- look at backend to frontend syncing
- figure out what to do with non property messages (components
  added/removed, commands, ...)

Change-Id: Ia0c442b0528e728c4324d168200bae021bc29266
Reviewed-by: Mike Krus <mike.krus@kdab.com>
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

86 files changed, 1354 insertions, 1859 deletions

diff --git a/src/core/aspects/qabstractaspect.cpp b/src/core/aspects/qabstractaspect.cpp
index 7b08dec81..7636fd666 100644
--- a/src/core/aspects/qabstractaspect.cpp
+++ b/src/core/aspects/qabstractaspect.cpp
@@ -40,6 +40,9 @@
 #include "qabstractaspect.h"
 #include "qabstractaspect_p.h"
 
+#include <QMetaObject>
+#include <QMetaProperty>
+
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
 
@@ -48,6 +51,7 @@
 #include <Qt3DCore/private/qaspectmanager_p.h>
 #include <Qt3DCore/private/qchangearbiter_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
+#include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 
 QT_BEGIN_NAMESPACE
@@ -170,7 +174,14 @@ QNodeId QAbstractAspect::rootEntityId() const Q_DECL_NOEXCEPT
 void QAbstractAspect::registerBackendType(const QMetaObject &obj, const QBackendNodeMapperPtr &functor)
 {
     Q_D(QAbstractAspect);
-    d->m_backendCreatorFunctors.insert(&obj, functor);
+    d->m_backendCreatorFunctors.insert(&obj, {functor, QAbstractAspectPrivate::DefaultMapper});
+}
+
+void QAbstractAspect::registerBackendType(const QMetaObject &obj, const QBackendNodeMapperPtr &functor, bool supportsSyncing)
+{
+    Q_D(QAbstractAspect);
+    const auto f = supportsSyncing ? QAbstractAspectPrivate::SupportsSyncing : QAbstractAspectPrivate::DefaultMapper;
+    d->m_backendCreatorFunctors.insert(&obj, {functor, f});
 }
 
 void QAbstractAspect::unregisterBackendType(const QMetaObject &obj)
@@ -203,12 +214,96 @@ QVector<QAspectJobPtr> QAbstractAspect::jobsToExecute(qint64 time)
     return QVector<QAspectJobPtr>();
 }
 
+void QAbstractAspect::syncDirtyFrontEndNodes(const QVector<QNode *> &nodes)
+{
+    Q_D(QAbstractAspect);
+    d->syncDirtyFrontEndNodes(nodes);
+}
+
+void QAbstractAspectPrivate::syncDirtyFrontEndNodes(const QVector<QNode *> &nodes)
+{
+    for (auto node: qAsConst(nodes)) {
+        const QMetaObject *metaObj = node->metaObject();
+        QBackendNodeMapperPtr backendNodeMapper;
+        bool supportsSyncing = false;
+        while (metaObj != nullptr && backendNodeMapper.isNull()) {
+            auto v = m_backendCreatorFunctors.value(metaObj);
+            backendNodeMapper = v.first;
+            supportsSyncing = v.second & SupportsSyncing;
+            metaObj = metaObj->superClass();
+        }
+
+        if (!backendNodeMapper)
+            continue;
+
+        QBackendNode *backend = backendNodeMapper->get(node->id());
+        if (!backend)
+            continue;
+        if (supportsSyncing)
+            syncDirtyFrontEndNode(node, backend, false);
+        else
+            sendPropertyMessages(node, backend);
+    }
+}
+
+void QAbstractAspectPrivate::syncDirtyFrontEndNode(QNode *node, QBackendNode *backend, bool firstTime) const
+{
+    Q_UNUSED(firstTime);
+    Q_ASSERT(false); // overload in derived class
+    sendPropertyMessages(node, backend);
+}
+
+void QAbstractAspectPrivate::sendPropertyMessages(QNode *node, QBackendNode *backend) const
+{
+    const int offset = QNode::staticMetaObject.propertyOffset();
+    const auto metaObj = node->metaObject();
+    const int count = metaObj->propertyCount();
+
+    const auto toBackendValue = [](const QVariant &data) -> QVariant
+    {
+        if (data.canConvert<QNode*>()) {
+            QNode *node = data.value<QNode*>();
+
+            // Ensure the node and all ancestors have issued their node creation changes.
+            // We can end up here if a newly created node with a parent is immediately set
+            // as a property on another node. In this case the deferred call to
+            // _q_postConstructorInit() will not have happened yet as the event
+            // loop will still be blocked. We need to do this for all ancestors,
+            // since the subtree of this node otherwise can end up on the backend
+            // with a reference to a non-existent parent.
+            if (node)
+                QNodePrivate::get(node)->_q_ensureBackendNodeCreated();
+
+            const QNodeId id = node ? node->id() : QNodeId();
+            return QVariant::fromValue(id);
+        }
+
+        return data;
+    };
+
+    QPropertyUpdatedChange change(node->id());
+    QPropertyUpdatedChangePtr pchange(&change, [](QPropertyUpdatedChange *) { });
+    for (int index = offset; index < count; index++) {
+        const QMetaProperty pro = metaObj->property(index);
+        change.setPropertyName(pro.name());
+        change.setValue(toBackendValue(pro.read(node)));
+        backend->sceneChangeEvent(pchange);
+    }
+
+    auto const dynamicProperties = node->dynamicPropertyNames();
+    for (const QByteArray &name: dynamicProperties) {
+        change.setPropertyName(name.data());
+        change.setValue(toBackendValue(node->property(name.data())));
+        backend->sceneChangeEvent(pchange);
+    }
+}
+
 QBackendNode *QAbstractAspectPrivate::createBackendNode(const QNodeCreatedChangeBasePtr &change) const
 {
     const QMetaObject *metaObj = change->metaObject();
     QBackendNodeMapperPtr backendNodeMapper;
     while (metaObj != nullptr && backendNodeMapper.isNull()) {
-        backendNodeMapper = m_backendCreatorFunctors.value(metaObj);
+        backendNodeMapper = m_backendCreatorFunctors.value(metaObj).first;
         metaObj = metaObj->superClass();
     }
 
@@ -248,6 +343,7 @@ QBackendNode *QAbstractAspectPrivate::createBackendNode(const QNodeCreatedChange
     return backend;
 }
 
+
 void QAbstractAspectPrivate::clearBackendNode(const QNodeDestroyedChangePtr &change) const
 {
     // Each QNodeDestroyedChange may contain info about a whole sub-tree of nodes that
@@ -259,7 +355,7 @@ void QAbstractAspectPrivate::clearBackendNode(const QNodeDestroyedChangePtr &cha
 
         // Find backend node mapper for this type
         while (metaObj != nullptr && backendNodeMapper.isNull()) {
-            backendNodeMapper = m_backendCreatorFunctors.value(metaObj);
+            backendNodeMapper = m_backendCreatorFunctors.value(metaObj).first;
             metaObj = metaObj->superClass();
         }
 
diff --git a/src/core/aspects/qabstractaspect.h b/src/core/aspects/qabstractaspect.h
index 1ae85e4e6..a9f4f03fc 100644
--- a/src/core/aspects/qabstractaspect.h
+++ b/src/core/aspects/qabstractaspect.h
@@ -77,12 +77,17 @@ protected:
 
     template<class Frontend>
     void registerBackendType(const QBackendNodeMapperPtr &functor);
-    void registerBackendType(const QMetaObject &, const QBackendNodeMapperPtr &functor);
+    template<class Frontend, bool supportsSyncing>
+    void registerBackendType(const QBackendNodeMapperPtr &functor);
+    void registerBackendType(const QMetaObject &obj, const QBackendNodeMapperPtr &functor);
     template<class Frontend>
     void unregisterBackendType();
     void unregisterBackendType(const QMetaObject &);
 
 private:
+    void syncDirtyFrontEndNodes(const QVector<QNode *> &nodes);
+    void registerBackendType(const QMetaObject &obj, const QBackendNodeMapperPtr &functor, bool supportsSyncing);
+
     virtual QVariant executeCommand(const QStringList &args);
 
     virtual QVector<QAspectJobPtr> jobsToExecute(qint64 time);
@@ -104,6 +109,12 @@ void QAbstractAspect::registerBackendType(const QBackendNodeMapperPtr &functor)
     registerBackendType(Frontend::staticMetaObject, functor);
 }
 
+template<class Frontend, bool supportsSyncing>
+void QAbstractAspect::registerBackendType(const QBackendNodeMapperPtr &functor)
+{
+    registerBackendType(Frontend::staticMetaObject, functor, supportsSyncing);
+}
+
 template<class Frontend>
 void QAbstractAspect::unregisterBackendType()
 {
diff --git a/src/core/aspects/qabstractaspect_p.h b/src/core/aspects/qabstractaspect_p.h
index e743dc63a..668b9670c 100644
--- a/src/core/aspects/qabstractaspect_p.h
+++ b/src/core/aspects/qabstractaspect_p.h
@@ -121,6 +121,9 @@ public:
 
     QBackendNode *createBackendNode(const QNodeCreatedChangeBasePtr &change) const override;
     void clearBackendNode(const QNodeDestroyedChangePtr &change) const;
+    void syncDirtyFrontEndNodes(const QVector<QNode *> &nodes);
+    virtual void syncDirtyFrontEndNode(QNode *node, QBackendNode *backend, bool firstTime) const;
+    void sendPropertyMessages(QNode *node, QBackendNode *backend) const;
 
     void sceneNodeAdded(Qt3DCore::QSceneChangePtr &e) override;
     void sceneNodeRemoved(Qt3DCore::QSceneChangePtr &e) override;
@@ -134,12 +137,17 @@ public:
 
     Q_DECLARE_PUBLIC(QAbstractAspect)
 
+    enum NodeMapperInfo {
+        DefaultMapper = 0,
+        SupportsSyncing = 1 << 0
+    };
+
     QEntity *m_root;
     QNodeId m_rootId;
     QAspectManager *m_aspectManager;
     QAbstractAspectJobManager *m_jobManager;
     QChangeArbiter *m_arbiter;
-    QHash<const QMetaObject*, QBackendNodeMapperPtr> m_backendCreatorFunctors;
+    QHash<const QMetaObject*, QPair<QBackendNodeMapperPtr, NodeMapperInfo>> m_backendCreatorFunctors;
     QMutex m_singleShotMutex;
     QVector<QAspectJobPtr> m_singleShotJobs;
 
diff --git a/src/core/aspects/qaspectengine.cpp b/src/core/aspects/qaspectengine.cpp
index 9c98e9613..c5e4b2b26 100644
--- a/src/core/aspects/qaspectengine.cpp
+++ b/src/core/aspects/qaspectengine.cpp
@@ -120,12 +120,6 @@ void QAspectEnginePrivate::initEntity(QEntity *entity)
     }
 }
 
-void QAspectEnginePrivate::generateCreationChanges(QNode *root)
-{
-    const QNodeCreatedChangeGenerator generator(root);
-    m_creationChanges = generator.creationChanges();
-}
-
 /*!
  * \class Qt3DCore::QAspectEngine
  * \inheaderfile Qt3DCore/QAspectEngine
@@ -444,7 +438,8 @@ void QAspectEngine::setRootEntity(QEntityPtr root)
     d->initNodeTree(root.data());
 
     // Traverse tree to generate a vector of creation changes
-    d->generateCreationChanges(root.data());
+    const QNodeCreatedChangeGenerator generator(root.data());
+    auto creationChanges = generator.creationChanges();
 
     // Specify if the AspectManager should be driving the simulation loop or not
     d->m_aspectManager->setRunMode(d->m_runMode);
@@ -456,7 +451,7 @@ void QAspectEngine::setRootEntity(QEntityPtr root)
     // TODO: Pass the creation changes via the arbiter rather than relying upon
     // an invokeMethod call.
     qCDebug(Aspects) << "Begin setting scene root on aspect manager";
-    d->m_aspectManager->setRootEntity(root.data(), d->m_creationChanges);
+    d->m_aspectManager->setRootEntity(root.data(), creationChanges);
     qCDebug(Aspects) << "Done setting scene root on aspect manager";
     d->m_aspectManager->enterSimulationLoop();
 }
diff --git a/src/core/aspects/qaspectengine_p.h b/src/core/aspects/qaspectengine_p.h
index e1aaa9de9..7dad2a352 100644
--- a/src/core/aspects/qaspectengine_p.h
+++ b/src/core/aspects/qaspectengine_p.h
@@ -106,9 +106,6 @@ public:
     void initNode(QNode *node);
     void initEntity(QEntity *entity);
 
-    void generateCreationChanges(QNode *rootNode);
-    QVector<QNodeCreatedChangeBasePtr> m_creationChanges;
-
     static QAspectEnginePrivate *get(QAspectEngine *engine);
 };
 
diff --git a/src/core/aspects/qaspectmanager.cpp b/src/core/aspects/qaspectmanager.cpp
index 6502590d8..0c16de882 100644
--- a/src/core/aspects/qaspectmanager.cpp
+++ b/src/core/aspects/qaspectmanager.cpp
@@ -370,6 +370,10 @@ void QAspectManager::processFrame()
     changeArbiterStats.threadId = reinterpret_cast<quint64>(QThread::currentThreadId());
     changeArbiterStats.startTime = QThreadPooler::m_jobsStatTimer.nsecsElapsed();
 #endif
+    const auto dirtyFrontEndNodes = m_changeArbiter->takeDirtyFrontEndNodes();
+    if (dirtyFrontEndNodes.size())
+        for (QAbstractAspect *aspect : qAsConst(m_aspects))
+           aspect->syncDirtyFrontEndNodes(dirtyFrontEndNodes);
     // TO DO: Having this done in the main thread actually means aspects could just
     // as simply read info out of the Frontend classes without risk of introducing
     // races. This could therefore be removed for Qt 6.
@@ -390,6 +394,8 @@ void QAspectManager::processFrame()
 #if defined(QT3D_CORE_JOB_TIMING)
     qDebug() << "Jobs took" << timer.nsecsElapsed() / 1.0e6;
 #endif
+
+    // TODO sync backend changes to frontend
 }
 
 } // namespace Qt3DCore
diff --git a/src/core/nodes/qbackendnode.cpp b/src/core/nodes/qbackendnode.cpp
index f10bf5769..3eb1cd9f7 100644
--- a/src/core/nodes/qbackendnode.cpp
+++ b/src/core/nodes/qbackendnode.cpp
@@ -256,16 +256,16 @@ void QBackendNode::setEnabled(bool enabled) Q_DECL_NOTHROW
 void QBackendNode::sceneChangeEvent(const QSceneChangePtr &e)
 {
     Q_D(QBackendNode);
-    auto propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
 
     switch (e->type()) {
-        case PropertyUpdated: {
-            if (propertyChange->propertyName() == QByteArrayLiteral("enabled"))
-                d->m_enabled = propertyChange->value().toBool();
-            break;
-        }
-        default:
-            break;
+    case PropertyUpdated: {
+        auto propertyChange = qSharedPointerCast<QPropertyUpdatedChange>(e);
+        if (propertyChange->propertyName() == QByteArrayLiteral("enabled"))
+            d->m_enabled = propertyChange->value().toBool();
+        break;
+    }
+    default:
+        break;
     }
 }
 
diff --git a/src/core/nodes/qcomponent.cpp b/src/core/nodes/qcomponent.cpp
index f67989b1e..2fe3c8094 100644
--- a/src/core/nodes/qcomponent.cpp
+++ b/src/core/nodes/qcomponent.cpp
@@ -73,7 +73,7 @@ void QComponentPrivate::addEntity(QEntity *entity)
         m_scene->addEntityForComponent(m_id, entity->id());
     }
 
-    const auto componentAddedChange = QComponentAddedChangePtr::create(q, entity);
+    const auto componentAddedChange = QComponentAddedChangePtr::create(q, entity);  // TODOSYNC notify backend directly
     notifyObservers(componentAddedChange);
     Q_EMIT q->addedToEntity(entity);
 }
@@ -86,7 +86,7 @@ void QComponentPrivate::removeEntity(QEntity *entity)
 
     m_entities.removeAll(entity);
 
-    const auto componentRemovedChange = QComponentRemovedChangePtr::create(q, entity);
+    const auto componentRemovedChange = QComponentRemovedChangePtr::create(q, entity);  // TODOSYNC notify backend directly
     notifyObservers(componentRemovedChange);
     Q_EMIT q->removedFromEntity(entity);
 }
diff --git a/src/core/nodes/qentity.cpp b/src/core/nodes/qentity.cpp
index 1d16e828e..a1f7d2859 100644
--- a/src/core/nodes/qentity.cpp
+++ b/src/core/nodes/qentity.cpp
@@ -105,7 +105,7 @@ void QEntityPrivate::removeDestroyedComponent(QComponent *comp)
     Q_Q(QEntity);
 
     if (m_changeArbiter) {
-        const auto componentRemovedChange = QComponentRemovedChangePtr::create(q, comp);
+        const auto componentRemovedChange = QComponentRemovedChangePtr::create(q, comp);  // TODOSYNC notify backend directly
         notifyObservers(componentRemovedChange);
     }
 
@@ -187,7 +187,7 @@ void QEntity::addComponent(QComponent *comp)
     d->registerPrivateDestructionHelper(comp, &QEntityPrivate::removeDestroyedComponent);
 
     if (d->m_changeArbiter) {
-        const auto componentAddedChange = QComponentAddedChangePtr::create(this, comp);
+        const auto componentAddedChange = QComponentAddedChangePtr::create(this, comp);     // TODOSYNC notify backend directly
         d->notifyObservers(componentAddedChange);
     }
     static_cast<QComponentPrivate *>(QComponentPrivate::get(comp))->addEntity(this);
diff --git a/src/core/nodes/qnode.cpp b/src/core/nodes/qnode.cpp
index 900c3f8ce..45d58bd8c 100644
--- a/src/core/nodes/qnode.cpp
+++ b/src/core/nodes/qnode.cpp
@@ -385,48 +385,13 @@ void QNodePrivate::unregisterNotifiedProperties()
 
 void QNodePrivate::propertyChanged(int propertyIndex)
 {
+    Q_UNUSED(propertyIndex);
+
     // Bail out early if we can to avoid the cost below
     if (m_blockNotifications)
         return;
 
-    const auto toBackendValue = [](const QVariant &data) -> QVariant
-    {
-        if (data.canConvert<QNode*>()) {
-            QNode *node = data.value<QNode*>();
-
-            // Ensure the node and all ancestors have issued their node creation changes.
-            // We can end up here if a newly created node with a parent is immediately set
-            // as a property on another node. In this case the deferred call to
-            // _q_postConstructorInit() will not have happened yet as the event
-            // loop will still be blocked. We need to do this for all ancestors,
-            // since the subtree of this node otherwise can end up on the backend
-            // with a reference to a non-existent parent.
-            if (node)
-                QNodePrivate::get(node)->_q_ensureBackendNodeCreated();
-
-            const QNodeId id = node ? node->id() : QNodeId();
-            return QVariant::fromValue(id);
-        }
-
-        return data;
-    };
-
-    Q_Q(QNode);
-
-    const QMetaProperty property = q->metaObject()->property(propertyIndex);
-
-    const QVariant data = property.read(q);
-
-    if (data.type() == QVariant::List) {
-        QSequentialIterable iterable = data.value<QSequentialIterable>();
-        QVariantList variants;
-        variants.reserve(iterable.size());
-        for (const auto &v : iterable)
-            variants.append(toBackendValue(v));
-        notifyPropertyChange(property.name(), variants);
-    } else {
-        notifyPropertyChange(property.name(), toBackendValue(data));
-    }
+    update();
 }
 
 /*!
@@ -498,8 +463,13 @@ void QNodePrivate::addEntityComponentToScene(QNode *root)
 // Called in the main thread by QScene -> following QEvent::childAdded / addChild
 void QNodePrivate::setArbiter(QLockableObserverInterface *arbiter)
 {
-    if (m_changeArbiter && m_changeArbiter != arbiter)
+    if (m_changeArbiter && m_changeArbiter != arbiter) {
         unregisterNotifiedProperties();
+
+        // Remove node from dirtyFrontendNodeList on old arbiter
+        Q_Q(QNode);
+        m_changeArbiter->removeDirtyFrontEndNode(q);
+    }
     m_changeArbiter = static_cast<QAbstractArbiter *>(arbiter);
     if (m_changeArbiter)
         registerNotifiedProperties();
@@ -626,26 +596,26 @@ QScene *QNodePrivate::scene() const
  */
 void QNodePrivate::notifyPropertyChange(const char *name, const QVariant &value)
 {
+    Q_UNUSED(name);
+    Q_UNUSED(value);
+
     // Bail out early if we can to avoid operator new
     if (m_blockNotifications)
         return;
 
-    auto e = QPropertyUpdatedChangePtr::create(m_id);
-    e->setPropertyName(name);
-    e->setValue(value);
-    notifyObservers(e);
+    update();
 }
 
 void QNodePrivate::notifyDynamicPropertyChange(const QByteArray &name, const QVariant &value)
 {
+    Q_UNUSED(name);
+    Q_UNUSED(value);
+
     // Bail out early if we can to avoid operator new
     if (m_blockNotifications)
         return;
 
-    auto e = QDynamicPropertyUpdatedChangePtr::create(m_id);
-    e->setPropertyName(name);
-    e->setValue(value);
-    notifyObservers(e);
+    update();
 }
 
 /*!
@@ -704,6 +674,14 @@ void QNodePrivate::updatePropertyTrackMode()
     }
 }
 
+void QNodePrivate::update()
+{
+    if (m_changeArbiter) {
+        Q_Q(QNode);
+        m_changeArbiter->addDirtyFrontEndNode(q);
+    }
+}
+
 /*!
     \internal
  */
diff --git a/src/core/nodes/qnode_p.h b/src/core/nodes/qnode_p.h
index 511a0e562..990c2caeb 100644
--- a/src/core/nodes/qnode_p.h
+++ b/src/core/nodes/qnode_p.h
@@ -89,6 +89,8 @@ public:
     void insertTree(QNode *treeRoot, int depth = 0);
     void updatePropertyTrackMode();
 
+    void update();
+
     Q_DECLARE_PUBLIC(QNode)
 
     // For now this just protects access to the m_changeArbiter.
diff --git a/src/core/qchangearbiter.cpp b/src/core/qchangearbiter.cpp
index 8cfc4b066..6ad72c895 100644
--- a/src/core/qchangearbiter.cpp
+++ b/src/core/qchangearbiter.cpp
@@ -266,6 +266,22 @@ void QChangeArbiter::sceneChangeEventWithLock(const QSceneChangeList &e)
     emit receivedChange();
 }
 
+void QChangeArbiter::addDirtyFrontEndNode(QNode *node)
+{
+    if (!m_dirtyFrontEndNodes.contains(node))
+        m_dirtyFrontEndNodes += node;
+}
+
+void QChangeArbiter::removeDirtyFrontEndNode(QNode *node)
+{
+    m_dirtyFrontEndNodes.removeOne(node);
+}
+
+QVector<QNode *> QChangeArbiter::takeDirtyFrontEndNodes()
+{
+    return std::move(m_dirtyFrontEndNodes);
+}
+
 // Either we have the postman or we could make the QChangeArbiter agnostic to the postman
 // but that would require adding it to every QObserverList in m_aspectObservations.
 void QChangeArbiter::setPostman(QAbstractPostman *postman)
diff --git a/src/core/qchangearbiter_p.h b/src/core/qchangearbiter_p.h
index c7d96b593..48fc4ca8c 100644
--- a/src/core/qchangearbiter_p.h
+++ b/src/core/qchangearbiter_p.h
@@ -81,6 +81,8 @@ class Q_3DCORE_PRIVATE_EXPORT QAbstractArbiter : public QLockableObserverInterfa
 {
 public:
     virtual QAbstractPostman *postman() const = 0;
+    virtual void addDirtyFrontEndNode(QNode *node) = 0;
+    virtual void removeDirtyFrontEndNode(QNode *node) = 0;
 };
 
 class Q_3DCORE_PRIVATE_EXPORT QChangeArbiter final
@@ -89,7 +91,7 @@ class Q_3DCORE_PRIVATE_EXPORT QChangeArbiter final
 {
     Q_OBJECT
 public:
-    explicit QChangeArbiter(QObject *parent = 0);
+    explicit QChangeArbiter(QObject *parent = nullptr);
     ~QChangeArbiter();
 
     void initialize(Qt3DCore::QAbstractAspectJobManager *jobManager);
@@ -109,6 +111,10 @@ public:
     void sceneChangeEventWithLock(const QSceneChangePtr &e) override; // QLockableObserverInterface impl
     void sceneChangeEventWithLock(const QSceneChangeList &e) override; // QLockableObserverInterface impl
 
+    void addDirtyFrontEndNode(QNode *node) override;
+    void removeDirtyFrontEndNode(QNode *node) override;
+    QVector<QNode *> takeDirtyFrontEndNodes();
+
     void setPostman(Qt3DCore::QAbstractPostman *postman);
     void setScene(Qt3DCore::QScene *scene);
 
@@ -155,6 +161,8 @@ private:
     QList<QChangeQueue *> m_lockingChangeQueues;
     QAbstractPostman *m_postman;
     QScene *m_scene;
+
+    QVector<QNode *> m_dirtyFrontEndNodes;
 };
 
 } // namespace Qt3DCore
diff --git a/src/core/qscene.cpp b/src/core/qscene.cpp
index c94272e90..1b8996e8d 100644
--- a/src/core/qscene.cpp
+++ b/src/core/qscene.cpp
@@ -68,7 +68,7 @@ public:
     QMultiHash<QNodeId, QObservableInterface *> m_observablesLookupTable;
     QHash<QObservableInterface *, QNodeId> m_observableToUuid;
     QHash<QNodeId, QScene::NodePropertyTrackData> m_nodePropertyTrackModeLookupTable;
-    QLockableObserverInterface *m_arbiter;
+    QAbstractArbiter *m_arbiter;
     QScopedPointer<NodePostConstructorInit> m_postConstructorInit;
     mutable QReadWriteLock m_lock;
     mutable QReadWriteLock m_nodePropertyTrackModeLock;
@@ -183,13 +183,13 @@ QNode *QScene::rootNode() const
     return d->m_rootNode;
 }
 
-void QScene::setArbiter(QLockableObserverInterface *arbiter)
+void QScene::setArbiter(QAbstractArbiter *arbiter)
 {
     Q_D(QScene);
     d->m_arbiter = arbiter;
 }
 
-QLockableObserverInterface *QScene::arbiter() const
+QAbstractArbiter *QScene::arbiter() const
 {
     Q_D(const QScene);
     return d->m_arbiter;
diff --git a/src/core/qscene_p.h b/src/core/qscene_p.h
index afcfb9b40..cdb85ebe6 100644
--- a/src/core/qscene_p.h
+++ b/src/core/qscene_p.h
@@ -65,6 +65,7 @@ namespace Qt3DCore {
 class QScenePrivate;
 class QAspectEngine;
 class NodePostConstructorInit;
+class QAbstractArbiter;
 
 typedef QList<QObservableInterface *> QObservableList;
 
@@ -88,8 +89,8 @@ public:
 
     QNode *rootNode() const;
 
-    void setArbiter(Qt3DCore::QLockableObserverInterface *arbiter);
-    Qt3DCore::QLockableObserverInterface *arbiter() const;
+    void setArbiter(QAbstractArbiter *arbiter);
+    QAbstractArbiter *arbiter() const;
 
     // Component -> Entities
     QVector<QNodeId> entitiesForComponent(QNodeId id) const;
diff --git a/src/render/framegraph/qmemorybarrier.cpp b/src/render/framegraph/qmemorybarrier.cpp
index b39537dcf..5da462f1b 100644
--- a/src/render/framegraph/qmemorybarrier.cpp
+++ b/src/render/framegraph/qmemorybarrier.cpp
@@ -140,7 +140,7 @@ void QMemoryBarrier::setWaitOperations(QMemoryBarrier::Operations waitOperations
     if (waitOperations != d->m_waitOperations) {
         d->m_waitOperations = waitOperations;
         emit waitOperationsChanged(waitOperations);
-        d->notifyPropertyChange("waitOperations", QVariant::fromValue(waitOperations));
+        d->notifyPropertyChange("waitOperations", QVariant::fromValue(waitOperations));  // TODOSYNC
     }
 }
 
diff --git a/src/render/frontend/qrendersettings.cpp b/src/render/frontend/qrendersettings.cpp
index 23f88eb10..6ddef6e8a 100644
--- a/src/render/frontend/qrendersettings.cpp
+++ b/src/render/frontend/qrendersettings.cpp
@@ -99,25 +99,25 @@ void QRenderSettingsPrivate::init()
 /*! \internal */
 void QRenderSettingsPrivate::_q_onPickingMethodChanged(QPickingSettings::PickMethod pickMethod)
 {
-    notifyPropertyChange("pickMethod", pickMethod);
+    notifyPropertyChange("pickMethod", pickMethod);// TODOSYNC
 }
 
 /*! \internal */
 void QRenderSettingsPrivate::_q_onPickResultModeChanged(QPickingSettings::PickResultMode pickResultMode)
 {
-    notifyPropertyChange("pickResultMode", pickResultMode);
+    notifyPropertyChange("pickResultMode", pickResultMode);// TODOSYNC
 }
 
 /*! \internal */
 void QRenderSettingsPrivate::_q_onFaceOrientationPickingModeChanged(QPickingSettings::FaceOrientationPickingMode faceOrientationPickingMode)
 {
-    notifyPropertyChange("faceOrientationPickingMode", faceOrientationPickingMode);
+    notifyPropertyChange("faceOrientationPickingMode", faceOrientationPickingMode);// TODOSYNC
 }
 
 /*! \internal */
 void QRenderSettingsPrivate::_q_onWorldSpaceToleranceChanged(float worldSpaceTolerance)
 {
-    notifyPropertyChange("pickWorldSpaceTolerance", worldSpaceTolerance);
+    notifyPropertyChange("pickWorldSpaceTolerance", worldSpaceTolerance);// TODOSYNC
 }
 
 QRenderSettings::QRenderSettings(Qt3DCore::QNode *parent)
diff --git a/tests/auto/animation/qadditiveclipblend/tst_qadditiveclipblend.cpp b/tests/auto/animation/qadditiveclipblend/tst_qadditiveclipblend.cpp
index c1f01394f..2df135969 100644
--- a/tests/auto/animation/qadditiveclipblend/tst_qadditiveclipblend.cpp
+++ b/tests/auto/animation/qadditiveclipblend/tst_qadditiveclipblend.cpp
@@ -197,25 +197,22 @@ private Q_SLOTS:
         {
             // WHEN
             addBlend.setAdditiveFactor(0.4f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "additiveFactor");
-            QCOMPARE(change->value().value<float>(), addBlend.additiveFactor());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &addBlend);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             addBlend.setAdditiveFactor(0.4f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -231,25 +228,22 @@ private Q_SLOTS:
         {
             // WHEN
             addBlend.setBaseClip(baseClip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "baseClip");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), addBlend.baseClip()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &addBlend);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             addBlend.setBaseClip(baseClip);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
@@ -264,25 +258,21 @@ private Q_SLOTS:
         {
             // WHEN
             addBlend.setAdditiveClip(additiveClip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "additiveClip");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), addBlend.additiveClip()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &addBlend);
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             addBlend.setAdditiveClip(additiveClip);
-            QCoreApplication::processEvents();
 
-            // THEN
+            //
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
diff --git a/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp b/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp
index 968ad8764..f446f1b0f 100644
--- a/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp
+++ b/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp
@@ -139,24 +139,22 @@ private Q_SLOTS:
         {
             // WHEN
             clip.setSource(QUrl(QStringLiteral("qrc:/toyplane.qlip")));
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "source");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &clip);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             clip.setSource(QStringLiteral("qrc:/toyplane.qlip"));
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/animation/qblendedclipanimator/tst_qblendedclipanimator.cpp b/tests/auto/animation/qblendedclipanimator/tst_qblendedclipanimator.cpp
index 56be94472..267ff03cb 100644
--- a/tests/auto/animation/qblendedclipanimator/tst_qblendedclipanimator.cpp
+++ b/tests/auto/animation/qblendedclipanimator/tst_qblendedclipanimator.cpp
@@ -261,25 +261,22 @@ private Q_SLOTS:
         {
             // WHEN
             blendedClipAnimator.setBlendTree(&blendRoot);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "blendTree");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), blendRoot.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             blendedClipAnimator.setBlendTree(&blendRoot);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -312,25 +309,22 @@ private Q_SLOTS:
         {
             // WHEN
             blendedClipAnimator.setChannelMapper(&channelMapper);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "channelMapper");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), channelMapper.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             blendedClipAnimator.setChannelMapper(&channelMapper);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -362,25 +356,22 @@ private Q_SLOTS:
         {
             // WHEN
             blendedClipAnimator.setRunning(true);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "running");
-            QCOMPARE(change->value().value<bool>(), blendedClipAnimator.isRunning());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             blendedClipAnimator.setRunning(true);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -395,25 +386,22 @@ private Q_SLOTS:
         {
             // WHEN
             blendedClipAnimator.setLoopCount(1584);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "loops");
-            QCOMPARE(change->value().value<int>(), blendedClipAnimator.loopCount());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             blendedClipAnimator.setLoopCount(1584);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -428,25 +416,22 @@ private Q_SLOTS:
         {
             // WHEN
             blendedClipAnimator.setNormalizedTime(0.5f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "normalizedTime");
-            QCOMPARE(change->value().value<float>(), blendedClipAnimator.normalizedTime());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             blendedClipAnimator.setNormalizedTime(0.5f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp b/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
index 78dff8b64..d217f3b0f 100644
--- a/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
+++ b/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
@@ -164,23 +164,18 @@ private Q_SLOTS:
         {
             // WHEN
             mapping.setChannelName(QStringLiteral("Scale"));
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "channelName");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toString(), mapping.channelName());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             mapping.setChannelName(QStringLiteral("Scale"));
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         {
diff --git a/tests/auto/animation/qchannelmapper/tst_qchannelmapper.cpp b/tests/auto/animation/qchannelmapper/tst_qchannelmapper.cpp
index bbc27fa41..e5a82e4c7 100644
--- a/tests/auto/animation/qchannelmapper/tst_qchannelmapper.cpp
+++ b/tests/auto/animation/qchannelmapper/tst_qchannelmapper.cpp
@@ -102,16 +102,12 @@ private Q_SLOTS:
 
         // WHEN
         mapper->setEnabled(false);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr propertyChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(propertyChange->propertyName(), "enabled");
-        QCOMPARE(propertyChange->value().toBool(), mapper->isEnabled());
-        QCOMPARE(propertyChange->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), mapper.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkMappingBookkeeping()
diff --git a/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp b/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
index a6e4e5eb8..37bd3e241 100644
--- a/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
+++ b/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
@@ -246,45 +246,35 @@ private Q_SLOTS:
         {
             // WHEN
             mapping.setChannelName(QStringLiteral("Scale"));
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "channelName");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toString(), mapping.channelName());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             mapping.setChannelName(QStringLiteral("Scale"));
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         {
             // WHEN
             mapping.setTarget(target.data());
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "target");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), mapping.target()->id());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             mapping.setTarget(target.data());
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         {
@@ -350,6 +340,9 @@ private Q_SLOTS:
         QFETCH(int, expectedType);
         QFETCH(int, expectedComponentCount);
 
+        Q_UNUSED(expectedType);
+        Q_UNUSED(expectedComponentCount);
+
         TestArbiter arbiter;
         Qt3DAnimation::QChannelMapping mapping;
         QScopedPointer<Qt3DCore::QEntity> target(new tst_QTargetEntity());
@@ -359,41 +352,18 @@ private Q_SLOTS:
         {
             // WHEN
             target->setProperty(propertyName.constData(), value);
-            mapping.setProperty(QString::fromLatin1(propertyName));
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 4);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), target.data());
 
-            // Automatic notification change when property is updated
-            auto change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), propertyName.constData());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value(), value);
+            arbiter.dirtyNodes.clear();
 
-            change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "type");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), expectedType);
-
-            change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "componentCount");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), expectedComponentCount);
-
-            change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "propertyName");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QVERIFY(qstrcmp(reinterpret_cast<const char *>(change->value().value<void *>()), propertyName.constData()) == 0);
-
-            arbiter.events.clear();
-
-            // WHEN
+            // THEN
             mapping.setProperty(QString::fromLatin1(propertyName));
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
diff --git a/tests/auto/animation/qclipanimator/tst_qclipanimator.cpp b/tests/auto/animation/qclipanimator/tst_qclipanimator.cpp
index 0b28228d9..711653819 100644
--- a/tests/auto/animation/qclipanimator/tst_qclipanimator.cpp
+++ b/tests/auto/animation/qclipanimator/tst_qclipanimator.cpp
@@ -248,25 +248,20 @@ private Q_SLOTS:
         {
             // WHEN
             animator.setClip(clip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "clip");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), clip->id());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &animator);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             animator.setClip(clip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         // GIVEN
@@ -274,25 +269,20 @@ private Q_SLOTS:
         {
             // WHEN
             animator.setChannelMapper(mapper);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "channelMapper");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), mapper->id());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &animator);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             animator.setChannelMapper(mapper);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         // GIVEN
@@ -300,49 +290,39 @@ private Q_SLOTS:
         {
             // WHEN
             animator.setClock(clock);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "clock");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), clock->id());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &animator);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             animator.setClock(clock);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         {
             // WHEN
             animator.setLoopCount(10);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "loops");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), animator.loopCount());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &animator);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             animator.setLoopCount(10);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/animation/qclipblendvalue/tst_qclipblendvalue.cpp b/tests/auto/animation/qclipblendvalue/tst_qclipblendvalue.cpp
index bdbee9380..de1e13a33 100644
--- a/tests/auto/animation/qclipblendvalue/tst_qclipblendvalue.cpp
+++ b/tests/auto/animation/qclipblendvalue/tst_qclipblendvalue.cpp
@@ -148,25 +148,20 @@ private Q_SLOTS:
         {
             // WHEN
             clipBlendNode.setClip(clip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "clip");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), clipBlendNode.clip()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &clipBlendNode);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             clipBlendNode.setClip(clip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
diff --git a/tests/auto/animation/qclock/tst_qclock.cpp b/tests/auto/animation/qclock/tst_qclock.cpp
index 34c70da7b..b6050ade7 100644
--- a/tests/auto/animation/qclock/tst_qclock.cpp
+++ b/tests/auto/animation/qclock/tst_qclock.cpp
@@ -136,26 +136,21 @@ private Q_SLOTS:
 
         {
             // WHEN
-            clock.setPlaybackRate(10.5);
-            QCoreApplication::processEvents();
+            clock.setPlaybackRate(10.5f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "playbackRate");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<double>(), clock.playbackRate());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &clock);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             clock.setPlaybackRate(10.5f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 };
diff --git a/tests/auto/animation/qlerpclipblend/tst_qlerpclipblend.cpp b/tests/auto/animation/qlerpclipblend/tst_qlerpclipblend.cpp
index 057f37786..1f7b646b4 100644
--- a/tests/auto/animation/qlerpclipblend/tst_qlerpclipblend.cpp
+++ b/tests/auto/animation/qlerpclipblend/tst_qlerpclipblend.cpp
@@ -197,25 +197,20 @@ private Q_SLOTS:
         {
             // WHEN
             lerpBlend.setBlendFactor(0.4f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "blendFactor");
-            QCOMPARE(change->value().value<float>(), lerpBlend.blendFactor());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &lerpBlend);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             lerpBlend.setBlendFactor(0.4f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -231,25 +226,20 @@ private Q_SLOTS:
         {
             // WHEN
             lerpBlend.setStartClip(startClip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "startClip");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), lerpBlend.startClip()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &lerpBlend);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             lerpBlend.setStartClip(startClip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
@@ -264,25 +254,20 @@ private Q_SLOTS:
         {
             // WHEN
             lerpBlend.setEndClip(endClip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "endClip");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), lerpBlend.endClip()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &lerpBlend);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             lerpBlend.setEndClip(endClip);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
diff --git a/tests/auto/animation/qskeletonmapping/tst_qskeletonmapping.cpp b/tests/auto/animation/qskeletonmapping/tst_qskeletonmapping.cpp
index 452292e9e..843af441e 100644
--- a/tests/auto/animation/qskeletonmapping/tst_qskeletonmapping.cpp
+++ b/tests/auto/animation/qskeletonmapping/tst_qskeletonmapping.cpp
@@ -149,23 +149,18 @@ private Q_SLOTS:
             // WHEN
             auto target = new Qt3DCore::QSkeleton();
             mapping.setSkeleton(target);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "skeleton");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), mapping.skeleton()->id());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             mapping.setSkeleton(target);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 };
diff --git a/tests/auto/core/common/testpostmanarbiter.cpp b/tests/auto/core/common/testpostmanarbiter.cpp
index ffc5bce5f..3fd8c80d1 100644
--- a/tests/auto/core/common/testpostmanarbiter.cpp
+++ b/tests/auto/core/common/testpostmanarbiter.cpp
@@ -72,7 +72,7 @@ void TestArbiter::sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &e)
 
 void TestArbiter::sceneChangeEventWithLock(const Qt3DCore::QSceneChangeList &e)
 {
-    events += QVector<Qt3DCore::QSceneChangePtr>::fromStdVector(e);
+    events += QVector<Qt3DCore::QSceneChangePtr>(e.begin(), e.end());
 }
 
 Qt3DCore::QAbstractPostman *TestArbiter::postman() const
@@ -88,4 +88,15 @@ void TestArbiter::setArbiterOnNode(Qt3DCore::QNode *node)
         setArbiterOnNode(n);
 }
 
+void TestArbiter::addDirtyFrontEndNode(Qt3DCore::QNode *node)
+{
+    if (!dirtyNodes.contains(node))
+        dirtyNodes << node;
+}
+
+void TestArbiter::removeDirtyFrontEndNode(Qt3DCore::QNode *node)
+{
+    dirtyNodes.removeOne(node);
+}
+
 QT_END_NAMESPACE
diff --git a/tests/auto/core/common/testpostmanarbiter.h b/tests/auto/core/common/testpostmanarbiter.h
index 7d7e4e49b..8dfb5874e 100644
--- a/tests/auto/core/common/testpostmanarbiter.h
+++ b/tests/auto/core/common/testpostmanarbiter.h
@@ -66,8 +66,11 @@ public:
     Qt3DCore::QAbstractPostman *postman() const final;
 
     QVector<Qt3DCore::QSceneChangePtr> events;
+    QVector<Qt3DCore::QNode *> dirtyNodes;
 
     void setArbiterOnNode(Qt3DCore::QNode *node);
+    void addDirtyFrontEndNode(Qt3DCore::QNode *node) final;
+    void removeDirtyFrontEndNode(Qt3DCore::QNode *node) final;
 
 private:
     TestPostman *m_postman;
diff --git a/tests/auto/core/nodes/tst_nodes.cpp b/tests/auto/core/nodes/tst_nodes.cpp
index d8ffbc361..dd6cc4892 100644
--- a/tests/auto/core/nodes/tst_nodes.cpp
+++ b/tests/auto/core/nodes/tst_nodes.cpp
@@ -103,6 +103,8 @@ private slots:
     void checkEnabledUpdate();
     void checkPropertyTrackModeUpdate();
     void checkTrackedPropertyNamesUpdate();
+
+    void checkNodeRemovedFromDirtyListOnDestruction();
 };
 
 class ObserverSpy;
@@ -113,8 +115,8 @@ public:
         : m_spy(spy)
     {}
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &) final {};
-    void setScene(Qt3DCore::QScene *) final {};
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &) final {}
+    void setScene(Qt3DCore::QScene *) final {}
     void notifyBackend(const Qt3DCore::QSceneChangePtr &change) final;
     bool shouldNotifyFrontend(const Qt3DCore::QSceneChangePtr &changee) final { Q_UNUSED(changee); return false; }
 
@@ -143,9 +145,7 @@ public:
     {
     }
 
-    ~ObserverSpy()
-    {
-    }
+    ~ObserverSpy();
 
     void sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &e) override
     {
@@ -169,10 +169,24 @@ public:
         return m_postman.data();
     }
 
+    void addDirtyFrontEndNode(Qt3DCore::QNode *node) final {
+        if (!dirtyNodes.contains(node))
+            dirtyNodes << node;
+    }
+
+    void removeDirtyFrontEndNode(Qt3DCore::QNode *node) final {
+        dirtyNodes.removeOne(node);
+    };
+
+    QVector<Qt3DCore::QNode *> dirtyNodes;
     QList<ChangeRecord> events;
     QScopedPointer<SimplePostman> m_postman;
 };
 
+ObserverSpy::~ObserverSpy()
+{
+}
+
 void SimplePostman::notifyBackend(const Qt3DCore::QSceneChangePtr &change)
 {
     m_spy->sceneChangeEventWithLock(change);
@@ -299,7 +313,7 @@ class MyQEntity : public Qt3DCore::QEntity
 {
     Q_OBJECT
 public:
-    explicit MyQEntity(Qt3DCore::QNode *parent = 0)
+    explicit MyQEntity(Qt3DCore::QNode *parent = nullptr)
         : QEntity(parent)
     {}
 
@@ -1244,10 +1258,10 @@ void tst_Nodes::checkConstructionWithParent()
     root->setNodeProperty(node);
 
     // THEN we should get one creation change, one child added change
-    // and one property change event, in that order.
+    // in that order.
     QCoreApplication::processEvents();
     QCOMPARE(root->children().count(), 1);
-    QCOMPARE(spy.events.size(), 3); // 1 creation change, 1 child added change, 1 property change
+    QCOMPARE(spy.events.size(), 2); // 1 creation change, 1 child added change
 
     // Ensure first event is child node's creation change
     const auto creationEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeCreatedChangeBase>();
@@ -1260,12 +1274,15 @@ void tst_Nodes::checkConstructionWithParent()
     QCOMPARE(newChildEvent->propertyName(), "children");
     QCOMPARE(newChildEvent->addedNodeId(), node->id());
 
-    // Ensure second and last event is property set change
-    const auto propertyEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyUpdatedChange>();
-    QVERIFY(!propertyEvent.isNull());
-    QCOMPARE(propertyEvent->subjectId(), root->id());
-    QCOMPARE(propertyEvent->propertyName(), "nodeProperty");
-    QCOMPARE(propertyEvent->value().value<Qt3DCore::QNodeId>(), node->id());
+    // Ensure the parent node is dirty
+    QCOMPARE(spy.dirtyNodes.size(), 1);
+    QCOMPARE(spy.dirtyNodes.front(), root.data());
+
+//    const auto propertyEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyUpdatedChange>();
+//    QVERIFY(!propertyEvent.isNull());
+//    QCOMPARE(propertyEvent->subjectId(), root->id());
+//    QCOMPARE(propertyEvent->propertyName(), "nodeProperty");
+//    QCOMPARE(propertyEvent->value().value<Qt3DCore::QNodeId>(), node->id());
 }
 
 void tst_Nodes::checkConstructionWithNonRootParent()
@@ -1298,7 +1315,7 @@ void tst_Nodes::checkConstructionWithNonRootParent()
     QCOMPARE(root->children().count(), 1);
     QCOMPARE(parent->children().count(), 1);
 
-    QCOMPARE(spy.events.size(), 4); // 2 creation changes, 1 child added changes, 1 property change
+    QCOMPARE(spy.events.size(), 3); // 2 creation changes, 1 child added changes
 
     // Ensure first event is parent node's creation change
     const auto parentCreationEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QNodeCreatedChangeBase>();
@@ -1316,11 +1333,8 @@ void tst_Nodes::checkConstructionWithNonRootParent()
     QCOMPARE(parentNewChildEvent->addedNodeId(), parent->id());
 
     // Ensure second and last event is property set change
-    const auto propertyEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyUpdatedChange>();
-    QVERIFY(!propertyEvent.isNull());
-    QCOMPARE(propertyEvent->subjectId(), root->id());
-    QCOMPARE(propertyEvent->propertyName(), "nodeProperty");
-    QCOMPARE(propertyEvent->value().value<Qt3DCore::QNodeId>(), child->id());
+    QCOMPARE(spy.dirtyNodes.size(), 1);
+    QCOMPARE(spy.dirtyNodes.front(), root.data());
 }
 
 void tst_Nodes::checkConstructionAsListElement()
@@ -1730,12 +1744,8 @@ void tst_Nodes::changeCustomProperty()
     // WHEN
     node->setCustomProperty(QStringLiteral("foo"));
     // THEN
-    QCOMPARE(spy.events.size(), 1);
-    QVERIFY(spy.events.first().wasLocked());
-    Qt3DCore::QPropertyUpdatedChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyUpdatedChange>();
-    QCOMPARE(event->type(), Qt3DCore::PropertyUpdated);
-    QCOMPARE(event->propertyName(), "customProperty");
-    QCOMPARE(event->value().toString(), QString("foo"));
+    QCOMPARE(spy.dirtyNodes.size(), 1);
+    QCOMPARE(spy.dirtyNodes.front(), node.data());
 }
 
 void tst_Nodes::checkDestruction()
@@ -1918,25 +1928,22 @@ void tst_Nodes::checkEnabledUpdate()
     {
         // WHEN
         node.setEnabled(false);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "enabled");
-        QCOMPARE(change->value().value<bool>(), node.isEnabled());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), &node);
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     {
         // WHEN
         node.setEnabled(false);
-        QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
     }
 
 }
@@ -1995,6 +2002,60 @@ void tst_Nodes::checkTrackedPropertyNamesUpdate()
 
 }
 
+void tst_Nodes::checkNodeRemovedFromDirtyListOnDestruction()
+{
+    // GIVEN
+    TestArbiter arbiter;
+    Qt3DCore::QScene scene;
+
+    {
+        // GIVEN
+        QScopedPointer<MyQNode> node(new MyQNode());
+        node->setArbiterAndScene(&arbiter, &scene);
+
+        // WHEN
+        node->setEnabled(false);
+
+        // THEN
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), node.data());
+
+        // WHEN
+        // scene should be unset and node removed from arbiter dirtyList
+        node.reset();
+
+        // THEN
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+    }
+    {
+        // GIVEN
+        QScopedPointer<MyQNode> node(new MyQNode());
+        node->setArbiterAndScene(&arbiter, &scene);
+
+
+        Qt3DCore::QNode *child = new Qt3DCore::QNode(node.data());
+        // Wait for deferred initialization of child node
+        QCoreApplication::processEvents();
+
+        // WHEN
+        child->setEnabled(false);
+
+        // THEN
+        QCOMPARE(arbiter.events.size(), 2); // nodeCreated + childAdded
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), child);
+
+        // WHEN
+        // scene should be unset and child node removed from arbiter dirtyList
+        node.reset();
+
+        // THEN
+        QCOMPARE(arbiter.events.size(), 2); // childRemoved + nodeDestroyed
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+    }
+}
 
 
 QTEST_MAIN(tst_Nodes)
diff --git a/tests/auto/core/qarmature/tst_qarmature.cpp b/tests/auto/core/qarmature/tst_qarmature.cpp
index f624b998f..b64757b5c 100644
--- a/tests/auto/core/qarmature/tst_qarmature.cpp
+++ b/tests/auto/core/qarmature/tst_qarmature.cpp
@@ -98,33 +98,22 @@ private Q_SLOTS:
 
         // WHEN
         QSkeleton *skeleton = new QSkeleton(armature.data());
-        QCoreApplication::processEvents();
-        arbiter.events.clear();
-
         armature->setSkeleton(skeleton);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "skeleton");
-        QCOMPARE(change->value().value<QNodeId>(), skeleton->id());
-        QCOMPARE(change->type(), PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), armature.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         armature->setSkeleton(nullptr);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "skeleton");
-        QCOMPARE(change->value().value<QNodeId>(), QNodeId());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), armature.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkSkeletonBookkeeping()
diff --git a/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp b/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
index 6574a91d9..e1b92f797 100644
--- a/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
+++ b/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
@@ -810,25 +810,19 @@ void tst_QChangeArbiter::distributePropertyChanges()
 
     // WHEN
     root->setProp1(root->prop1() + 1);
-    arbiter->syncChanges();
 
     // THEN
-    QVERIFY(!rootObserver->lastChange().isNull());
-    QCOMPARE(rootObserver->lastChange()->type(), Qt3DCore::PropertyUpdated);
-    Qt3DCore::QPropertyUpdatedChangePtr propChange = qSharedPointerDynamicCast<Qt3DCore::QPropertyUpdatedChange>(rootObserver->lastChange());
-    QCOMPARE(root->id(), propChange->subjectId());
-    QCOMPARE(QString(propChange->propertyName()), QString("prop1"));
+    auto dirtyNodes = arbiter->takeDirtyFrontEndNodes();
+    QCOMPARE(dirtyNodes.size(), 1);
+    QCOMPARE(dirtyNodes.front(), root);
 
     // WHEN
     root->setProp2(root->prop2() + 1.f);
-    arbiter->syncChanges();
 
     // THEN
-    QVERIFY(!rootObserver->lastChange().isNull());
-    QCOMPARE(rootObserver->lastChange()->type(), Qt3DCore::PropertyUpdated);
-    propChange = qSharedPointerDynamicCast<Qt3DCore::QPropertyUpdatedChange>(rootObserver->lastChange());
-    QCOMPARE(root->id(), propChange->subjectId());
-    QCOMPARE(QString(propChange->propertyName()), QString("prop2"));
+    dirtyNodes = arbiter->takeDirtyFrontEndNodes();
+    QCOMPARE(dirtyNodes.size(), 1);
+    QCOMPARE(dirtyNodes.front(), root);
 
     // Test change notifications made to an entity that was added to the scene
     // via QNode::setParent()
@@ -839,14 +833,11 @@ void tst_QChangeArbiter::distributePropertyChanges()
     tst_SimpleObserver *setParentChildObserver = new tst_SimpleObserver();
     arbiter->registerObserver(setParentChildObserver, setParentChild->id());
     setParentChild->setProp2(setParentChild->prop2() + 1.f);
-    arbiter->syncChanges();
 
     // THEN
-    QVERIFY(!setParentChildObserver->lastChange().isNull());
-    QCOMPARE(setParentChildObserver->lastChange()->type(), Qt3DCore::PropertyUpdated);
-    propChange = qSharedPointerDynamicCast<Qt3DCore::QPropertyUpdatedChange>(setParentChildObserver->lastChange());
-    QCOMPARE(setParentChild->id(), propChange->subjectId());
-    QCOMPARE(QString(propChange->propertyName()), QString("prop2"));
+    dirtyNodes = arbiter->takeDirtyFrontEndNodes();
+    QCOMPARE(dirtyNodes.size(), 1);
+    QCOMPARE(dirtyNodes.front(), setParentChild);
 
     // Test change notifications made to an entity that was added to the scene
     // via the QNode() constructor parent parameter
@@ -857,14 +848,11 @@ void tst_QChangeArbiter::distributePropertyChanges()
     tst_SimpleObserver *directChildObserver = new tst_SimpleObserver();
     arbiter->registerObserver(directChildObserver, directChild->id());
     directChild->setProp1(directChild->prop1() + 1);
-    arbiter->syncChanges();
 
     // THEN
-    QVERIFY(!directChildObserver->lastChange().isNull());
-    QCOMPARE(directChildObserver->lastChange()->type(), Qt3DCore::PropertyUpdated);
-    propChange = qSharedPointerDynamicCast<Qt3DCore::QPropertyUpdatedChange>(directChildObserver->lastChange());
-    QCOMPARE(directChild->id(), propChange->subjectId());
-    QCOMPARE(QString(propChange->propertyName()), QString("prop1"));
+    dirtyNodes = arbiter->takeDirtyFrontEndNodes();
+    QCOMPARE(dirtyNodes.size(), 1);
+    QCOMPARE(dirtyNodes.front(), directChild);
 
     Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
 }
diff --git a/tests/auto/core/qjoint/tst_qjoint.cpp b/tests/auto/core/qjoint/tst_qjoint.cpp
index ec1a45f90..436814f7f 100644
--- a/tests/auto/core/qjoint/tst_qjoint.cpp
+++ b/tests/auto/core/qjoint/tst_qjoint.cpp
@@ -317,69 +317,54 @@ private Q_SLOTS:
         {
             // WHEN
             joint.setScale(QVector3D(2.0f, 1.0f, 3.0f));
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "scale");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<QVector3D>(), joint.scale());
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &joint);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             joint.setScale(QVector3D(2.0f, 1.0f, 3.0f));
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         {
             // WHEN
             const auto newValue = QQuaternion::fromAxisAndAngle(1.0f, 1.0f, 1.0f, 45.0f);
             joint.setRotation(newValue);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "rotation");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<QQuaternion>(), newValue);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &joint);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             joint.setRotation(newValue);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         {
             // WHEN
             const QVector3D newValue(1.0f, 2.0f, 3.0f);
             joint.setTranslation(newValue);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "translation");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<QVector3D>(), newValue);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &joint);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             joint.setTranslation(newValue);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         {
@@ -387,23 +372,18 @@ private Q_SLOTS:
             QMatrix4x4 newValue;
             newValue.rotate(90.0f, 1.0f, 0.0f, 0.0f);
             joint.setInverseBindMatrix(newValue);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "inverseBindMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().value<QMatrix4x4>(), newValue);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &joint);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             joint.setInverseBindMatrix(newValue);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 };
diff --git a/tests/auto/core/qscene/qscene.pro b/tests/auto/core/qscene/qscene.pro
index 829130997..150b86f71 100644
--- a/tests/auto/core/qscene/qscene.pro
+++ b/tests/auto/core/qscene/qscene.pro
@@ -6,3 +6,5 @@ QT += testlib core-private 3dcore 3dcore-private
 
 SOURCES += \
     tst_qscene.cpp
+
+include(../common/common.pri)
diff --git a/tests/auto/core/qscene/tst_qscene.cpp b/tests/auto/core/qscene/tst_qscene.cpp
index 0a7e6d9b8..9a50d2abc 100644
--- a/tests/auto/core/qscene/tst_qscene.cpp
+++ b/tests/auto/core/qscene/tst_qscene.cpp
@@ -34,6 +34,7 @@
 #include <Qt3DCore/private/qobservableinterface_p.h>
 #include <Qt3DCore/private/qlockableobserverinterface_p.h>
 #include <private/qnode_p.h>
+#include "testpostmanarbiter.h"
 
 class tst_QScene : public QObject
 {
@@ -60,14 +61,6 @@ private slots:
     void nodeUpdatePropertyTrackData();
 };
 
-class tst_LockableObserver : public Qt3DCore::QLockableObserverInterface
-{
-public:
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &) override {}
-    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &) override {}
-    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangeList &) override {}
-};
-
 class tst_Observable : public Qt3DCore::QObservableInterface
 {
 public:
@@ -111,7 +104,7 @@ void tst_QScene::addObservable()
         observables.append(new tst_Observable());
 
     Qt3DCore::QScene *scene = new Qt3DCore::QScene;
-    scene->setArbiter(new tst_LockableObserver);
+    scene->setArbiter(new TestArbiter);
 
     // WHEN
     for (int i = 0; i < 5; i++)
@@ -146,7 +139,7 @@ void tst_QScene::addNodeObservable()
         nodes.append(new tst_Node());
 
     Qt3DCore::QScene *scene = new Qt3DCore::QScene;
-    scene->setArbiter(new tst_LockableObserver);
+    scene->setArbiter(new TestArbiter);
 
     // WHEN
     for (int i = 0; i < 10; i++)
@@ -171,7 +164,7 @@ void tst_QScene::removeObservable()
         observables.append(new tst_Observable());
 
     Qt3DCore::QScene *scene = new Qt3DCore::QScene;
-    scene->setArbiter(new tst_LockableObserver);
+    scene->setArbiter(new TestArbiter);
 
     // WHEN
     for (int i = 0; i < 5; i++)
@@ -222,7 +215,7 @@ void tst_QScene::removeNodeObservable()
         observables.append(new tst_Observable());
 
     Qt3DCore::QScene *scene = new Qt3DCore::QScene;
-    scene->setArbiter(new tst_LockableObserver);
+    scene->setArbiter(new TestArbiter);
 
     // WHEN
     scene->addObservable(node1);
diff --git a/tests/auto/core/qskeleton/tst_qskeleton.cpp b/tests/auto/core/qskeleton/tst_qskeleton.cpp
index f66e07cbe..6ad6e538c 100644
--- a/tests/auto/core/qskeleton/tst_qskeleton.cpp
+++ b/tests/auto/core/qskeleton/tst_qskeleton.cpp
@@ -109,33 +109,24 @@ private Q_SLOTS:
 
         // WHEN
         QJoint *joint = new QJoint(skeleton.data());
-        QCoreApplication::processEvents();
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         skeleton->setRootJoint(joint);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "rootJoint");
-        QCOMPARE(change->value().value<QNodeId>(), joint->id());
-        QCOMPARE(change->type(), PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), skeleton.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         skeleton->setRootJoint(nullptr);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "rootJoint");
-        QCOMPARE(change->value().value<QNodeId>(), QNodeId());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), skeleton.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkRootJointBookkeeping()
diff --git a/tests/auto/core/qskeletonloader/tst_qskeletonloader.cpp b/tests/auto/core/qskeletonloader/tst_qskeletonloader.cpp
index 1386429d4..7fcdc4bbe 100644
--- a/tests/auto/core/qskeletonloader/tst_qskeletonloader.cpp
+++ b/tests/auto/core/qskeletonloader/tst_qskeletonloader.cpp
@@ -169,12 +169,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "source");
-            QCOMPARE(change->type(), PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes[0], &skeleton);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -184,21 +183,20 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
-
         {
             // WHEN
             skeleton.setCreateJointsEnabled(true);
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "createJointsEnabled");
-            QCOMPARE(change->type(), PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes[0], &skeleton);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -208,6 +206,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.events.size(), 0);
         }
     }
 
@@ -242,6 +241,9 @@ private Q_SLOTS:
         QCOMPARE(spy.count(), 0);
         QCOMPARE(arbiter.events.size(), 0);
         QCOMPARE(status(), newStatus);
+
+        // Cleanup
+        QNodePrivate::get(this)->setArbiter(nullptr);
     }
 
     void checkRootJointPropertyUpdate()
@@ -266,8 +268,11 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(spy.count(), 1);
-        QCOMPARE(arbiter.events.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
         QVERIFY(rootJoint() != nullptr);
+
+        // Cleanup
+        QNodePrivate::get(this)->setArbiter(nullptr);
     }
 };
 
diff --git a/tests/auto/core/qtransform/tst_qtransform.cpp b/tests/auto/core/qtransform/tst_qtransform.cpp
index f5527ebf5..0590a8259 100644
--- a/tests/auto/core/qtransform/tst_qtransform.cpp
+++ b/tests/auto/core/qtransform/tst_qtransform.cpp
@@ -123,74 +123,54 @@ private Q_SLOTS:
 
         // WHEN
         transform->setTranslation(QVector3D(454.0f, 427.0f, 383.0f));
-        QCoreApplication::processEvents();
 
         // THEN
-        Qt3DCore::QPropertyUpdatedChangePtr change;
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "translation");
-        QCOMPARE(change->value().value<QVector3D>(), QVector3D(454.0f, 427.0f, 383.0f));
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         QQuaternion q = Qt3DCore::QTransform::fromAxisAndAngle(QVector3D(0.0f, 1.0f, 0.0f), 90.0f);
         transform->setRotation(q);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "rotation");
-        QCOMPARE(change->value().value<QQuaternion>(), q);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         transform->setScale3D(QVector3D(883.0f, 1200.0f, 1340.0f));
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "scale3D");
-        QCOMPARE(change->value().value<QVector3D>(), QVector3D(883.0f, 1200.0f, 1340.0f));
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         // Force the transform to update its matrix
         (void)transform->matrix();
 
         transform->setMatrix(QMatrix4x4());
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 3);
-        change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "scale3D");
-        QCOMPARE(change->value().value<QVector3D>(), QVector3D(1.0f, 1.0f, 1.0f));
-        change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "rotation");
-        QCOMPARE(change->value().value<QQuaternion>(), QQuaternion());
-        change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "translation");
-        QCOMPARE(change->value().value<QVector3D>(), QVector3D());
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
+
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         transform->setRotationX(20.0f);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "rotation");
-        QCOMPARE(change->value().value<QQuaternion>().toEulerAngles().x(), 20.0f);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkSignalEmittion()
diff --git a/tests/auto/input/qabstractaxisinput/tst_qabstractaxisinput.cpp b/tests/auto/input/qabstractaxisinput/tst_qabstractaxisinput.cpp
index 87f738367..44bb64ea4 100644
--- a/tests/auto/input/qabstractaxisinput/tst_qabstractaxisinput.cpp
+++ b/tests/auto/input/qabstractaxisinput/tst_qabstractaxisinput.cpp
@@ -72,16 +72,12 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         axisInput->setSourceDevice(device);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceDevice");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), device->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkSourceDeviceBookkeeping()
diff --git a/tests/auto/input/qactioninput/tst_qactioninput.cpp b/tests/auto/input/qactioninput/tst_qactioninput.cpp
index 3b6030673..be06cd8b2 100644
--- a/tests/auto/input/qactioninput/tst_qactioninput.cpp
+++ b/tests/auto/input/qactioninput/tst_qactioninput.cpp
@@ -101,16 +101,12 @@ private Q_SLOTS:
         // WHEN
         QVector<int> buttons = QVector<int>() << 555;
         actionInput->setButtons(buttons);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "buttons");
-        QCOMPARE(change->value().value<QVector<int>>(), buttons);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), actionInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         TestDevice *device = new TestDevice(actionInput.data());
@@ -118,16 +114,12 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         actionInput->setSourceDevice(device);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceDevice");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), device->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), actionInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkSourceDeviceBookkeeping()
diff --git a/tests/auto/input/qanalogaxisinput/tst_qanalogaxisinput.cpp b/tests/auto/input/qanalogaxisinput/tst_qanalogaxisinput.cpp
index da22ca165..c9abd0f4b 100644
--- a/tests/auto/input/qanalogaxisinput/tst_qanalogaxisinput.cpp
+++ b/tests/auto/input/qanalogaxisinput/tst_qanalogaxisinput.cpp
@@ -97,16 +97,12 @@ private Q_SLOTS:
 
         // WHEN
         axisInput->setAxis(350);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "axis");
-        QCOMPARE(change->value().toInt(), 350);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         TestDevice *device = new TestDevice(axisInput.data());
@@ -114,16 +110,12 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         axisInput->setSourceDevice(device);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceDevice");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), device->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 };
 
diff --git a/tests/auto/input/qaxisaccumulator/tst_qaxisaccumulator.cpp b/tests/auto/input/qaxisaccumulator/tst_qaxisaccumulator.cpp
index 2447c564d..492573fd8 100644
--- a/tests/auto/input/qaxisaccumulator/tst_qaxisaccumulator.cpp
+++ b/tests/auto/input/qaxisaccumulator/tst_qaxisaccumulator.cpp
@@ -131,42 +131,31 @@ private Q_SLOTS:
 
         // WHEN
         accumulator->setSourceAxis(axis);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceAxis");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), axis->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), accumulator.data());
+
+        arbiter.dirtyNodes.clear();
 
-        arbiter.events.clear();
 
         // WHEN
         accumulator->setScale(2.0f);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "scale");
-        QCOMPARE(change->value().toFloat(), 2.0f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), accumulator.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         accumulator->setSourceAxisType(Qt3DInput::QAxisAccumulator::Acceleration);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceAxisType");
-        QCOMPARE(change->value().value<Qt3DInput::QAxisAccumulator::SourceAxisType>(), Qt3DInput::QAxisAccumulator::Acceleration);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), accumulator.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkValuePropertyChanged()
diff --git a/tests/auto/input/qbuttonaxisinput/tst_qbuttonaxisinput.cpp b/tests/auto/input/qbuttonaxisinput/tst_qbuttonaxisinput.cpp
index 618c75d42..924c1f080 100644
--- a/tests/auto/input/qbuttonaxisinput/tst_qbuttonaxisinput.cpp
+++ b/tests/auto/input/qbuttonaxisinput/tst_qbuttonaxisinput.cpp
@@ -121,72 +121,50 @@ private Q_SLOTS:
         // WHEN
         QVector<int> buttons = QVector<int>() << 555;
         axisInput->setButtons(buttons);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "buttons");
-        QCOMPARE(change->value().value<QVector<int>>(), buttons);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         axisInput->setScale(1340.0f);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "scale");
-        QCOMPARE(change->value().toFloat(), 1340.0f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         TestDevice *device = new TestDevice(axisInput.data());
-        QCoreApplication::processEvents();
-        arbiter.events.clear();
 
         axisInput->setSourceDevice(device);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceDevice");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), device->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         axisInput->setAcceleration(42.0f);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "acceleration");
-        QCOMPARE(change->value().toFloat(), 42.0f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         axisInput->setDeceleration(43.0f);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "deceleration");
-        QCOMPARE(change->value().toFloat(), 43.0f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 };
 
diff --git a/tests/auto/input/qkeyboardhandler/tst_qkeyboardhandler.cpp b/tests/auto/input/qkeyboardhandler/tst_qkeyboardhandler.cpp
index f35d6490f..426a50237 100644
--- a/tests/auto/input/qkeyboardhandler/tst_qkeyboardhandler.cpp
+++ b/tests/auto/input/qkeyboardhandler/tst_qkeyboardhandler.cpp
@@ -96,16 +96,12 @@ private Q_SLOTS:
 
         // WHEN
         keyboardHandler->setFocus(true);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "focus");
-        QCOMPARE(change->value().toBool(), true);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), keyboardHandler.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         auto device = new Qt3DInput::QKeyboardDevice(keyboardHandler.data());
@@ -113,16 +109,12 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         keyboardHandler->setSourceDevice(device);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceDevice");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), device->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), keyboardHandler.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkSourceDeviceBookkeeping()
diff --git a/tests/auto/input/qmousedevice/tst_qmousedevice.cpp b/tests/auto/input/qmousedevice/tst_qmousedevice.cpp
index 6ea085184..58d260d16 100644
--- a/tests/auto/input/qmousedevice/tst_qmousedevice.cpp
+++ b/tests/auto/input/qmousedevice/tst_qmousedevice.cpp
@@ -161,25 +161,17 @@ private Q_SLOTS:
         {
             // WHEN
             mouseDevice.setSensitivity(0.7f);
-            QCoreApplication::processEvents();
-
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "sensitivity");
-            QCOMPARE(change->value().value<float>(), mouseDevice.sensitivity());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mouseDevice);
         }
 
         {
             // WHEN
             mouseDevice.setSensitivity(0.7f);
-            QCoreApplication::processEvents();
 
-            // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mouseDevice);
         }
 
     }
diff --git a/tests/auto/render/commons/testrenderer.h b/tests/auto/render/commons/testrenderer.h
index cc8ec502f..dbe69ace5 100644
--- a/tests/auto/render/commons/testrenderer.h
+++ b/tests/auto/render/commons/testrenderer.h
@@ -52,7 +52,7 @@ public:
     void shutdown() override {}
     void releaseGraphicsResources() override {}
     void render() override {}
-    void doRender(bool swapBuffers) override {}
+    void doRender(bool swapBuffers) override { Q_UNUSED(swapBuffers); }
     void cleanGraphicsResources() override {}
     bool isRunning() const override { return true; }
     bool shouldRender() override { return true; }
diff --git a/tests/auto/render/qabstractlight/tst_qabstractlight.cpp b/tests/auto/render/qabstractlight/tst_qabstractlight.cpp
index bc67148d2..011ad1036 100644
--- a/tests/auto/render/qabstractlight/tst_qabstractlight.cpp
+++ b/tests/auto/render/qabstractlight/tst_qabstractlight.cpp
@@ -149,26 +149,13 @@ private Q_SLOTS:
 
         light->setColor(Qt::red);
         light->setIntensity(0.8f); // change from the default of 0.5f
-        QCoreApplication::processEvents();
-
-        QCOMPARE(arbiter.events.size(), 2 * 2); // Due to contained shader data
-        for (int i = 0; i < 2; i++)
-            arbiter.events.removeAt(i);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events[0].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "color");
-        QCOMPARE(change->subjectId(), light->id());
-        QCOMPARE(change->value().value<QColor>(), QColor(Qt::red));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        change = arbiter.events[1].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "intensity");
-        QCOMPARE(change->subjectId(), light->id());
-        QCOMPARE(change->value().value<float>(), 0.8f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
 
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 2);
+        QVERIFY(arbiter.dirtyNodes[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
+        QCOMPARE(arbiter.dirtyNodes[1], light.data());
 
-        light->setColor(Qt::red);
-        QCoreApplication::processEvents();
+        arbiter.dirtyNodes.clear();
 
         QCOMPARE(arbiter.events.size(), 0);
 
@@ -186,33 +173,13 @@ private Q_SLOTS:
         pointLight->setConstantAttenuation(0.5f);
         pointLight->setLinearAttenuation(0.0f);     // No actual event triggered as 0.0f is default
         pointLight->setQuadraticAttenuation(1.0f);
-        QCoreApplication::processEvents();
-
-        QCOMPARE(arbiter.events.size(), 4 * 2); // Due to contained shader data
-        for (int i = 0; i < 4; i++)
-            arbiter.events.removeAt(i);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events[0].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "color");
-        QCOMPARE(change->subjectId(), pointLight->id());
-        QCOMPARE(change->value().value<QColor>(), QColor(Qt::green));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        change = arbiter.events[1].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "intensity");
-        QCOMPARE(change->subjectId(), pointLight->id());
-        QCOMPARE(change->value().value<float>(), 0.8f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        change = arbiter.events[2].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "constantAttenuation");
-        QCOMPARE(change->subjectId(), pointLight->id());
-        QCOMPARE(change->value().value<float>(), 0.5f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        change = arbiter.events[3].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "quadraticAttenuation");
-        QCOMPARE(change->subjectId(), pointLight->id());
-        QCOMPARE(change->value().value<float>(), 1.0f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
 
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 2);
+        QVERIFY(arbiter.dirtyNodes[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
+        QCOMPARE(arbiter.dirtyNodes[1], pointLight.data());
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkDirectionalLightPropertyUpdates()
@@ -224,28 +191,12 @@ private Q_SLOTS:
         dirLight->setColor(Qt::blue);
         dirLight->setIntensity(0.8f);
         dirLight->setWorldDirection(QVector3D(0.5f, 0.0f, -1.0f));
-        QCoreApplication::processEvents();
-
-        QCOMPARE(arbiter.events.size(), 3 * 2); // Due to contained shader data
-        for (int i = 0; i < 3; i++)
-            arbiter.events.removeAt(i);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events[0].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "color");
-        QCOMPARE(change->subjectId(), dirLight->id());
-        QCOMPARE(change->value().value<QColor>(), QColor(Qt::blue));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        change = arbiter.events[1].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "intensity");
-        QCOMPARE(change->subjectId(), dirLight->id());
-        QCOMPARE(change->value().value<float>(), 0.8f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        change = arbiter.events[2].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "worldDirection");
-        QCOMPARE(change->subjectId(), dirLight->id());
-        QCOMPARE(change->value().value<QVector3D>(), QVector3D(0.5f, 0.0f, -1.0f));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
 
-        arbiter.events.clear();
+        QCOMPARE(arbiter.dirtyNodes.size(), 2);
+        QVERIFY(arbiter.dirtyNodes[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
+        QCOMPARE(arbiter.dirtyNodes[1], dirLight.data());
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkSpotLightPropertyUpdates()
@@ -258,33 +209,12 @@ private Q_SLOTS:
         spotLight->setIntensity(0.8f);
         spotLight->setLocalDirection(QVector3D(0.5f, 0.0f, -1.0f));
         spotLight->setCutOffAngle(0.75f);
-        QCoreApplication::processEvents();
-
-        QCOMPARE(arbiter.events.size(), 4 * 2); // Due to contained shader data
-        for (int i = 0; i < 4; i++)
-            arbiter.events.removeAt(i);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events[0].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "color");
-        QCOMPARE(change->subjectId(), spotLight->id());
-        QCOMPARE(change->value().value<QColor>(), QColor(Qt::lightGray));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        change = arbiter.events[1].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "intensity");
-        QCOMPARE(change->subjectId(), spotLight->id());
-        QCOMPARE(change->value().value<float>(), 0.8f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        change = arbiter.events[2].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "localDirection");
-        QCOMPARE(change->subjectId(), spotLight->id());
-        QCOMPARE(change->value().value<QVector3D>(), QVector3D(0.5f, 0.0f, -1.0f).normalized());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        change = arbiter.events[3].staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "cutOffAngle");
-        QCOMPARE(change->subjectId(), spotLight->id());
-        QCOMPARE(change->value().value<float>(), 0.75f);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
 
-        arbiter.events.clear();
+        QCOMPARE(arbiter.dirtyNodes.size(), 2);
+        QVERIFY(arbiter.dirtyNodes[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
+        QCOMPARE(arbiter.dirtyNodes[1], spotLight.data());
+
+        arbiter.dirtyNodes.clear();
     }
 };
 
diff --git a/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp b/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp
index b6ae9dee8..04364e2d9 100644
--- a/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp
+++ b/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp
@@ -464,25 +464,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setFormat(Qt3DRender::QAbstractTexture::RG8_UNorm);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "format");
-            QCOMPARE(change->value().value<Qt3DRender::QAbstractTexture::TextureFormat>(), abstractTexture.format());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setFormat(Qt3DRender::QAbstractTexture::RG8_UNorm);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -497,25 +494,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setGenerateMipMaps(true);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "generateMipMaps");
-            QCOMPARE(change->value().value<bool>(), abstractTexture.generateMipMaps());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setGenerateMipMaps(true);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -530,25 +524,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setWidth(1024);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "width");
-            QCOMPARE(change->value().value<int>(), abstractTexture.width());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setWidth(1024);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -563,25 +554,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setHeight(256);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "height");
-            QCOMPARE(change->value().value<int>(), abstractTexture.height());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setHeight(256);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -596,25 +584,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setDepth(512);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "depth");
-            QCOMPARE(change->value().value<int>(), abstractTexture.depth());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setDepth(512);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -629,25 +614,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setMagnificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapLinear);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "magnificationFilter");
-            QCOMPARE(change->value().value<Qt3DRender::QAbstractTexture::Filter>(), abstractTexture.magnificationFilter());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setMagnificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapLinear);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -662,25 +644,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setMinificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapLinear);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "minificationFilter");
-            QCOMPARE(change->value().value<Qt3DRender::QAbstractTexture::Filter>(), abstractTexture.minificationFilter());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setMinificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapLinear);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -695,25 +674,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setMaximumAnisotropy(327.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "maximumAnisotropy");
-            QCOMPARE(change->value().value<float>(), abstractTexture.maximumAnisotropy());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setMaximumAnisotropy(327.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -728,25 +704,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setComparisonFunction(Qt3DRender::QAbstractTexture::CompareAlways);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "comparisonFunction");
-            QCOMPARE(change->value().value<Qt3DRender::QAbstractTexture::ComparisonFunction>(), abstractTexture.comparisonFunction());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setComparisonFunction(Qt3DRender::QAbstractTexture::CompareAlways);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -761,25 +734,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setComparisonMode(Qt3DRender::QAbstractTexture::CompareRefToTexture);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "comparisonMode");
-            QCOMPARE(change->value().value<Qt3DRender::QAbstractTexture::ComparisonMode>(), abstractTexture.comparisonMode());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setComparisonMode(Qt3DRender::QAbstractTexture::CompareRefToTexture);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -794,25 +764,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setLayers(64);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "layers");
-            QCOMPARE(change->value().value<int>(), abstractTexture.layers());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setLayers(64);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -827,25 +794,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTexture.setSamples(16);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "samples");
-            QCOMPARE(change->value().value<int>(), abstractTexture.samples());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTexture.setSamples(16);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qabstracttextureimage/tst_qabstracttextureimage.cpp b/tests/auto/render/qabstracttextureimage/tst_qabstracttextureimage.cpp
index 05029450a..a5e31b949 100644
--- a/tests/auto/render/qabstracttextureimage/tst_qabstracttextureimage.cpp
+++ b/tests/auto/render/qabstracttextureimage/tst_qabstracttextureimage.cpp
@@ -200,25 +200,20 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTextureImage.setMipLevel(9);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "mipLevel");
-            QCOMPARE(change->value().value<int>(), abstractTextureImage.mipLevel());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTextureImage);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTextureImage.setMipLevel(9);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -233,25 +228,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTextureImage.setLayer(12);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "layer");
-            QCOMPARE(change->value().value<int>(), abstractTextureImage.layer());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTextureImage);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTextureImage.setLayer(12);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -266,25 +258,22 @@ private Q_SLOTS:
         {
             // WHEN
             abstractTextureImage.setFace(Qt3DRender::QAbstractTexture::CubeMapPositiveY);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "face");
-            QCOMPARE(change->value().value<Qt3DRender::QAbstractTexture::CubeMapFace>(), abstractTextureImage.face());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTextureImage);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             abstractTextureImage.setFace(Qt3DRender::QAbstractTexture::CubeMapPositiveY);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qattribute/tst_qattribute.cpp b/tests/auto/render/qattribute/tst_qattribute.cpp
index 23532c435..588ce40db 100644
--- a/tests/auto/render/qattribute/tst_qattribute.cpp
+++ b/tests/auto/render/qattribute/tst_qattribute.cpp
@@ -85,7 +85,7 @@ private Q_SLOTS:
         QTest::newRow("defaultConstructed") << defaultConstructed;
 
         Qt3DRender::QAttribute *customVertex = new Qt3DRender::QAttribute();
-        Qt3DRender::QBuffer *buffer = new Qt3DRender::QBuffer(Qt3DRender::QBuffer::VertexBuffer);
+        Qt3DRender::QBuffer *buffer = new Qt3DRender::QBuffer();
         customVertex->setBuffer(buffer);
         customVertex->setAttributeType(Qt3DRender::QAttribute::VertexAttribute);
         customVertex->setCount(454);
@@ -98,7 +98,7 @@ private Q_SLOTS:
         QTest::newRow("vertex") << customVertex;
 
         Qt3DRender::QAttribute *customIndex = new Qt3DRender::QAttribute();
-        Qt3DRender::QBuffer *indexBuffer = new Qt3DRender::QBuffer(Qt3DRender::QBuffer::IndexBuffer);
+        Qt3DRender::QBuffer *indexBuffer = new Qt3DRender::QBuffer();
         customIndex->setBuffer(indexBuffer);
         customIndex->setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
         customIndex->setCount(383);
@@ -111,7 +111,7 @@ private Q_SLOTS:
         QTest::newRow("index") << customIndex;
 
         Qt3DRender::QAttribute *customIndirect = new Qt3DRender::QAttribute();
-        Qt3DRender::QBuffer *indirectBuffer = new Qt3DRender::QBuffer(Qt3DRender::QBuffer::DrawIndirectBuffer);
+        Qt3DRender::QBuffer *indirectBuffer = new Qt3DRender::QBuffer();
         customIndirect->setBuffer(indirectBuffer);
         customIndirect->setAttributeType(Qt3DRender::QAttribute::DrawIndirectAttribute);
         customIndirect->setCount(1);
@@ -160,134 +160,95 @@ private Q_SLOTS:
 
         // WHEN
         attribute->setVertexBaseType(Qt3DRender::QAttribute::Double);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "vertexBaseType");
-        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QAttribute::Double));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         attribute->setVertexSize(4);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "vertexSize");
-        QCOMPARE(change->value().value<uint>(), 4U);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         attribute->setName(QStringLiteral("Duntov"));
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "name");
-        QCOMPARE(change->value().value<QString>(), QStringLiteral("Duntov"));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         attribute->setCount(883);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "count");
-        QCOMPARE(change->value().value<uint>(), 883U);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         attribute->setByteStride(1340);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "byteStride");
-        QCOMPARE(change->value().value<uint>(), 1340U);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         attribute->setByteOffset(1584);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "byteOffset");
-        QCOMPARE(change->value().value<uint>(), 1584U);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         attribute->setDivisor(1450);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "divisor");
-        QCOMPARE(change->value().value<uint>(), 1450U);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         attribute->setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "attributeType");
-        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QAttribute::IndexAttribute));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QBuffer buf;
         attribute->setBuffer(&buf);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "buffer");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), buf.id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QBuffer buf2;
         attribute->setBuffer(&buf2);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "buffer");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), buf2.id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
 
+        arbiter.dirtyNodes.clear();
     }
 
     void checkBufferBookkeeping()
@@ -309,7 +270,7 @@ private Q_SLOTS:
         {
             // WHEN
             Qt3DRender::QAttribute someOtherAttribute;
-            QScopedPointer<Qt3DRender::QBuffer> buf(new Qt3DRender::QBuffer(Qt3DRender::QBuffer::VertexBuffer, &someOtherAttribute));
+            QScopedPointer<Qt3DRender::QBuffer> buf(new Qt3DRender::QBuffer(&someOtherAttribute));
             attribute->setBuffer(buf.data());
 
             // THEN
diff --git a/tests/auto/render/qblitframebuffer/tst_qblitframebuffer.cpp b/tests/auto/render/qblitframebuffer/tst_qblitframebuffer.cpp
index f6c7e1a8a..a53650945 100644
--- a/tests/auto/render/qblitframebuffer/tst_qblitframebuffer.cpp
+++ b/tests/auto/render/qblitframebuffer/tst_qblitframebuffer.cpp
@@ -119,217 +119,169 @@ private Q_SLOTS:
         // sourceRenderTarget
         // WHEN
         blitFramebuffer->setSource(sourceRenderTarget);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "source");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), sourceRenderTarget->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         blitFramebuffer->setSource(sourceRenderTarget);
-        QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         blitFramebuffer->setSource(nullptr);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "source");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), Qt3DCore::QNodeId());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // destinationRenderTarget
         // WHEN
         blitFramebuffer->setDestination(destinationRenderTarget);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "destination");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), destinationRenderTarget->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         blitFramebuffer->setDestination(destinationRenderTarget);
-        QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         blitFramebuffer->setDestination(nullptr);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "destination");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), Qt3DCore::QNodeId());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // sourceRect
         // WHEN
         blitFramebuffer->setSourceRect(QRect(0,0,1,1));
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceRect");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<QRect>(), QRect(0,0,1,1)) ;
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         blitFramebuffer->setSourceRect(QRect(0,0,1,1));
-        QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         blitFramebuffer->setSourceRect(QRect());
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceRect");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<QRect>(), QRect());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // destinationRect
         blitFramebuffer->setDestinationRect(QRect(0,0,1,1));
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "destinationRect");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<QRect>(), QRect(0,0,1,1)) ;
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         blitFramebuffer->setDestinationRect(QRect(0,0,1,1));
-        QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         blitFramebuffer->setDestinationRect(QRect());
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "destinationRect");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<QRect>(), QRect());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // sourceAttachmentPoint
         // WHEN
         blitFramebuffer->setSourceAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color1);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceAttachmentPoint");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<Qt3DRender::QRenderTargetOutput::AttachmentPoint>(), Qt3DRender::QRenderTargetOutput::Color1);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         blitFramebuffer->setSourceAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color1);
-        QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         blitFramebuffer->setSourceAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color0);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sourceAttachmentPoint");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<Qt3DRender::QRenderTargetOutput::AttachmentPoint>(), Qt3DRender::QRenderTargetOutput::Color0);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // destinationAttachmentPoint
         // WHEN
         blitFramebuffer->setDestinationAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color1);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "destinationAttachmentPoint");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<Qt3DRender::QRenderTargetOutput::AttachmentPoint>(), Qt3DRender::QRenderTargetOutput::Color1);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         blitFramebuffer->setDestinationAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color1);
-        QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         blitFramebuffer->setDestinationAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color0);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "destinationAttachmentPoint");
-        QCOMPARE(change->subjectId(), blitFramebuffer->id());
-        QCOMPARE(change->value().value<Qt3DRender::QRenderTargetOutput::AttachmentPoint>(), Qt3DRender::QRenderTargetOutput::Color0);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkSourceDestReset()
diff --git a/tests/auto/render/qbuffer/tst_qbuffer.cpp b/tests/auto/render/qbuffer/tst_qbuffer.cpp
index 21bedf744..8a9a25408 100644
--- a/tests/auto/render/qbuffer/tst_qbuffer.cpp
+++ b/tests/auto/render/qbuffer/tst_qbuffer.cpp
@@ -130,27 +130,23 @@ private Q_SLOTS:
 
         // WHEN
         buffer->setUsage(Qt3DRender::QBuffer::DynamicCopy);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "usage");
-        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QBuffer::DynamicCopy));
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         buffer->setData(QByteArrayLiteral("Z28"));
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "data");
-        QCOMPARE(change->value().value<QByteArray>(), QByteArrayLiteral("Z28"));
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QBufferDataGeneratorPtr functor(new TestFunctor(355));
@@ -159,7 +155,7 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+        auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
         QCOMPARE(change->propertyName(), "dataGenerator");
         QCOMPARE(change->value().value<Qt3DRender::QBufferDataGeneratorPtr>(), functor);
 
@@ -167,15 +163,13 @@ private Q_SLOTS:
 
         // WHEN
         buffer->setSyncData(true);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "syncData");
-        QCOMPARE(change->value().toBool(), true);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         buffer->updateData(1, QByteArrayLiteral("L1"));
diff --git a/tests/auto/render/qcameralens/tst_qcameralens.cpp b/tests/auto/render/qcameralens/tst_qcameralens.cpp
index adff66dc5..c4f684d5f 100644
--- a/tests/auto/render/qcameralens/tst_qcameralens.cpp
+++ b/tests/auto/render/qcameralens/tst_qcameralens.cpp
@@ -423,12 +423,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -438,6 +437,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -452,24 +452,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setNearPlane(5.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setNearPlane(5.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -484,24 +482,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setFarPlane(5.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setFarPlane(5.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -516,24 +512,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setFieldOfView(5.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setFieldOfView(5.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -548,24 +542,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setAspectRatio(9.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setAspectRatio(9.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -580,24 +572,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setLeft(0.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setLeft(0.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -612,24 +602,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setRight(24.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setRight(24.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -644,24 +632,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setBottom(-12.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setBottom(-12.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -676,24 +662,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setTop(12.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setTop(12.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -708,24 +692,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setExposure(2.0f);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "exposure");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setExposure(2.0f);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -743,25 +725,22 @@ private Q_SLOTS:
         {
             // WHEN
             cameraLens.setProjectionMatrix(m);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "projectionMatrix");
-            QCOMPARE(change->value().value<QMatrix4x4>(), m);
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             cameraLens.setProjectionMatrix(m);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.events.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qcameraselector/tst_qcameraselector.cpp b/tests/auto/render/qcameraselector/tst_qcameraselector.cpp
index c11dde57f..650e531c2 100644
--- a/tests/auto/render/qcameraselector/tst_qcameraselector.cpp
+++ b/tests/auto/render/qcameraselector/tst_qcameraselector.cpp
@@ -92,49 +92,41 @@ private Q_SLOTS:
         // WHEN
         Qt3DCore::QEntity *camera = new Qt3DCore::QEntity();
         cameraSelector->setCamera(camera);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "camera");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), camera->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), cameraSelector.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         cameraSelector->setCamera(camera);
-        QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         Qt3DCore::QEntity *camera2 = new Qt3DCore::QEntity();
         cameraSelector->setCamera(camera2);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "camera");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), camera2->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), cameraSelector.data());
+
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         cameraSelector->setCamera(nullptr);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "camera");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), Qt3DCore::QNodeId());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), cameraSelector.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkCameraBookkeeping()
diff --git a/tests/auto/render/qclearbuffers/tst_qclearbuffers.cpp b/tests/auto/render/qclearbuffers/tst_qclearbuffers.cpp
index ce1493e10..d2407229d 100644
--- a/tests/auto/render/qclearbuffers/tst_qclearbuffers.cpp
+++ b/tests/auto/render/qclearbuffers/tst_qclearbuffers.cpp
@@ -104,38 +104,30 @@ private Q_SLOTS:
 
         // WHEN
         clearBuffer->setBuffers(Qt3DRender::QClearBuffers::AllBuffers);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "buffers");
-        QCOMPARE(change->subjectId(), clearBuffer->id());
-        QCOMPARE(change->value().value<Qt3DRender::QClearBuffers::BufferType>(), Qt3DRender::QClearBuffers::AllBuffers);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), clearBuffer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         clearBuffer->setBuffers(Qt3DRender::QClearBuffers::AllBuffers);
-        QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         clearBuffer->setBuffers(Qt3DRender::QClearBuffers::ColorDepthBuffer);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "buffers");
-        QCOMPARE(change->subjectId(), clearBuffer->id());
-        QCOMPARE(change->value().value<Qt3DRender::QClearBuffers::BufferType>(), Qt3DRender::QClearBuffers::ColorDepthBuffer);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), clearBuffer.data());
+
+        arbiter.dirtyNodes.clear();
     }
 };
 
diff --git a/tests/auto/render/qcomputecommand/tst_qcomputecommand.cpp b/tests/auto/render/qcomputecommand/tst_qcomputecommand.cpp
index cc07120a2..b46cc4ea0 100644
--- a/tests/auto/render/qcomputecommand/tst_qcomputecommand.cpp
+++ b/tests/auto/render/qcomputecommand/tst_qcomputecommand.cpp
@@ -214,13 +214,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "workGroupX");
-            QCOMPARE(change->value().value<int>(), computeCommand.workGroupX());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -229,7 +227,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -244,25 +242,22 @@ private Q_SLOTS:
         {
             // WHEN
             computeCommand.setWorkGroupY(512);
-            QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "workGroupY");
-            QCOMPARE(change->value().value<int>(), computeCommand.workGroupY());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
             // WHEN
             computeCommand.setWorkGroupY(512);
-            QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -280,13 +275,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "workGroupZ");
-            QCOMPARE(change->value().value<int>(), computeCommand.workGroupZ());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -296,6 +289,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -313,13 +307,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "runType");
-            QCOMPARE(change->value().value<int>(), int(computeCommand.runType()));
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -329,6 +321,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
@@ -349,22 +342,20 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 2);
+            QCOMPARE(arbiter.events.size(), 1);
             {
                 auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
                 QCOMPARE(change->propertyName(), "frameCount");
                 QCOMPARE(change->value().value<int>(), 1);
                 QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
             }
-            {
-                auto change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "enabled");
-                QCOMPARE(change->value().value<bool>(), true);
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            }
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(computeCommand.isEnabled(), true);
 
             computeCommand.setEnabled(false);
             QCoreApplication::processEvents();
+            arbiter.dirtyNodes.clear();
             arbiter.events.clear();
         }
 
@@ -374,24 +365,21 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 2);
+            QCOMPARE(arbiter.events.size(), 1);
             {
                 auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
                 QCOMPARE(change->propertyName(), "frameCount");
                 QCOMPARE(change->value().value<int>(), 2);
                 QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
             }
-            {
-                auto change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "enabled");
-                QCOMPARE(change->value().value<bool>(), true);
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            }
-
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(computeCommand.isEnabled(), true);
 
             computeCommand.setEnabled(false);
             QCoreApplication::processEvents();
             arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -400,41 +388,22 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 5);
+            QCOMPARE(arbiter.events.size(), 1);
             {
                 auto change = arbiter.events.at(0).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "workGroupX");
-                QCOMPARE(change->value().value<int>(), 10);
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            }
-            {
-                auto change = arbiter.events.at(1).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "workGroupY");
-                QCOMPARE(change->value().value<int>(), 11);
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            }
-            {
-                auto change = arbiter.events.at(2).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "workGroupZ");
-                QCOMPARE(change->value().value<int>(), 12);
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            }
-            {
-                auto change = arbiter.events.at(3).staticCast<Qt3DCore::QPropertyUpdatedChange>();
                 QCOMPARE(change->propertyName(), "frameCount");
                 QCOMPARE(change->value().value<int>(), 1);
                 QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
             }
-            {
-                auto change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "enabled");
-                QCOMPARE(change->value().value<bool>(), true);
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            }
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(computeCommand.isEnabled(), true);
+            QCOMPARE(computeCommand.workGroupX(), 10);
+            QCOMPARE(computeCommand.workGroupY(), 11);
+            QCOMPARE(computeCommand.workGroupZ(), 12);
 
             computeCommand.setEnabled(false);
-            QCoreApplication::processEvents();
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
     }
 
diff --git a/tests/auto/render/qdispatchcompute/tst_qdispatchcompute.cpp b/tests/auto/render/qdispatchcompute/tst_qdispatchcompute.cpp
index 6fa55f370..7d1a36f11 100644
--- a/tests/auto/render/qdispatchcompute/tst_qdispatchcompute.cpp
+++ b/tests/auto/render/qdispatchcompute/tst_qdispatchcompute.cpp
@@ -189,13 +189,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "workGroupX");
-            QCOMPARE(change->value().value<int>(), dispatchCompute.workGroupX());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &dispatchCompute);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -205,6 +203,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -222,13 +221,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "workGroupY");
-            QCOMPARE(change->value().value<int>(), dispatchCompute.workGroupY());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &dispatchCompute);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -238,6 +235,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -255,13 +253,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "workGroupZ");
-            QCOMPARE(change->value().value<int>(), dispatchCompute.workGroupZ());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &dispatchCompute);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -271,6 +267,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qfilterkey/tst_qfilterkey.cpp b/tests/auto/render/qfilterkey/tst_qfilterkey.cpp
index 8c8381323..33691690e 100644
--- a/tests/auto/render/qfilterkey/tst_qfilterkey.cpp
+++ b/tests/auto/render/qfilterkey/tst_qfilterkey.cpp
@@ -166,13 +166,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "value");
-            QCOMPARE(change->value().value<QVariant>(), filterKey.value());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &filterKey);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -182,6 +180,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -199,13 +198,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "name");
-            QCOMPARE(change->value().value<QString>(), filterKey.name());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &filterKey);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -215,6 +212,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qframegraphnode/tst_qframegraphnode.cpp b/tests/auto/render/qframegraphnode/tst_qframegraphnode.cpp
index 1e19d8609..24febdac4 100644
--- a/tests/auto/render/qframegraphnode/tst_qframegraphnode.cpp
+++ b/tests/auto/render/qframegraphnode/tst_qframegraphnode.cpp
@@ -181,14 +181,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "enabled");
-        QCOMPARE(change->subjectId(), frameGraphNode->id());
-        QCOMPARE(change->value().toBool(), false);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), frameGraphNode.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         frameGraphNode->setEnabled(false);
@@ -196,20 +193,18 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         frameGraphNode->setEnabled(true);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "enabled");
-        QCOMPARE(change->subjectId(), frameGraphNode->id());
-        QCOMPARE(change->value().toBool(), true);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), frameGraphNode.data());
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkParentFrameNodeRetrieval()
diff --git a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
index 221d0f880..15cf98de0 100644
--- a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
+++ b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
@@ -162,117 +162,99 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "instanceCount");
-        QCOMPARE(change->value().value<int>(), 256);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         geometryRenderer->setVertexCount(1340);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "vertexCount");
-        QCOMPARE(change->value().value<int>(), 1340);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         geometryRenderer->setIndexOffset(883);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "indexOffset");
-        QCOMPARE(change->value().value<int>(), 883);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         geometryRenderer->setFirstInstance(1200);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "firstInstance");
-        QCOMPARE(change->value().value<int>(), 1200);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         geometryRenderer->setIndexBufferByteOffset(91);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "indexBufferByteOffset");
-        QCOMPARE(change->value().value<int>(), 91);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         geometryRenderer->setRestartIndexValue(65535);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "restartIndexValue");
-        QCOMPARE(change->value().value<int>(), 65535);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         geometryRenderer->setVerticesPerPatch(2);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "verticesPerPatch");
-        QCOMPARE(change->value().toInt(), 2);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         geometryRenderer->setPrimitiveRestartEnabled(true);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "primitiveRestartEnabled");
-        QCOMPARE(change->value().value<bool>(), true);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         geometryRenderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Patches);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "primitiveType");
-        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QGeometryRenderer::Patches));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QGeometryFactoryPtr factory(new TestFactory(555));
@@ -281,7 +263,7 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+        auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
         QCOMPARE(change->propertyName(), "geometryFactory");
         QCOMPARE(change->value().value<Qt3DRender::QGeometryFactoryPtr>(), factory);
         QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
@@ -294,13 +276,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr nodeAddedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(nodeAddedChange->propertyName(), "geometry");
-        QCOMPARE(nodeAddedChange->value().value<Qt3DCore::QNodeId>(), geom.id());
-        QCOMPARE(nodeAddedChange->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QGeometry geom2;
@@ -308,13 +288,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "geometry");
-        QCOMPARE(nodeRemovedChange->value().value<Qt3DCore::QNodeId>(), geom2.id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkGeometryBookkeeping()
diff --git a/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp b/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp
index ba357c8c9..7d4e5d45d 100644
--- a/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp
+++ b/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp
@@ -93,12 +93,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "thresholdType");
-            QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QLevelOfDetail::ProjectedScreenPixelSizeThreshold));
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), lod.data());
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -108,12 +107,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "thresholds");
-            QCOMPARE(change->value().value<decltype(thresholds)>(), thresholds);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), lod.data());
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
     }
 };
diff --git a/tests/auto/render/qmaterial/tst_qmaterial.cpp b/tests/auto/render/qmaterial/tst_qmaterial.cpp
index dc6fe7789..5b24c6127 100644
--- a/tests/auto/render/qmaterial/tst_qmaterial.cpp
+++ b/tests/auto/render/qmaterial/tst_qmaterial.cpp
@@ -253,37 +253,26 @@ private Q_SLOTS:
         // WHEN
         Qt3DRender::QEffect effect;
         material->setEffect(&effect);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "effect");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), effect.id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), material.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // GIVEN
         TestArbiter arbiter2;
         QScopedPointer<TestMaterial> material2(new TestMaterial());
         arbiter2.setArbiterOnNode(material2.data());
 
-        QCoreApplication::processEvents();
-        // Clear events trigger by child generation of TestMnterial
-        arbiter2.events.clear();
-
         // WHEN
         material2->setEffect(&effect);
-        QCoreApplication::processEvents();
 
         // THEN
-        qDebug() << Q_FUNC_INFO << arbiter2.events.size();
-        QCOMPARE(arbiter2.events.size(), 1);
-        change = arbiter2.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "effect");
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), effect.id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter2.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter2.dirtyNodes.front(), material2.data());
+
+        arbiter2.dirtyNodes.clear();
     }
 
     void checkDynamicParametersAddedUpdates()
@@ -364,93 +353,64 @@ private Q_SLOTS:
         TestMaterial *material = new TestMaterial();
         arbiter.setArbiterOnNode(material);
 
-        QCoreApplication::processEvents();
-        // Clear events trigger by child generation of TestMnterial
-        arbiter.events.clear();
-
         // WHEN
         const QByteArray vertexCode = QByteArrayLiteral("new vertex shader code");
         material->m_shaderProgram->setVertexShaderCode(vertexCode);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "vertexShaderCode");
-        QCOMPARE(change->value().value<QByteArray>(), vertexCode);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         const QByteArray fragmentCode = QByteArrayLiteral("new fragment shader code");
         material->m_shaderProgram->setFragmentShaderCode(fragmentCode);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "fragmentShaderCode");
-        QCOMPARE(change->value().value<QByteArray>(), fragmentCode);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
 
+        arbiter.dirtyNodes.clear();
         // WHEN
         const QByteArray geometryCode = QByteArrayLiteral("new geometry shader code");
         material->m_shaderProgram->setGeometryShaderCode(geometryCode);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "geometryShaderCode");
-        QCOMPARE(change->value().value<QByteArray>(), geometryCode);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         const QByteArray computeCode = QByteArrayLiteral("new compute shader code");
         material->m_shaderProgram->setComputeShaderCode(computeCode);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "computeShaderCode");
-        QCOMPARE(change->value().value<QByteArray>(), computeCode);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         const QByteArray tesselControlCode = QByteArrayLiteral("new tessellation control shader code");
         material->m_shaderProgram->setTessellationControlShaderCode(tesselControlCode);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "tessellationControlShaderCode");
-        QCOMPARE(change->value().value<QByteArray>(), tesselControlCode);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         const QByteArray tesselEvalCode = QByteArrayLiteral("new tessellation eval shader code");
         material->m_shaderProgram->setTessellationEvaluationShaderCode(tesselEvalCode);
-        QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "tessellationEvaluationShaderCode");
-        QCOMPARE(change->value().value<QByteArray>(), tesselEvalCode);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkEffectBookkeeping()
diff --git a/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp b/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp
index 25ee10cad..3be43f677 100644
--- a/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp
+++ b/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp
@@ -148,13 +148,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "waitOperations");
-            QCOMPARE(change->value().value<Qt3DRender::QMemoryBarrier::Operations>(), memoryBarrier.waitOperations());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &memoryBarrier);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -164,6 +162,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp b/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
index 2f351331a..53c0ec939 100644
--- a/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
+++ b/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
@@ -156,14 +156,11 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 1);
-                QCOMPARE(picker.priority(), 883);
-                auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "priority");
-                QCOMPARE(change->value().value<int>(), picker.priority());
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-                arbiter.events.clear();
+                QCOMPARE(arbiter.events.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes.size(), 1);
+                QCOMPARE(arbiter.dirtyNodes.front(), &picker);
+
+                arbiter.dirtyNodes.clear();
             }
 
             {
@@ -173,6 +170,7 @@ private Q_SLOTS:
 
                 // THEN
                 QCOMPARE(arbiter.events.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes.size(), 0);
             }
         }
         {
@@ -182,14 +180,11 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 1);
-                QCOMPARE(picker.isDragEnabled(), true);
-                auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "dragEnabled");
-                QCOMPARE(change->value().value<bool>(), picker.isDragEnabled());
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-                arbiter.events.clear();
+                QCOMPARE(arbiter.events.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes.size(), 1);
+                QCOMPARE(arbiter.dirtyNodes.front(), &picker);
+
+                arbiter.dirtyNodes.clear();
             }
 
             {
@@ -199,6 +194,7 @@ private Q_SLOTS:
 
                 // THEN
                 QCOMPARE(arbiter.events.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes.size(), 0);
             }
         }
         {
@@ -208,14 +204,11 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 1);
-                QCOMPARE(picker.isHoverEnabled(), true);
-                auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "hoverEnabled");
-                QCOMPARE(change->value().value<bool>(), picker.isHoverEnabled());
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-                arbiter.events.clear();
+                QCOMPARE(arbiter.events.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes.size(), 1);
+                QCOMPARE(arbiter.dirtyNodes.front(), &picker);
+
+                arbiter.dirtyNodes.clear();
             }
 
             {
@@ -225,6 +218,7 @@ private Q_SLOTS:
 
                 // THEN
                 QCOMPARE(arbiter.events.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes.size(), 0);
             }
         }
     }
@@ -272,13 +266,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "hoverEnabled");
-        QCOMPARE(change->value().toBool(), true);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), objectPicker.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkBackendUpdates_data()
diff --git a/tests/auto/render/qparameter/tst_qparameter.cpp b/tests/auto/render/qparameter/tst_qparameter.cpp
index d5957db27..77f9daae8 100644
--- a/tests/auto/render/qparameter/tst_qparameter.cpp
+++ b/tests/auto/render/qparameter/tst_qparameter.cpp
@@ -166,13 +166,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "name");
-            QCOMPARE(change->value().value<QString>(), parameter.name());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &parameter);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -182,6 +180,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -199,13 +198,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "value");
-            QCOMPARE(change->value().value<QVariant>(), parameter.value());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &parameter);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -215,6 +212,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         // WHEN -> QNode -> QNodeId
@@ -227,13 +225,11 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 1);
-                auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-                QCOMPARE(change->propertyName(), "value");
-                QCOMPARE(change->value().value<Qt3DCore::QNodeId>(),testEntity.id());
-                QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+                QCOMPARE(arbiter.events.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes.size(), 1);
+                QCOMPARE(arbiter.dirtyNodes.front(), &parameter);
 
-                arbiter.events.clear();
+                arbiter.dirtyNodes.clear();
             }
 
             {
@@ -243,6 +239,7 @@ private Q_SLOTS:
 
                 // THEN
                 QCOMPARE(arbiter.events.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes.size(), 0);
             }
 
         }
diff --git a/tests/auto/render/qproximityfilter/tst_qproximityfilter.cpp b/tests/auto/render/qproximityfilter/tst_qproximityfilter.cpp
index 890d6ee3e..aa6be3143 100644
--- a/tests/auto/render/qproximityfilter/tst_qproximityfilter.cpp
+++ b/tests/auto/render/qproximityfilter/tst_qproximityfilter.cpp
@@ -176,13 +176,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "entity");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), proximityFilter.entity()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &proximityFilter);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -192,6 +190,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -209,13 +208,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "distanceThreshold");
-            QCOMPARE(change->value().value<float>(), proximityFilter.distanceThreshold());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &proximityFilter);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -225,6 +222,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qraycaster/tst_qraycaster.cpp b/tests/auto/render/qraycaster/tst_qraycaster.cpp
index 43b317f00..c7f819a34 100644
--- a/tests/auto/render/qraycaster/tst_qraycaster.cpp
+++ b/tests/auto/render/qraycaster/tst_qraycaster.cpp
@@ -111,13 +111,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "origin");
-        QCOMPARE(change->value().value<QVector3D>(), QVector3D(1., 1., 1.));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), rayCaster.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         auto layer = new Qt3DRender::QLayer(rayCaster.data());
diff --git a/tests/auto/render/qrenderpass/tst_qrenderpass.cpp b/tests/auto/render/qrenderpass/tst_qrenderpass.cpp
index bcc8e9313..38b66de94 100644
--- a/tests/auto/render/qrenderpass/tst_qrenderpass.cpp
+++ b/tests/auto/render/qrenderpass/tst_qrenderpass.cpp
@@ -305,13 +305,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "shaderProgram");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), renderPass.shaderProgram()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -321,6 +319,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qrendersettings/tst_qrendersettings.cpp b/tests/auto/render/qrendersettings/tst_qrendersettings.cpp
index 6f182cbeb..224996579 100644
--- a/tests/auto/render/qrendersettings/tst_qrendersettings.cpp
+++ b/tests/auto/render/qrendersettings/tst_qrendersettings.cpp
@@ -253,13 +253,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "renderPolicy");
-            QCOMPARE(change->value().value<Qt3DRender::QRenderSettings::RenderPolicy>(), renderSettings.renderPolicy());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -269,6 +267,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -287,13 +286,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "activeFrameGraph");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), viewport.id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -303,6 +300,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -322,13 +320,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "pickMethod");
-            QCOMPARE(change->value().value<Qt3DRender::QPickingSettings::PickMethod>(), pickingSettings->pickMethod());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -338,6 +334,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -357,13 +354,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "pickResultMode");
-            QCOMPARE(change->value().value<Qt3DRender::QPickingSettings::PickResultMode>(), pickingSettings->pickResultMode());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -373,6 +368,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -392,13 +388,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "faceOrientationPickingMode");
-            QCOMPARE(change->value().value<Qt3DRender::QPickingSettings::FaceOrientationPickingMode>(), pickingSettings->faceOrientationPickingMode());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -408,6 +402,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -427,13 +422,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "pickWorldSpaceTolerance");
-            QCOMPARE(change->value().toFloat(), pickingSettings->worldSpaceTolerance());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -443,6 +436,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qrenderstate/tst_qrenderstate.cpp b/tests/auto/render/qrenderstate/tst_qrenderstate.cpp
index 596aa9553..63319b42c 100644
--- a/tests/auto/render/qrenderstate/tst_qrenderstate.cpp
+++ b/tests/auto/render/qrenderstate/tst_qrenderstate.cpp
@@ -200,18 +200,18 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<QPropertyUpdatedChange>();
-        QVERIFY(change->propertyName() == propertyName);
-        QCOMPARE(change->subjectId(), frontend1->id());
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), frontend1);
 
-        // WHEN
-        backend1->sceneChangeEvent(change.staticCast<QSceneChange>());
+        // TODOSYNC update when syncFromFrontendNode is implemented
+//        // WHEN
+//        backend1->sceneChangeEvent(change.staticCast<QSceneChange>());
 
-        // THEN
-        QVERIFY(backend1->impl() == backend2->impl());
+//        // THEN
+//        QVERIFY(backend1->impl() == backend2->impl());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkStencilUpdates_data()
diff --git a/tests/auto/render/qrendersurfaceselector/tst_qrendersurfaceselector.cpp b/tests/auto/render/qrendersurfaceselector/tst_qrendersurfaceselector.cpp
index 982a58b2b..1004921d8 100644
--- a/tests/auto/render/qrendersurfaceselector/tst_qrendersurfaceselector.cpp
+++ b/tests/auto/render/qrendersurfaceselector/tst_qrendersurfaceselector.cpp
@@ -261,13 +261,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "surface");
-            QCOMPARE(change->value().value<QObject *>(), renderSurfaceSelector.surface());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderSurfaceSelector);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -277,6 +275,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
         // Prevents crashes with temporary window being destroyed
@@ -296,13 +295,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "externalRenderTargetSize");
-            QCOMPARE(change->value().value<QSize>(), renderSurfaceSelector.externalRenderTargetSize());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderSurfaceSelector);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -312,6 +309,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -329,13 +327,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "surfacePixelRatio");
-            QCOMPARE(change->value().value<float>(), renderSurfaceSelector.surfacePixelRatio());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderSurfaceSelector);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -345,6 +341,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qrendertargetoutput/tst_qrendertargetoutput.cpp b/tests/auto/render/qrendertargetoutput/tst_qrendertargetoutput.cpp
index c847095dc..d501bc4e5 100644
--- a/tests/auto/render/qrendertargetoutput/tst_qrendertargetoutput.cpp
+++ b/tests/auto/render/qrendertargetoutput/tst_qrendertargetoutput.cpp
@@ -247,13 +247,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "attachmentPoint");
-            QCOMPARE(change->value().value<Qt3DRender::QRenderTargetOutput::AttachmentPoint>(), renderTargetOutput.attachmentPoint());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -263,6 +261,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -281,13 +280,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "texture");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), renderTargetOutput.texture()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -297,6 +294,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -314,13 +312,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "mipLevel");
-            QCOMPARE(change->value().value<int>(), renderTargetOutput.mipLevel());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -330,6 +326,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -347,13 +344,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "layer");
-            QCOMPARE(change->value().value<int>(), renderTargetOutput.layer());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -363,6 +358,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -380,13 +376,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "face");
-            QCOMPARE(change->value().value<Qt3DRender::QAbstractTexture::CubeMapFace>(), renderTargetOutput.face());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -396,6 +390,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
index 6b53ab733..f525f1254 100644
--- a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
+++ b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
@@ -117,14 +117,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "target");
-        QCOMPARE(change->subjectId(), renderTargetSelector->id());
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), target->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         renderTargetSelector->setTarget(target);
@@ -132,20 +129,18 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         renderTargetSelector->setTarget(nullptr);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "target");
-        QCOMPARE(change->subjectId(), renderTargetSelector->id());
-        QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), Qt3DCore::QNodeId());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> outputs;
@@ -155,7 +150,7 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+        auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
         QCOMPARE(change->propertyName(), "outputs");
         QCOMPARE(change->subjectId(), renderTargetSelector->id());
         QCOMPARE(change->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >(), outputs);
@@ -182,7 +177,6 @@ private Q_SLOTS:
         QCOMPARE(change->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >(), QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>());
         QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
 
-
         arbiter.events.clear();
     }
 
diff --git a/tests/auto/render/qscene2d/tst_qscene2d.cpp b/tests/auto/render/qscene2d/tst_qscene2d.cpp
index 846207456..5ea2dd110 100644
--- a/tests/auto/render/qscene2d/tst_qscene2d.cpp
+++ b/tests/auto/render/qscene2d/tst_qscene2d.cpp
@@ -222,13 +222,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "output");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), scene2d.output()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &scene2d);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -238,6 +236,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -255,14 +254,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "renderPolicy");
-            QCOMPARE(change->value().value<Qt3DRender::Quick::QScene2D::RenderPolicy>(),
-                     scene2d.renderPolicy());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-            arbiter.events.clear();
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &scene2d);
+
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -272,6 +268,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -289,13 +286,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "mouseEnabled");
-            QCOMPARE(change->value().toBool(), scene2d.isMouseEnabled());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &scene2d);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -305,6 +300,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qsceneloader/tst_qsceneloader.cpp b/tests/auto/render/qsceneloader/tst_qsceneloader.cpp
index d5d3feec8..381960c42 100644
--- a/tests/auto/render/qsceneloader/tst_qsceneloader.cpp
+++ b/tests/auto/render/qsceneloader/tst_qsceneloader.cpp
@@ -130,34 +130,34 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "source");
-        QCOMPARE(change->value().value<QUrl>(), sourceUrl);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), sceneLoader.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
-    void checkStatusPropertyUpdate()
-    {
-        // GIVEN
-        qRegisterMetaType<Qt3DRender::QSceneLoader::Status>("Status");
-        TestArbiter arbiter;
-        QScopedPointer<Qt3DRender::QSceneLoader> sceneLoader(new Qt3DRender::QSceneLoader());
-        arbiter.setArbiterOnNode(sceneLoader.data());
-        QSignalSpy spy(sceneLoader.data(), SIGNAL(statusChanged(Status)));
+    // DEPRECATED
+//    void checkStatusPropertyUpdate()
+//    {
+//        // GIVEN
+//        qRegisterMetaType<Qt3DRender::QSceneLoader::Status>("Status");
+//        TestArbiter arbiter;
+//        QScopedPointer<Qt3DRender::QSceneLoader> sceneLoader(new Qt3DRender::QSceneLoader());
+//        arbiter.setArbiterOnNode(sceneLoader.data());
+//        QSignalSpy spy(sceneLoader.data(), SIGNAL(statusChanged(Status)));
 
 
-        // WHEN
-        const Qt3DRender::QSceneLoader::Status newStatus = Qt3DRender::QSceneLoader::Ready;
-        sceneLoader->setStatus(newStatus);
+//        // WHEN
+//        const Qt3DRender::QSceneLoader::Status newStatus = Qt3DRender::QSceneLoader::Ready;
+//        sceneLoader->setStatus(newStatus);
 
-        // THEN
-        QVERIFY(arbiter.events.empty());
-        QCOMPARE(spy.count(), 1);
+//        // THEN
+//        QVERIFY(arbiter.events.empty());
+//        QCOMPARE(spy.count(), 1);
 
-        spy.clear();
-    }
+//        spy.clear();
+//    }
 
     void checkPropertyChanges()
     {
diff --git a/tests/auto/render/qscreenraycaster/tst_qscreenraycaster.cpp b/tests/auto/render/qscreenraycaster/tst_qscreenraycaster.cpp
index fd67da175..60f386dd9 100644
--- a/tests/auto/render/qscreenraycaster/tst_qscreenraycaster.cpp
+++ b/tests/auto/render/qscreenraycaster/tst_qscreenraycaster.cpp
@@ -105,13 +105,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.last().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "position");
-        QCOMPARE(change->value().value<QPoint>(), QPoint(200, 200));
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), rayCaster.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 
     void checkBackendUpdates_data()
diff --git a/tests/auto/render/qshaderimage/tst_qshaderimage.cpp b/tests/auto/render/qshaderimage/tst_qshaderimage.cpp
index 0a12e806f..67c9ca39b 100644
--- a/tests/auto/render/qshaderimage/tst_qshaderimage.cpp
+++ b/tests/auto/render/qshaderimage/tst_qshaderimage.cpp
@@ -279,13 +279,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "texture");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), shaderImage.texture()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -295,6 +293,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -312,13 +311,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "layered");
-            QCOMPARE(change->value().value<bool>(), shaderImage.layered());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -328,6 +325,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -345,13 +343,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "mipLevel");
-            QCOMPARE(change->value().value<int>(), shaderImage.mipLevel());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -361,6 +357,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -378,13 +375,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "layer");
-            QCOMPARE(change->value().value<int>(), shaderImage.layer());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -394,6 +389,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -411,13 +407,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "access");
-            QCOMPARE(change->value().value<Qt3DRender::QShaderImage::Access>(), shaderImage.access());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -427,6 +421,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -444,13 +439,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "format");
-            QCOMPARE(change->value().value<Qt3DRender::QShaderImage::ImageFormat>(), shaderImage.format());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -460,6 +453,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
index 3fcc49067..7865a5f65 100644
--- a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
+++ b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
@@ -261,13 +261,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "vertexShaderCode");
-            QCOMPARE(change->value().value<QByteArray>(), shaderProgram.vertexShaderCode());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -277,6 +275,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -294,13 +293,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "tessellationControlShaderCode");
-            QCOMPARE(change->value().value<QByteArray>(), shaderProgram.tessellationControlShaderCode());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -310,6 +307,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -327,13 +325,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "tessellationEvaluationShaderCode");
-            QCOMPARE(change->value().value<QByteArray>(), shaderProgram.tessellationEvaluationShaderCode());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -343,6 +339,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -360,13 +357,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "geometryShaderCode");
-            QCOMPARE(change->value().value<QByteArray>(), shaderProgram.geometryShaderCode());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -376,6 +371,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -393,13 +389,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "fragmentShaderCode");
-            QCOMPARE(change->value().value<QByteArray>(), shaderProgram.fragmentShaderCode());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -409,6 +403,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -426,13 +421,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "computeShaderCode");
-            QCOMPARE(change->value().value<QByteArray>(), shaderProgram.computeShaderCode());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -442,6 +435,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp b/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp
index 021a3d6c1..881c24728 100644
--- a/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp
+++ b/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp
@@ -351,13 +351,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "shaderProgram");
-            QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), builder.shaderProgram()->id());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -367,6 +365,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
@@ -384,13 +383,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "enabledLayers");
-            QCOMPARE(change->value().toStringList(), layers);
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -400,6 +397,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
@@ -416,13 +414,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "vertexShaderGraph");
-            QCOMPARE(change->value().value<QUrl>(), builder.vertexShaderGraph());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -432,6 +428,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -449,13 +446,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "tessellationControlShaderGraph");
-            QCOMPARE(change->value().value<QUrl>(), builder.tessellationControlShaderGraph());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -465,6 +460,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -482,13 +478,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "tessellationEvaluationShaderGraph");
-            QCOMPARE(change->value().value<QUrl>(), builder.tessellationEvaluationShaderGraph());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -498,6 +492,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -515,13 +510,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "geometryShaderGraph");
-            QCOMPARE(change->value().value<QUrl>(), builder.geometryShaderGraph());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -531,6 +524,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -548,13 +542,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "fragmentShaderGraph");
-            QCOMPARE(change->value().value<QUrl>(), builder.fragmentShaderGraph());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -564,6 +556,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
@@ -581,13 +574,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "computeShaderGraph");
-            QCOMPARE(change->value().value<QUrl>(), builder.computeShaderGraph());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -597,6 +588,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
diff --git a/tests/auto/render/qsharedgltexture/tst_qsharedgltexture.cpp b/tests/auto/render/qsharedgltexture/tst_qsharedgltexture.cpp
index 1a1db60e4..8402f86bd 100644
--- a/tests/auto/render/qsharedgltexture/tst_qsharedgltexture.cpp
+++ b/tests/auto/render/qsharedgltexture/tst_qsharedgltexture.cpp
@@ -144,13 +144,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            const auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "textureId");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), 1584);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &glTexture);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -160,6 +158,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp b/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp
index 477acc058..66c625cfc 100644
--- a/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp
+++ b/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp
@@ -117,13 +117,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "sortTypes");
-        QCOMPARE(change->value().value<QVector<int>>(), sortTypesInt);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), sortPolicy.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
     }
 };
 
diff --git a/tests/auto/render/qviewport/tst_qviewport.cpp b/tests/auto/render/qviewport/tst_qviewport.cpp
index 93a2735f2..ab3dda08f 100644
--- a/tests/auto/render/qviewport/tst_qviewport.cpp
+++ b/tests/auto/render/qviewport/tst_qviewport.cpp
@@ -97,37 +97,32 @@ private Q_SLOTS:
 
         {
             // WHEN
-            viewport->setNormalizedRect(QRectF(0.5f, 0.5f, 1.0f, 1.0f));
+            viewport->setNormalizedRect(QRectF(0.5, 0.5, 1.0, 1.0));
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "normalizedRect");
-            QCOMPARE(change->subjectId(), viewport->id());
-            QCOMPARE(change->value().value<QRectF>(), QRectF(0.5f, 0.5f, 1.0f, 1.0f));
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), viewport.data());
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
-            viewport->setNormalizedRect(QRectF(0.5f, 0.5f, 1.0f, 1.0f));
+            viewport->setNormalizedRect(QRectF(0.5, 0.5, 1.0, 1.0));
             QCoreApplication::processEvents();
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
             // WHEN
-            viewport->setNormalizedRect(QRectF(0.0f, 0.0f, 1.0f, 1.0f));
+            viewport->setNormalizedRect(QRectF(0.0, 0.0, 1.0, 1.0));
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "normalizedRect");
-            QCOMPARE(change->subjectId(), viewport->id());
-            QCOMPARE(change->value().value<QRectF>(), QRectF(0.0f, 0.0f, 1.0f, 1.0f));
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), viewport.data());
         }
 
         arbiter.events.clear();
@@ -138,14 +133,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "gamma");
-            QCOMPARE(change->subjectId(), viewport->id());
-            QCOMPARE(change->value().toFloat(), 1.8f);
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), viewport.data());
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             viewport->setGamma(1.8f);
@@ -153,18 +145,16 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
             // WHEN
             viewport->setGamma(2.0f);
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "gamma");
-            QCOMPARE(change->subjectId(), viewport->id());
-            QCOMPARE(change->value().toFloat(), 2.0f);
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), viewport.data());
         }
     }
 };
diff --git a/tests/auto/render/qwaitfence/tst_qwaitfence.cpp b/tests/auto/render/qwaitfence/tst_qwaitfence.cpp
index ab3ae9b4d..db0618074 100644
--- a/tests/auto/render/qwaitfence/tst_qwaitfence.cpp
+++ b/tests/auto/render/qwaitfence/tst_qwaitfence.cpp
@@ -228,13 +228,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "handleType");
-            QCOMPARE(change->value().value<Qt3DRender::QWaitFence::HandleType>(), waitFence.handleType());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &waitFence);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -244,6 +242,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
@@ -260,13 +259,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "handle");
-            QCOMPARE(change->value().value<QVariant>(), waitFence.handle());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &waitFence);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -276,6 +273,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
@@ -292,13 +290,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "waitOnCPU");
-            QCOMPARE(change->value().value<bool>(), waitFence.waitOnCPU());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &waitFence);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -308,6 +304,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.events.size(), 0);
         }
     }
 
@@ -324,13 +321,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 1);
-            auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "timeout");
-            QCOMPARE(change->value().value<quint64>(), waitFence.timeout());
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &waitFence);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
         }
 
         {
@@ -340,6 +335,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 };
diff --git a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
index 931778c6e..cf0c25d10 100644
--- a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
+++ b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
@@ -768,24 +768,20 @@ void tst_RenderViewUtils::shouldNotifyDynamicPropertyChanges()
     shaderData->setProperty("scalar", 883.0f);
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 1);
-    auto change = arbiter.events.first().dynamicCast<Qt3DCore::QDynamicPropertyUpdatedChange>();
-    QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-    QCOMPARE(change->propertyName(), QByteArrayLiteral("scalar"));
-    QCOMPARE(change->value().toFloat(), 883.0f);
+    QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes.front(), shaderData.data());
 
-    arbiter.events.clear();
+    arbiter.dirtyNodes.clear();
 
     // WHEN
     QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D);
     shaderData->setProperty("texture", QVariant::fromValue(texture.data()));
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 1);
-    change = arbiter.events.first().dynamicCast<Qt3DCore::QDynamicPropertyUpdatedChange>();
-    QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-    QCOMPARE(change->propertyName(), QByteArrayLiteral("texture"));
-    QCOMPARE(change->value(), QVariant::fromValue(texture->id()));
+    QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes.front(), shaderData.data());
 }
 
 QTEST_MAIN(tst_RenderViewUtils)
diff --git a/tests/auto/render/texture/tst_texture.cpp b/tests/auto/render/texture/tst_texture.cpp
index d827e900e..1d69c54be 100644
--- a/tests/auto/render/texture/tst_texture.cpp
+++ b/tests/auto/render/texture/tst_texture.cpp
@@ -114,13 +114,11 @@ void tst_RenderTexture::checkFrontendPropertyNotifications()
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 1);
-    Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-    QCOMPARE(change->propertyName(), "width");
-    QCOMPARE(change->value().value<int>(), 512);
-    QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+    QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
 
-    arbiter.events.clear();
+    arbiter.dirtyNodes.clear();
 
     // WHEN
     texture.setWidth(512);
@@ -128,19 +126,18 @@ void tst_RenderTexture::checkFrontendPropertyNotifications()
 
     // THEN
     QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
     // WHEN
     texture.setHeight(256);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 1);
-    change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-    QCOMPARE(change->propertyName(), "height");
-    QCOMPARE(change->value().value<int>(), 256);
-    QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+    QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
 
-    arbiter.events.clear();
+    arbiter.dirtyNodes.clear();
 
     // WHEN
     texture.setHeight(256);
@@ -148,19 +145,18 @@ void tst_RenderTexture::checkFrontendPropertyNotifications()
 
     // THEN
     QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
     // WHEN
     texture.setDepth(128);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 1);
-    change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-    QCOMPARE(change->propertyName(), "depth");
-    QCOMPARE(change->value().value<int>(), 128);
-    QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+    QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
 
-    arbiter.events.clear();
+    arbiter.dirtyNodes.clear();
 
     // WHEN
     texture.setDepth(128);
@@ -168,19 +164,18 @@ void tst_RenderTexture::checkFrontendPropertyNotifications()
 
     // THEN
     QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.events.size(), 0);
 
     // WHEN
     texture.setLayers(16);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 1);
-    change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-    QCOMPARE(change->propertyName(), "layers");
-    QCOMPARE(change->value().value<int>(), 16);
-    QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+    QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
 
-    arbiter.events.clear();
+    arbiter.dirtyNodes.clear();
 
     // WHEN
     texture.setLayers(16);
@@ -188,19 +183,18 @@ void tst_RenderTexture::checkFrontendPropertyNotifications()
 
     // THEN
     QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
     // WHEN
     texture.setSamples(32);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 1);
-    change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-    QCOMPARE(change->propertyName(), "samples");
-    QCOMPARE(change->value().value<int>(), 32);
-    QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+    QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
 
-    arbiter.events.clear();
+    arbiter.dirtyNodes.clear();
 
     // WHEN
     texture.setSamples(32);
@@ -208,6 +202,7 @@ void tst_RenderTexture::checkFrontendPropertyNotifications()
 
     // THEN
     QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
     // WHEN
     Qt3DRender::QTextureImage img;