Use sync method when initializing new backend nodes

If the node type supports syncing, use that rather than the creation
message. The message is still needed since that is passed to the
instantiation functor (none of qt3d's classes appear to use anything
but the node id, but can't be sure no other classes do, and can't add
other virtual method without breaking BC).

Change-Id: Id99f448070b8722a7809b968798772c9eb3c8397
Reviewed-by: Mike Krus <mike.krus@kdab.com>

1 files changed, 56 insertions, 33 deletions

diff --git a/src/core/aspects/qabstractaspect.cpp b/src/core/aspects/qabstractaspect.cpp
index 7636fd666..2ad3248e5 100644
--- a/src/core/aspects/qabstractaspect.cpp
+++ b/src/core/aspects/qabstractaspect.cpp
@@ -53,6 +53,7 @@
 #include <Qt3DCore/private/qnodevisitor_p.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
+#include <Qt3DCore/private/qnode_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -190,12 +191,6 @@ void QAbstractAspect::unregisterBackendType(const QMetaObject &obj)
     d->m_backendCreatorFunctors.remove(&obj);
 }
 
-void QAbstractAspectPrivate::sceneNodeAdded(QSceneChangePtr &change)
-{
-    QNodeCreatedChangeBasePtr creationChange = qSharedPointerCast<QNodeCreatedChangeBase>(change);
-    createBackendNode(creationChange);
-}
-
 void QAbstractAspectPrivate::sceneNodeRemoved(QSceneChangePtr &change)
 {
     QNodeDestroyedChangePtr destructionChange = qSharedPointerCast<QNodeDestroyedChange>(change);
@@ -220,18 +215,23 @@ void QAbstractAspect::syncDirtyFrontEndNodes(const QVector<QNode *> &nodes)
     d->syncDirtyFrontEndNodes(nodes);
 }
 
+QAbstractAspectPrivate::BackendNodeMapperAndInfo QAbstractAspectPrivate::mapperForNode(QNode *n) const
+{
+    const QMetaObject *metaObj = n->metaObject();
+    BackendNodeMapperAndInfo info;
+
+    while (metaObj != nullptr && info.first.isNull()) {
+        info = m_backendCreatorFunctors.value(metaObj);
+        metaObj = metaObj->superClass();
+    }
+    return info;
+}
+
 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();
-        }
+        const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(node);
+        const QBackendNodeMapperPtr backendNodeMapper = backendNodeMapperInfo.first;
 
         if (!backendNodeMapper)
             continue;
@@ -239,6 +239,8 @@ void QAbstractAspectPrivate::syncDirtyFrontEndNodes(const QVector<QNode *> &node
         QBackendNode *backend = backendNodeMapper->get(node->id());
         if (!backend)
             continue;
+
+        const bool supportsSyncing = backendNodeMapperInfo.second & SupportsSyncing;
         if (supportsSyncing)
             syncDirtyFrontEndNode(node, backend, false);
         else
@@ -248,9 +250,9 @@ void QAbstractAspectPrivate::syncDirtyFrontEndNodes(const QVector<QNode *> &node
 
 void QAbstractAspectPrivate::syncDirtyFrontEndNode(QNode *node, QBackendNode *backend, bool firstTime) const
 {
-    Q_UNUSED(firstTime);
     Q_ASSERT(false); // overload in derived class
-    sendPropertyMessages(node, backend);
+    if (!firstTime)
+        sendPropertyMessages(node, backend);
 }
 
 void QAbstractAspectPrivate::sendPropertyMessages(QNode *node, QBackendNode *backend) const
@@ -300,50 +302,66 @@ void QAbstractAspectPrivate::sendPropertyMessages(QNode *node, QBackendNode *bac
 
 QBackendNode *QAbstractAspectPrivate::createBackendNode(const QNodeCreatedChangeBasePtr &change) const
 {
-    const QMetaObject *metaObj = change->metaObject();
-    QBackendNodeMapperPtr backendNodeMapper;
-    while (metaObj != nullptr && backendNodeMapper.isNull()) {
-        backendNodeMapper = m_backendCreatorFunctors.value(metaObj).first;
-        metaObj = metaObj->superClass();
-    }
+    Q_UNUSED(change);
+    Q_ASSERT(false); // should not be here
+    return nullptr;
+}
+
+QBackendNode *QAbstractAspectPrivate::createBackendNode(QNode *node) const
+{
+    const BackendNodeMapperAndInfo backendNodeMapperInfo = mapperForNode(node);
+    const QBackendNodeMapperPtr backendNodeMapper = backendNodeMapperInfo.first;
 
     if (!backendNodeMapper)
         return nullptr;
 
-    QBackendNode *backend = backendNodeMapper->get(change->subjectId());
+    QBackendNode *backend = backendNodeMapper->get(node->id());
     if (backend != nullptr)
         return backend;
-    backend = backendNodeMapper->create(change);
+
+    QNodeCreatedChangeBasePtr change;
+    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);
+        change = QNodeCreatedChangeBasePtr(&changeObj, [](QNodeCreatedChangeBase *) {});
+        backend = backendNodeMapper->create(change);
+    } else {
+        change = node->createNodeCreationChange();
+        backend = backendNodeMapper->create(change);
+    }
 
     if (!backend)
         return nullptr;
 
     // TODO: Find some place else to do all of this function from the arbiter
-    backend->setPeerId(change->subjectId());
+    backend->setPeerId(node->id());
 
     // 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
     // return a QBackendNode pointer.
 
     QBackendNodePrivate *backendPriv = QBackendNodePrivate::get(backend);
-    backendPriv->setEnabled(change->isNodeEnabled());
+    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"
-                       << change->subjectId() << "of type" << change->metaObject()->className();
+                       << node->id() << "of type" << node->metaObject()->className();
         m_arbiter->registerObserver(backendPriv, backend->peerId(), AllChanges);
         if (backend->mode() == QBackendNode::ReadWrite)
             m_arbiter->scene()->addObservable(backendPriv, backend->peerId());
     }
 
-    backend->initializeFromPeer(change);
+    if (supportsSyncing)
+        syncDirtyFrontEndNode(node, backend, true);
+    else
+        backend->initializeFromPeer(change);
 
     return backend;
 }
 
-
 void QAbstractAspectPrivate::clearBackendNode(const QNodeDestroyedChangePtr &change) const
 {
     // Each QNodeDestroyedChange may contain info about a whole sub-tree of nodes that
@@ -376,7 +394,7 @@ void QAbstractAspectPrivate::clearBackendNode(const QNodeDestroyedChangePtr &cha
     }
 }
 
-void QAbstractAspectPrivate::setRootAndCreateNodes(QEntity *rootObject, const QVector<QNodeCreatedChangeBasePtr> &changes)
+void QAbstractAspectPrivate::setRootAndCreateNodes(QEntity *rootObject, const QVector<QNode *> &nodes)
 {
     qCDebug(Aspects) << Q_FUNC_INFO << "rootObject =" << rootObject;
     if (rootObject == m_root)
@@ -385,8 +403,13 @@ void QAbstractAspectPrivate::setRootAndCreateNodes(QEntity *rootObject, const QV
     m_root = rootObject;
     m_rootId = rootObject->id();
 
-    for (const auto &change : changes)
-        createBackendNode(change);
+    createNodes(nodes);
+}
+
+void QAbstractAspectPrivate::createNodes(const QVector<QNode *> &nodes)
+{
+    for (const auto node : nodes)
+        createBackendNode(node);
 }
 
 QServiceLocator *QAbstractAspectPrivate::services() const