Remove deprecated classes and functions

Mostly old messaging API

Change-Id: I17eb2206b2ede56d2f7d36375d5e711d6149019f
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

8 files changed, 45 insertions, 262 deletions

diff --git a/src/core/aspects/qabstractaspect.cpp b/src/core/aspects/qabstractaspect.cpp
index 824434ce6..3f569a4ed 100644
--- a/src/core/aspects/qabstractaspect.cpp
+++ b/src/core/aspects/qabstractaspect.cpp
@@ -45,16 +45,10 @@
 
 #include <Qt3DCore/qcomponent.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/qpropertyvalueaddedchange.h>
-#include <Qt3DCore/qpropertyvalueremovedchange.h>
-#include <Qt3DCore/qcomponentaddedchange.h>
-#include <Qt3DCore/qcomponentremovedchange.h>
 
 #include <Qt3DCore/private/corelogging_p.h>
 #include <Qt3DCore/private/qaspectjobmanager_p.h>
 #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>
@@ -180,14 +174,7 @@ 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, 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});
+    d->m_backendCreatorFunctors.insert(&obj, functor);
 }
 
 void QAbstractAspect::unregisterBackendType(const QMetaObject &obj)
@@ -208,24 +195,23 @@ QVector<QAspectJobPtr> QAbstractAspect::jobsToExecute(qint64 time)
     return QVector<QAspectJobPtr>();
 }
 
-QAbstractAspectPrivate::BackendNodeMapperAndInfo QAbstractAspectPrivate::mapperForNode(const QMetaObject *metaObj) const
+QBackendNodeMapperPtr QAbstractAspectPrivate::mapperForNode(const QMetaObject *metaObj) const
 {
     Q_ASSERT(metaObj);
-    BackendNodeMapperAndInfo info;
+    QBackendNodeMapperPtr mapper;
 
-    while (metaObj != nullptr && info.first.isNull()) {
-        info = m_backendCreatorFunctors.value(metaObj);
+    while (metaObj != nullptr && mapper.isNull()) {
+        mapper = m_backendCreatorFunctors.value(metaObj);
         metaObj = metaObj->superClass();
     }
-    return info;
+    return mapper;
 }
 
 void QAbstractAspectPrivate::syncDirtyFrontEndNodes(const QVector<QNode *> &nodes)
 {
     for (auto node: qAsConst(nodes)) {
         const QMetaObject *metaObj = QNodePrivate::get(node)->m_typeInfo;
-        const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(metaObj);
-        const QBackendNodeMapperPtr backendNodeMapper = backendNodeMapperInfo.first;
+        const QBackendNodeMapperPtr backendNodeMapper = mapperForNode(metaObj);
 
         if (!backendNodeMapper)
             continue;
@@ -234,168 +220,53 @@ void QAbstractAspectPrivate::syncDirtyFrontEndNodes(const QVector<QNode *> &node
         if (!backend)
             continue;
 
-        const bool supportsSyncing = backendNodeMapperInfo.second & SupportsSyncing;
-        if (supportsSyncing)
-            syncDirtyFrontEndNode(node, backend, false);
-        else
-            sendPropertyMessages(node, backend);
+        syncDirtyFrontEndNode(node, backend, false);
     }
 }
 
-void QAbstractAspectPrivate::syncDirtyFrontEndSubNodes(const QVector<NodeRelationshipChange> &nodes)
+void QAbstractAspectPrivate::syncDirtyEntityComponentNodes(const QVector<ComponentRelationshipChange> &changes)
 {
-    for (const auto &nodeChange: qAsConst(nodes)) {
-        auto getBackend = [this](QNode *node) -> std::tuple<QBackendNode *, bool> {
-            const QMetaObject *metaObj = QNodePrivate::get(node)->m_typeInfo;
-            const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(metaObj);
-            const QBackendNodeMapperPtr backendNodeMapper = backendNodeMapperInfo.first;
-
-            if (!backendNodeMapper)
-                return {};
-
-            QBackendNode *backend = backendNodeMapper->get(node->id());
-            if (!backend)
-                return {};
+    auto getBackend = [this] (QNode *node) -> QBackendNode* {
+        const QMetaObject *metaObj = QNodePrivate::get(node)->m_typeInfo;
+        const QBackendNodeMapperPtr backendNodeMapper = mapperForNode(metaObj);
 
-            const bool supportsSyncing = backendNodeMapperInfo.second & SupportsSyncing;
+        if (!backendNodeMapper)
+            return nullptr;
 
-            return std::tuple<QBackendNode *, bool>(backend, supportsSyncing);
-        };
+        return backendNodeMapper->get(node->id());
+    };
 
-        auto nodeInfo = getBackend(nodeChange.node);
-        if (!std::get<0>(nodeInfo))
+    for (const auto &change: qAsConst(changes)) {
+        auto entityBackend = getBackend(change.node);
+        if (!entityBackend)
             continue;
 
-        auto subNodeInfo = getBackend(nodeChange.subNode);
-        if (!std::get<0>(subNodeInfo))
+        auto componentBackend = getBackend(change.subNode);
+        if (!componentBackend)
             continue;
 
-        switch (nodeChange.change) {
-        case PropertyValueAdded: {
-            if (std::get<1>(nodeInfo))
-                break; // do nothing as the node will be dirty anyway
-
-            QPropertyValueAddedChange change(nodeChange.node->id());
-            change.setPropertyName(nodeChange.property);
-            change.setAddedValue(QVariant::fromValue(nodeChange.subNode->id()));
-            QPropertyValueAddedChangePtr pChange(&change, [](QPropertyValueAddedChange *) { });
-            std::get<0>(nodeInfo)->sceneChangeEvent(pChange);
-        }
-        break;
-        case PropertyValueRemoved: {
-            if (std::get<1>(nodeInfo))
-                break; // do nothing as the node will be dirty anyway
-
-            QPropertyValueRemovedChange change(nodeChange.node->id());
-            change.setPropertyName(nodeChange.property);
-            change.setRemovedValue(QVariant::fromValue(nodeChange.subNode->id()));
-            QPropertyValueRemovedChangePtr pChange(&change, [](QPropertyValueRemovedChange *) { });
-            std::get<0>(nodeInfo)->sceneChangeEvent(pChange);
-        }
-        break;
-        case ComponentAdded: {
-            // let the entity know it has a new component
-            if (std::get<1>(nodeInfo)) {
-                QBackendNodePrivate::get(std::get<0>(nodeInfo))->componentAdded(nodeChange.subNode);
-            } else {
-                QComponentAddedChange change(qobject_cast<Qt3DCore::QComponent *>(nodeChange.subNode), qobject_cast<Qt3DCore::QEntity *>(nodeChange.node));
-                QComponentAddedChangePtr pChange(&change, [](QComponentAddedChange *) { });
-                std::get<0>(nodeInfo)->sceneChangeEvent(pChange);
-            }
-
-            // let the component know it was added to an entity
-            if (std::get<1>(subNodeInfo)) {
-                QBackendNodePrivate::get(std::get<0>(subNodeInfo))->addedToEntity(nodeChange.node);
-            } else {
-                QComponentAddedChange change(qobject_cast<Qt3DCore::QComponent *>(nodeChange.subNode), qobject_cast<Qt3DCore::QEntity *>(nodeChange.node));
-                QComponentAddedChangePtr pChange(&change, [](QComponentAddedChange *) { });
-                std::get<0>(subNodeInfo)->sceneChangeEvent(pChange);
-            }
-        }
-        break;
-        case ComponentRemoved: {
-            // let the entity know a component was removed
-            if (std::get<1>(nodeInfo)) {
-                QBackendNodePrivate::get(std::get<0>(nodeInfo))->componentRemoved(nodeChange.subNode);
-            } else {
-                QComponentRemovedChange change(qobject_cast<Qt3DCore::QComponent *>(nodeChange.subNode), qobject_cast<Qt3DCore::QEntity *>(nodeChange.node));
-                QComponentRemovedChangePtr pChange(&change, [](QComponentRemovedChange *) { });
-                std::get<0>(nodeInfo)->sceneChangeEvent(pChange);
-            }
-
-            // let the component know it was removed from an entity
-            if (std::get<1>(subNodeInfo)) {
-                QBackendNodePrivate::get(std::get<0>(subNodeInfo))->removedFromEntity(nodeChange.node);
-            } else {
-                QComponentRemovedChange change(qobject_cast<Qt3DCore::QEntity *>(nodeChange.node), qobject_cast<Qt3DCore::QComponent *>(nodeChange.subNode));
-                QComponentRemovedChangePtr pChange(&change, [](QComponentRemovedChange *) { });
-                std::get<0>(nodeInfo)->sceneChangeEvent(pChange);
-            }
-        }
-        break;
-        default:
+        switch (change.change) {
+        case ComponentRelationshipChange::Added:
+            QBackendNodePrivate::get(entityBackend)->componentAdded(change.subNode);
+            QBackendNodePrivate::get(componentBackend)->addedToEntity(change.node);
+            break;
+        case ComponentRelationshipChange::Removed:
+            QBackendNodePrivate::get(entityBackend)->componentRemoved(change.subNode);
+            QBackendNodePrivate::get(componentBackend)->removedFromEntity(change.node);
             break;
         }
     }
 }
 
-void QAbstractAspectPrivate::syncDirtyFrontEndNode(QNode *node, QBackendNode *backend, bool firstTime) const
-{
-    Q_ASSERT(false); // overload in derived class
-    if (!firstTime)
-        sendPropertyMessages(node, backend);
-}
-
-void QAbstractAspectPrivate::sendPropertyMessages(QNode *node, QBackendNode *backend) const
+void QAbstractAspectPrivate::syncDirtyFrontEndNode(QNode *, QBackendNode *, bool) 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);
-    }
+    // this would usually be overloaded in derived aspect classes
 }
 
 QBackendNode *QAbstractAspectPrivate::createBackendNode(const NodeTreeChange &change) const
 {
     const QMetaObject *metaObj = change.metaObj;
-    const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(metaObj);
-    const QBackendNodeMapperPtr backendNodeMapper = backendNodeMapperInfo.first;
+    const QBackendNodeMapperPtr backendNodeMapper = mapperForNode(metaObj);
 
     if (!backendNodeMapper)
         return nullptr;
@@ -405,23 +276,14 @@ QBackendNode *QAbstractAspectPrivate::createBackendNode(const NodeTreeChange &ch
         return backend;
 
     QNode *node = change.node;
-    QNodeCreatedChangeBasePtr creationChange;
-    const bool supportsSyncing = backendNodeMapperInfo.second & SupportsSyncing;
-    if (supportsSyncing) {
-        // All objects modified to use syncing should only use the id in the creation functor
-        QNodeCreatedChangeBase changeObj(node);
-        creationChange = QNodeCreatedChangeBasePtr(&changeObj, [](QNodeCreatedChangeBase *) {});
-        backend = backendNodeMapper->create(creationChange);
-    } else {
-        creationChange = node->createNodeCreationChange();
-        backend = backendNodeMapper->create(creationChange);
-    }
+    QNodeId nodeId = qIdForNode(node);
+    backend = backendNodeMapper->create(nodeId);
 
     if (!backend)
         return nullptr;
 
     // TODO: Find some place else to do all of this function from the arbiter
-    backend->setPeerId(change.id);
+    backend->setPeerId(nodeId);
 
     // Backend could be null if the user decides that his functor should only
     // perform some action when encountering a given type of item but doesn't need to
@@ -430,20 +292,7 @@ QBackendNode *QAbstractAspectPrivate::createBackendNode(const NodeTreeChange &ch
     QBackendNodePrivate *backendPriv = QBackendNodePrivate::get(backend);
     backendPriv->setEnabled(node->isEnabled());
 
-    // TO DO: Find a way to specify the changes to observe
-    // Register backendNode with QChangeArbiter
-    if (m_arbiter != nullptr) { // Unit tests may not have the arbiter registered
-        qCDebug(Nodes) << q_func()->objectName() << "Creating backend node for node id"
-                       << node->id() << "of type" << QNodePrivate::get(node)->m_typeInfo->className();
-        m_arbiter->registerObserver(backendPriv, backend->peerId(), AllChanges);
-        if (backend->mode() == QBackendNode::ReadWrite)
-            m_arbiter->scene()->addObservable(backendPriv, backend->peerId());
-    }
-
-    if (supportsSyncing)
-        syncDirtyFrontEndNode(node, backend, true);
-    else
-        backend->initializeFromPeer(creationChange);
+    syncDirtyFrontEndNode(node, backend, true);
 
     return backend;
 }
@@ -451,23 +300,12 @@ QBackendNode *QAbstractAspectPrivate::createBackendNode(const NodeTreeChange &ch
 void QAbstractAspectPrivate::clearBackendNode(const NodeTreeChange &change) const
 {
     const QMetaObject *metaObj = change.metaObj;
-    const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(metaObj);
-    const QBackendNodeMapperPtr backendNodeMapper = backendNodeMapperInfo.first;
+    const QBackendNodeMapperPtr backendNodeMapper = mapperForNode(metaObj);
 
     if (!backendNodeMapper)
         return;
 
-    // Request the mapper to destroy the corresponding backend node
-    QBackendNode *backend = backendNodeMapper->get(change.id);
-    if (backend) {
-        qCDebug(Nodes) << "Deleting backend node for node id"
-                       << change.id << "of type" << metaObj->className();
-        QBackendNodePrivate *backendPriv = QBackendNodePrivate::get(backend);
-        m_arbiter->unregisterObserver(backendPriv, backend->peerId());
-        if (backend->mode() == QBackendNode::ReadWrite)
-            m_arbiter->scene()->removeObservable(backendPriv, backend->peerId());
-        backendNodeMapper->destroy(change.id);
-    }
+    backendNodeMapper->destroy(change.id);
 }
 
 void QAbstractAspectPrivate::setRootAndCreateNodes(QEntity *rootObject, const QVector<NodeTreeChange> &nodesChanges)
diff --git a/src/core/aspects/qabstractaspect.h b/src/core/aspects/qabstractaspect.h
index 3b2f31c50..e15b987c1 100644
--- a/src/core/aspects/qabstractaspect.h
+++ b/src/core/aspects/qabstractaspect.h
@@ -42,7 +42,6 @@
 
 #include <Qt3DCore/qt3dcore_global.h>
 #include <Qt3DCore/qnodeid.h>
-#include <Qt3DCore/qscenechange.h>
 #include <QtCore/QObject>
 #include <QtCore/QSharedPointer>
 
@@ -78,10 +77,7 @@ protected:
 
     template<class Frontend>
     void registerBackendType(const QBackendNodeMapperPtr &functor);
-    template<class Frontend, bool supportsSyncing>
-    void registerBackendType(const QBackendNodeMapperPtr &functor);
     void registerBackendType(const QMetaObject &obj, const QBackendNodeMapperPtr &functor);
-    void registerBackendType(const QMetaObject &obj, const QBackendNodeMapperPtr &functor, bool supportsSyncing);
     template<class Frontend>
     void unregisterBackendType();
     void unregisterBackendType(const QMetaObject &);
@@ -108,12 +104,6 @@ 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()
 {
@@ -128,7 +118,6 @@ QT_END_NAMESPACE
     QT_BEGIN_NAMESPACE \
     namespace Qt3DCore { \
         typedef QAbstractAspect *(*AspectCreateFunction)(QObject *); \
-        QT_DEPRECATED Q_3DCORESHARED_EXPORT void qt3d_QAspectFactory_addDefaultFactory(const QString &, const QMetaObject *, AspectCreateFunction); \
         Q_3DCORESHARED_EXPORT void qt3d_QAspectFactory_addDefaultFactory(const QLatin1String &, const QMetaObject *, AspectCreateFunction); \
     } \
     QT_END_NAMESPACE \
diff --git a/src/core/aspects/qabstractaspect_p.h b/src/core/aspects/qabstractaspect_p.h
index dd13ac5bf..eed85433f 100644
--- a/src/core/aspects/qabstractaspect_p.h
+++ b/src/core/aspects/qabstractaspect_p.h
@@ -52,12 +52,11 @@
 //
 
 #include <Qt3DCore/qabstractaspect.h>
-#include <Qt3DCore/qnodedestroyedchange.h>
 
 #include <Qt3DCore/private/qaspectjobproviderinterface_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <Qt3DCore/private/qt3dcore_global_p.h>
-#include <Qt3DCore/private/qscenechange_p.h>
+#include <Qt3DCore/private/qchangearbiter_p.h>
 #include <QtCore/private/qobject_p.h>
 
 #include <QMutex>
@@ -72,7 +71,6 @@ class QBackendNode;
 class QEntity;
 class QAspectManager;
 class QAbstractAspectJobManager;
-class QChangeArbiter;
 class QServiceLocator;
 
 namespace Debug {
@@ -133,7 +131,7 @@ public:
     QBackendNode *createBackendNode(const NodeTreeChange &change) const;
     void clearBackendNode(const NodeTreeChange &change) const;
     void syncDirtyFrontEndNodes(const QVector<QNode *> &nodes);
-    void syncDirtyFrontEndSubNodes(const QVector<NodeRelationshipChange> &nodes);
+    void syncDirtyEntityComponentNodes(const QVector<ComponentRelationshipChange> &nodes);
     virtual void syncDirtyFrontEndNode(QNode *node, QBackendNode *backend, bool firstTime) const;
     void sendPropertyMessages(QNode *node, QBackendNode *backend) const;
 
@@ -146,19 +144,14 @@ public:
 
     Q_DECLARE_PUBLIC(QAbstractAspect)
 
-    enum NodeMapperInfo {
-        DefaultMapper = 0,
-        SupportsSyncing = 1 << 0
-    };
-    using BackendNodeMapperAndInfo = QPair<QBackendNodeMapperPtr, NodeMapperInfo>;
-    BackendNodeMapperAndInfo mapperForNode(const QMetaObject *metaObj) const;
+    QBackendNodeMapperPtr mapperForNode(const QMetaObject *metaObj) const;
 
     QEntity *m_root;
     QNodeId m_rootId;
     QAspectManager *m_aspectManager;
     QAbstractAspectJobManager *m_jobManager;
     QChangeArbiter *m_arbiter;
-    QHash<const QMetaObject*, BackendNodeMapperAndInfo> m_backendCreatorFunctors;
+    QHash<const QMetaObject*, QBackendNodeMapperPtr> m_backendCreatorFunctors;
     QMutex m_singleShotMutex;
     QVector<QAspectJobPtr> m_singleShotJobs;
 
diff --git a/src/core/aspects/qaspectengine.cpp b/src/core/aspects/qaspectengine.cpp
index d28306197..c11de2e26 100644
--- a/src/core/aspects/qaspectengine.cpp
+++ b/src/core/aspects/qaspectengine.cpp
@@ -52,7 +52,6 @@
 #include <Qt3DCore/private/qeventfilterservice_p.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
-#include <Qt3DCore/private/qpostman_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qservicelocator_p.h>
 #include <Qt3DCore/private/qsysteminformationservice_p.h>
@@ -115,17 +114,14 @@ QAspectEnginePrivate *QAspectEnginePrivate::get(QAspectEngine *q)
 QAspectEnginePrivate::QAspectEnginePrivate()
     : QObjectPrivate()
     , m_aspectManager(nullptr)
-    , m_postman(nullptr)
     , m_scene(nullptr)
     , m_initialized(false)
     , m_runMode(QAspectEngine::Automatic)
 {
     qRegisterMetaType<Qt3DCore::QAbstractAspect *>();
-    qRegisterMetaType<Qt3DCore::QObserverInterface *>();
     qRegisterMetaType<Qt3DCore::QNode *>();
     qRegisterMetaType<Qt3DCore::QEntity *>();
     qRegisterMetaType<Qt3DCore::QScene *>();
-    qRegisterMetaType<Qt3DCore::QAbstractPostman *>();
 }
 
 QAspectEnginePrivate::~QAspectEnginePrivate()
@@ -226,8 +222,6 @@ QAspectEngine::QAspectEngine(QObject *parent)
     qCDebug(Aspects) << Q_FUNC_INFO;
     Q_D(QAspectEngine);
     d->m_scene = new QScene(this);
-    d->m_postman = new QPostman(this);
-    d->m_postman->setScene(d->m_scene);
     d->m_aspectManager = new QAspectManager(this);
 }
 
@@ -248,7 +242,6 @@ QAspectEngine::~QAspectEngine()
     for (auto aspect : aspects)
         unregisterAspect(aspect);
 
-    delete d->m_postman;
     delete d->m_scene;
 }
 
@@ -265,8 +258,6 @@ void QAspectEnginePrivate::initialize()
     m_aspectManager->initialize();
     QChangeArbiter *arbiter = m_aspectManager->changeArbiter();
     m_scene->setArbiter(arbiter);
-    QChangeArbiter::createUnmanagedThreadLocalChangeQueue(arbiter);
-    arbiter->setPostman(m_postman);
     arbiter->setScene(m_scene);
     m_initialized = true;
     m_aspectManager->setPostConstructorInit(m_scene->postConstructorInit());
@@ -283,19 +274,12 @@ void QAspectEnginePrivate::shutdown()
 {
     qCDebug(Aspects) << Q_FUNC_INFO;
 
-    // Flush any change batch waiting in the postman that may contain node
-    // destruction changes that the aspects should process before we exit
-    // the simulation loop
-    m_postman->submitChangeBatch();
-
     // Exit the simulation loop. Waits for this to be completed on the aspect
     // thread before returning
     exitSimulationLoop();
 
     // Cleanup the scene before quitting the backend
     m_scene->setArbiter(nullptr);
-    QChangeArbiter *arbiter = m_aspectManager->changeArbiter();
-    QChangeArbiter::destroyUnmanagedThreadLocalChangeQueue(arbiter);
     m_initialized = false;
 }
 
diff --git a/src/core/aspects/qaspectengine_p.h b/src/core/aspects/qaspectengine_p.h
index 8f3abcd38..47a756511 100644
--- a/src/core/aspects/qaspectengine_p.h
+++ b/src/core/aspects/qaspectengine_p.h
@@ -52,7 +52,6 @@
 //
 
 #include <Qt3DCore/private/qt3dcore_global_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
 #include <QtCore/qsharedpointer.h>
 
 #include <Qt3DCore/private/qaspectfactory_p.h>
@@ -66,7 +65,6 @@ namespace Qt3DCore {
 class QEntity;
 class QNode;
 class QAspectManager;
-class QPostman;
 class QScene;
 
 class Q_3DCORE_PRIVATE_EXPORT QAspectEnginePrivate : public QObjectPrivate
@@ -79,7 +77,6 @@ public:
 
     QAspectFactory m_factory;
     QAspectManager *m_aspectManager;
-    QPostman *m_postman;
     QScene *m_scene;
     QSharedPointer<QEntity> m_root;
     QVector<QAbstractAspect*> m_aspects;
diff --git a/src/core/aspects/qaspectfactory.cpp b/src/core/aspects/qaspectfactory.cpp
index 2f1530257..5528a9966 100644
--- a/src/core/aspects/qaspectfactory.cpp
+++ b/src/core/aspects/qaspectfactory.cpp
@@ -60,15 +60,6 @@ Q_3DCORESHARED_EXPORT void qt3d_QAspectFactory_addDefaultFactory(const QLatin1St
     defaultAspectNames->insert(metaObject, name);
 }
 
-Q_3DCORESHARED_EXPORT void qt3d_QAspectFactory_addDefaultFactory(const QString &name,
-                                                                 const QMetaObject *metaObject,
-                                                                 QAspectFactory::CreateFunction factory)
-{
-    return qt3d_QAspectFactory_addDefaultFactory(QLatin1String(name.toLatin1()),
-                                                 metaObject,
-                                                 factory);
-}
-
 QAspectFactory::QAspectFactory()
     : m_factories(*defaultFactories),
       m_aspectNames(*defaultAspectNames)
diff --git a/src/core/aspects/qaspectmanager.cpp b/src/core/aspects/qaspectmanager.cpp
index f0dc366b2..225d7550e 100644
--- a/src/core/aspects/qaspectmanager.cpp
+++ b/src/core/aspects/qaspectmanager.cpp
@@ -217,9 +217,6 @@ void QAspectManager::exitSimulationLoop()
     for (QAbstractAspect *aspect : qAsConst(m_aspects))
         aspect->d_func()->onEngineAboutToShutdown();
 
-    // Process any pending changes from the frontend before we shut the aspects down
-    m_changeArbiter->syncChanges();
-
     // Give aspects a chance to perform any shutdown actions. This may include unqueuing
     // any blocking work on the main thread that could potentially deadlock during shutdown.
     qCDebug(Aspects) << "Calling onEngineShutdown() for each aspect";
@@ -249,7 +246,6 @@ void QAspectManager::initialize()
     qCDebug(Aspects) << Q_FUNC_INFO;
     m_jobManager->initialize();
     m_scheduler->setAspectManager(this);
-    m_changeArbiter->initialize(m_jobManager);
 }
 
 /*!
@@ -517,21 +513,16 @@ void QAspectManager::processFrame()
         }
 
         // Sync node / subnode relationship changes
-        const auto dirtySubNodes = m_changeArbiter->takeDirtyFrontEndSubNodes();
+        const auto dirtySubNodes = m_changeArbiter->takeDirtyEntityComponentNodes();
         if (dirtySubNodes.size())
             for (QAbstractAspect *aspect : qAsConst(m_aspects))
-                QAbstractAspectPrivate::get(aspect)->syncDirtyFrontEndSubNodes(dirtySubNodes);
+                QAbstractAspectPrivate::get(aspect)->syncDirtyEntityComponentNodes(dirtySubNodes);
 
         // Sync property updates
         const auto dirtyFrontEndNodes = m_changeArbiter->takeDirtyFrontEndNodes();
         if (dirtyFrontEndNodes.size())
             for (QAbstractAspect *aspect : qAsConst(m_aspects))
                 QAbstractAspectPrivate::get(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.
-        m_changeArbiter->syncChanges();
     }
 
     // For each Aspect
diff --git a/src/core/aspects/qaspectmanager_p.h b/src/core/aspects/qaspectmanager_p.h
index 2038e0822..e6772e095 100644
--- a/src/core/aspects/qaspectmanager_p.h
+++ b/src/core/aspects/qaspectmanager_p.h
@@ -51,8 +51,8 @@
 // We mean it.
 //
 
-#include <Qt3DCore/qnodecreatedchange.h>
 #include <Qt3DCore/qaspectengine.h>
+#include <Qt3DCore/qnodeid.h>
 #include <QtCore/QObject>
 #include <QtCore/QScopedPointer>
 #include <QtCore/QSemaphore>