Redo animator internals

The animators have suffered from crashes at runtime and instability
during testing which have led them to not live up to their potential.
This change brings some new concepts to try to make the situation a
bit better:

Firstly, the ownership of the render thread animation job is
maintained using a QSharedPointer, greatly simplifying the management
of that object. For the most part it will be deleted on the
render thread, but if not, then that is ok too.

Secondly, the proxy job is no longer tied to the animation controller.
It simply starts the job on the render thread and polls to see if it
has completed and only then performs the write back into the source
item.

Thirdly, the transform helper object which unifies x, y, scale
and rotation animators into one matrix has been moved out of the
controller and is striclty managed by the transform jobs.

Finally, the qmlbench testcase indicates this new implementation
is almost 10% faster than the old one, so the addition of shared
pointers have not caused any significant performance additions.

Change-Id: I51bbc43f716f8635fea97a08f2367e10cde95499
Reviewed-by: Michael Brasser <michael.brasser@live.com>
Reviewed-by: Anton Kudryavtsev <a.kudryavtsev@netris.ru>

4 files changed, 391 insertions, 436 deletions

diff --git a/src/quick/util/qquickanimatorcontroller.cpp b/src/quick/util/qquickanimatorcontroller.cpp
index 6d8167413e..ed3380b9ca 100644
--- a/src/quick/util/qquickanimatorcontroller.cpp
+++ b/src/quick/util/qquickanimatorcontroller.cpp
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2016 Gunnar Sletta <gunnar@sletta.org>
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtQuick module of the Qt Toolkit.
@@ -50,228 +51,116 @@
 
 QT_BEGIN_NAMESPACE
 
-QQuickAnimatorController::QQuickAnimatorController(QQuickWindow *window)
-    : m_window(window)
-    , m_nodesAreInvalid(false)
-{
-    m_guiEntity = new QQuickAnimatorControllerGuiThreadEntity();
-    m_guiEntity->controller = this;
-    connect(window, SIGNAL(frameSwapped()), m_guiEntity, SLOT(frameSwapped()));
-}
-
-void QQuickAnimatorControllerGuiThreadEntity::frameSwapped()
+QQuickAnimatorController::~QQuickAnimatorController()
 {
-    if (!controller.isNull())
-        controller->stopProxyJobs();
 }
 
-QQuickAnimatorController::~QQuickAnimatorController()
+QQuickAnimatorController::QQuickAnimatorController(QQuickWindow *window)
+    : m_window(window)
 {
-    // The proxy job might already have been deleted, in which case we
-    // need to avoid calling functions on them. Then delete the job.
-    for (QAbstractAnimationJob *job : qAsConst(m_deleting)) {
-        m_starting.take(job);
-        m_stopping.take(job);
-        m_animatorRoots.take(job);
-        delete job;
-    }
-
-    for (QQuickAnimatorProxyJob *proxy : qAsConst(m_animatorRoots))
-        proxy->controllerWasDeleted();
-    for (auto it = m_animatorRoots.keyBegin(), end = m_animatorRoots.keyEnd(); it != end; ++it)
-        delete *it;
-
-    // Delete those who have been started, stopped and are now still
-    // pending for restart.
-    for (auto it = m_starting.keyBegin(), end = m_starting.keyEnd(); it != end; ++it) {
-        QAbstractAnimationJob *job = *it;
-        if (!m_animatorRoots.contains(job))
-            delete job;
-    }
-
-    delete m_guiEntity;
 }
 
-static void qquickanimator_invalidate_node(QAbstractAnimationJob *job)
+static void qquickanimator_invalidate_jobs(QAbstractAnimationJob *job)
 {
     if (job->isRenderThreadJob()) {
-        static_cast<QQuickAnimatorJob *>(job)->nodeWasDestroyed();
+        static_cast<QQuickAnimatorJob *>(job)->invalidate();
     } else if (job->isGroup()) {
         QAnimationGroupJob *g = static_cast<QAnimationGroupJob *>(job);
         for (QAbstractAnimationJob *a = g->firstChild(); a; a = a->nextSibling())
-            qquickanimator_invalidate_node(a);
+            qquickanimator_invalidate_jobs(a);
     }
 }
 
 void QQuickAnimatorController::windowNodesDestroyed()
 {
     m_nodesAreInvalid = true;
-    for (QHash<QAbstractAnimationJob *, QQuickAnimatorProxyJob *>::const_iterator it = m_animatorRoots.constBegin();
-         it != m_animatorRoots.constEnd(); ++it) {
-        qquickanimator_invalidate_node(it.key());
-    }
-}
 
-void QQuickAnimatorController::itemDestroyed(QObject *o)
-{
-    m_deletedSinceLastFrame << (QQuickItem *) o;
+    for (const QSharedPointer<QAbstractAnimationJob> &toStop : qAsConst(m_rootsPendingStop))
+        toStop->stop();
+    m_rootsPendingStop.clear();
+
+    // Clear animation roots and iterate over a temporary to avoid that job->stop()
+    // modifies the m_animationRoots and messes with our iteration
+    const auto roots = m_animationRoots;
+    m_animationRoots.clear();
+    for (const QSharedPointer<QAbstractAnimationJob> &job : roots) {
+        qquickanimator_invalidate_jobs(job.data());
+
+        // Stop it and add it to the list of pending start so it might get
+        // started later on.
+        job->stop();
+        m_rootsPendingStart.insert(job);
+    }
 }
 
 void QQuickAnimatorController::advance()
 {
     bool running = false;
-    for (QHash<QAbstractAnimationJob *, QQuickAnimatorProxyJob *>::const_iterator it = m_animatorRoots.constBegin();
-         !running && it != m_animatorRoots.constEnd(); ++it) {
-        if (it.key()->isRunning())
+    for (const QSharedPointer<QAbstractAnimationJob> &job : qAsConst(m_animationRoots)) {
+        if (job->isRunning()) {
             running = true;
+            break;
+        }
     }
 
-    // It was tempting to only run over the active animations, but we need to push
-    // the values for the transforms that finished in the last frame and those will
-    // have been removed already...
-    lock();
-    for (QHash<QQuickItem *, QQuickTransformAnimatorJob::Helper *>::const_iterator it = m_transforms.constBegin();
-         it != m_transforms.constEnd(); ++it) {
-        QQuickTransformAnimatorJob::Helper *xform = *it;
-        // Set to zero when the item was deleted in beforeNodeSync().
-        if (!xform->item)
-            continue;
-        (*it)->apply();
-    }
-    unlock();
+    for (QQuickAnimatorJob *job : qAsConst(m_runningAnimators))
+        job->commit();
 
     if (running)
         m_window->update();
 }
 
-static void qquick_initialize_helper(QAbstractAnimationJob *job, QQuickAnimatorController *c, bool attachListener)
+static void qquickanimator_sync_before_start(QAbstractAnimationJob *job)
 {
     if (job->isRenderThreadJob()) {
-        QQuickAnimatorJob *j = static_cast<QQuickAnimatorJob *>(job);
-        // Note: since a QQuickAnimatorJob::m_target is a QPointer,
-        // if m_target is destroyed between the time it was set
-        // as the target of the animator job and before this step,
-        // (e.g a Loader being set inactive just after starting the animator)
-        // we are sure it will be NULL and won't be dangling around
-        if (!j->target()) {
-            return;
-        } else if (c->m_deletedSinceLastFrame.contains(j->target())) {
-            j->targetWasDeleted();
-        } else {
-            if (attachListener)
-                j->addAnimationChangeListener(c, QAbstractAnimationJob::StateChange);
-            j->initialize(c);
-        }
+        static_cast<QQuickAnimatorJob *>(job)->preSync();
     } else if (job->isGroup()) {
         QAnimationGroupJob *g = static_cast<QAnimationGroupJob *>(job);
         for (QAbstractAnimationJob *a = g->firstChild(); a; a = a->nextSibling())
-            qquick_initialize_helper(a, c, attachListener);
+            qquickanimator_sync_before_start(a);
     }
 }
 
 void QQuickAnimatorController::beforeNodeSync()
 {
-    for (QAbstractAnimationJob *job : qAsConst(m_deleting)) {
-        m_starting.take(job);
-        m_stopping.take(job);
-        m_animatorRoots.take(job);
-        job->stop();
-        delete job;
-    }
-    m_deleting.clear();
+    for (const QSharedPointer<QAbstractAnimationJob> &toStop : qAsConst(m_rootsPendingStop))
+        toStop->stop();
+    m_rootsPendingStop.clear();
 
-    if (m_starting.size())
-        m_window->update();
-    for (QQuickAnimatorProxyJob *proxy : qAsConst(m_starting)) {
-        QAbstractAnimationJob *job = proxy->job();
-        job->addAnimationChangeListener(this, QAbstractAnimationJob::Completion);
-        qquick_initialize_helper(job, this, true);
-        m_animatorRoots[job] = proxy;
-        job->start();
-        proxy->startedByController();
-    }
-    m_starting.clear();
 
-    for (QQuickAnimatorProxyJob *proxy : qAsConst(m_stopping)) {
-        QAbstractAnimationJob *job = proxy->job();
-        job->stop();
-    }
-    m_stopping.clear();
-
-    // First sync after a window was hidden or otherwise invalidated.
-    // call initialize again to pick up new nodes..
-    if (m_nodesAreInvalid) {
-        for (QHash<QAbstractAnimationJob *, QQuickAnimatorProxyJob *>::const_iterator it = m_animatorRoots.constBegin();
-             it != m_animatorRoots.constEnd(); ++it) {
-            qquick_initialize_helper(it.key(), this, false);
-        }
-        m_nodesAreInvalid = false;
-    }
+    for (QQuickAnimatorJob *job : qAsConst(m_runningAnimators))
+        job->preSync();
 
-    for (QQuickAnimatorJob *job : qAsConst(m_activeLeafAnimations)) {
-        if (!job->target())
-            continue;
-        else if (m_deletedSinceLastFrame.contains(job->target()))
-            job->targetWasDeleted();
-        else if (job->isTransform()) {
-            QQuickTransformAnimatorJob *xform = static_cast<QQuickTransformAnimatorJob *>(job);
-            xform->transformHelper()->sync();
-        }
-    }
-    for (QQuickItem *wiped : qAsConst(m_deletedSinceLastFrame)) {
-        QQuickTransformAnimatorJob::Helper *helper = m_transforms.take(wiped);
-        // Helper will now already have been reset in all animators referencing it.
-        delete helper;
-    }
+    // Start pending jobs
+    for (const QSharedPointer<QAbstractAnimationJob> &job : qAsConst(m_rootsPendingStart)) {
+        Q_ASSERT(!job->isRunning());
 
-    m_deletedSinceLastFrame.clear();
-}
+        // We want to make sure that presync is called before
+        // updateAnimationTime is called the very first time, so before
+        // starting a tree of jobs, we go through it and call preSync on all
+        // its animators.
+        qquickanimator_sync_before_start(job.data());
 
-void QQuickAnimatorController::afterNodeSync()
-{
-    for (QQuickAnimatorJob *job : qAsConst(m_activeLeafAnimations)) {
-        if (job->target())
-            job->afterNodeSync();
+        // The start the job..
+        job->start();
+        m_animationRoots.insert(job.data(), job);
     }
-}
+    m_rootsPendingStart.clear();
 
-void QQuickAnimatorController::proxyWasDestroyed(QQuickAnimatorProxyJob *proxy)
-{
-    lock();
-    m_proxiesToStop.remove(proxy);
-    unlock();
+    // Issue an update directly on the window to force another render pass.
+    if (m_animationRoots.size())
+        m_window->update();
 }
 
-void QQuickAnimatorController::stopProxyJobs()
+void QQuickAnimatorController::afterNodeSync()
 {
-    // Need to make a copy under lock and then stop while unlocked.
-    // Stopping triggers writeBack which in turn may lock, so it needs
-    // to be outside the lock. It is also safe because deletion of
-    // proxies happens on the GUI thread, where this code is also executing.
-    lock();
-    const QSet<QQuickAnimatorProxyJob *> jobs = m_proxiesToStop;
-    m_proxiesToStop.clear();
-    unlock();
-    for (QQuickAnimatorProxyJob *p : jobs)
-        p->stop();
+    for (QQuickAnimatorJob *job : qAsConst(m_runningAnimators))
+        job->postSync();
 }
 
 void QQuickAnimatorController::animationFinished(QAbstractAnimationJob *job)
 {
-    /* We are currently on the render thread and m_deleting is primarily
-     * being written on the GUI Thread and read during sync. However, we don't
-     * need to lock here as this is a direct result of animationDriver->advance()
-     * which is already locked. For non-threaded render loops no locking is
-     * needed in any case.
-     */
-    if (!m_deleting.contains(job)) {
-        QQuickAnimatorProxyJob *proxy = m_animatorRoots.value(job);
-        if (proxy) {
-            m_window->update();
-            m_proxiesToStop << proxy;
-        }
-        // else already gone...
-    }
+     m_animationRoots.remove(job);
 }
 
 void QQuickAnimatorController::animationStateChanged(QAbstractAnimationJob *job,
@@ -281,43 +170,52 @@ void QQuickAnimatorController::animationStateChanged(QAbstractAnimationJob *job,
     Q_ASSERT(job->isRenderThreadJob());
     QQuickAnimatorJob *animator = static_cast<QQuickAnimatorJob *>(job);
     if (newState == QAbstractAnimationJob::Running) {
-        m_activeLeafAnimations << animator;
-        animator->setHasBeenRunning(true);
+        m_runningAnimators.insert(animator);
     } else if (oldState == QAbstractAnimationJob::Running) {
-        m_activeLeafAnimations.remove(animator);
+        animator->commit();
+        m_runningAnimators.remove(animator);
     }
 }
 
 
-
 void QQuickAnimatorController::requestSync()
 {
     // Force a "sync" pass as the newly started animation needs to sync properties from GUI.
     m_window->maybeUpdate();
 }
 
-// These functions are called on the GUI thread.
-void QQuickAnimatorController::startJob(QQuickAnimatorProxyJob *proxy, QAbstractAnimationJob *job)
+// All this is being executed on the GUI thread while the animator controller
+// is locked.
+void QQuickAnimatorController::start_helper(QAbstractAnimationJob *job)
 {
-    proxy->markJobManagedByController();
-    m_starting[job] = proxy;
-    m_stopping.remove(job);
-    requestSync();
+    if (job->isRenderThreadJob()) {
+        QQuickAnimatorJob *j = static_cast<QQuickAnimatorJob *>(job);
+        j->addAnimationChangeListener(this, QAbstractAnimationJob::StateChange);
+        j->initialize(this);
+    } else if (job->isGroup()) {
+        QAnimationGroupJob *g = static_cast<QAnimationGroupJob *>(job);
+        for (QAbstractAnimationJob *a = g->firstChild(); a; a = a->nextSibling())
+            start_helper(a);
+    }
 }
 
-void QQuickAnimatorController::stopJob(QQuickAnimatorProxyJob *proxy, QAbstractAnimationJob *job)
+// Called by the proxy when it is time to kick off an animation job
+void QQuickAnimatorController::start(const QSharedPointer<QAbstractAnimationJob> &job)
 {
-    m_stopping[job] = proxy;
-    m_starting.remove(job);
+    m_rootsPendingStart.insert(job);
+    m_rootsPendingStop.remove(job);
+    job->addAnimationChangeListener(this, QAbstractAnimationJob::Completion);
+    start_helper(job.data());
     requestSync();
 }
 
-void QQuickAnimatorController::deleteJob(QAbstractAnimationJob *job)
+
+// Called by the proxy when it is time to stop an animation job.
+void QQuickAnimatorController::cancel(const QSharedPointer<QAbstractAnimationJob> &job)
 {
-    lock();
-    m_deleting << job;
-    requestSync();
-    unlock();
+    m_rootsPendingStart.remove(job);
+    m_rootsPendingStop.insert(job);
 }
 
+
 QT_END_NAMESPACE
diff --git a/src/quick/util/qquickanimatorcontroller_p.h b/src/quick/util/qquickanimatorcontroller_p.h
index b63518abad..1ec44ccc9d 100644
--- a/src/quick/util/qquickanimatorcontroller_p.h
+++ b/src/quick/util/qquickanimatorcontroller_p.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2016 Gunnar Sletta <gunnar@sletta.org>
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtQuick module of the Qt Toolkit.
@@ -60,8 +61,6 @@
 
 QT_BEGIN_NAMESPACE
 
-class QQuickAnimatorControllerGuiThreadEntity;
-
 class QQuickAnimatorController : public QObject, public QAnimationJobChangeListener
 {
     Q_OBJECT
@@ -80,50 +79,35 @@ public:
     void requestSync();
 
     // These are called from the GUI thread (the proxy)
-    void startJob(QQuickAnimatorProxyJob *proxy, QAbstractAnimationJob *job);
-    void stopJob(QQuickAnimatorProxyJob *proxy, QAbstractAnimationJob *job);
-    void deleteJob(QAbstractAnimationJob *job);
+    void start(const QSharedPointer<QAbstractAnimationJob> &job);
+    void cancel(const QSharedPointer<QAbstractAnimationJob> &job);
+    bool isPendingStart(const QSharedPointer<QAbstractAnimationJob> &job) const { return m_rootsPendingStart.contains(job); }
 
     void lock() { m_mutex.lock(); }
     void unlock() { m_mutex.unlock(); }
 
-
     void proxyWasDestroyed(QQuickAnimatorProxyJob *proxy);
     void stopProxyJobs();
     void windowNodesDestroyed();
 
-public Q_SLOTS:
-    void itemDestroyed(QObject *);
+    QQuickWindow *window() const { return m_window; }
+
+private:
+    void start_helper(QAbstractAnimationJob *job);
+    void cancel_helper(QAbstractAnimationJob *job);
 
 public:
-    // These are manipulated from the GUI thread and should only
-    // be updated during the sync() phase.
-    QHash<QAbstractAnimationJob *, QQuickAnimatorProxyJob *> m_starting;
-    QHash<QAbstractAnimationJob *, QQuickAnimatorProxyJob *> m_stopping;
-    QSet<QAbstractAnimationJob *> m_deleting;
-
-    QHash<QAbstractAnimationJob *, QQuickAnimatorProxyJob *> m_animatorRoots;
-    QSet<QQuickAnimatorJob *> m_activeLeafAnimations;
-    QHash<QQuickItem *, QQuickTransformAnimatorJob::Helper *> m_transforms;
-    QSet<QQuickItem *> m_deletedSinceLastFrame;
+    QSet<QQuickAnimatorJob * > m_runningAnimators;
+    QHash<QAbstractAnimationJob *, QSharedPointer<QAbstractAnimationJob> > m_animationRoots;
+    QSet<QSharedPointer<QAbstractAnimationJob> > m_rootsPendingStop;
+    QSet<QSharedPointer<QAbstractAnimationJob> > m_rootsPendingStart;
+
     QQuickWindow *m_window;
-    QQuickAnimatorControllerGuiThreadEntity *m_guiEntity;
-    QSet<QQuickAnimatorProxyJob *> m_proxiesToStop;
     QMutex m_mutex;
 
     bool m_nodesAreInvalid;
 };
 
-class QQuickAnimatorControllerGuiThreadEntity : public QObject
-{
-    Q_OBJECT
-public:
-    QPointer<QQuickAnimatorController> controller;
-
-public Q_SLOTS:
-    void frameSwapped();
-};
-
 
 
 QT_END_NAMESPACE
diff --git a/src/quick/util/qquickanimatorjob.cpp b/src/quick/util/qquickanimatorjob.cpp
index a0c787dae5..11c7c28d5f 100644
--- a/src/quick/util/qquickanimatorjob.cpp
+++ b/src/quick/util/qquickanimatorjob.cpp
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2016 Gunnar Sletta <gunnar@sletta.org>
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtQuick module of the Qt Toolkit.
@@ -54,12 +55,42 @@
 
 QT_BEGIN_NAMESPACE
 
+struct QQuickTransformAnimatorHelperStore
+{
+    QHash<QQuickItem *, QQuickTransformAnimatorJob::Helper *> store;
+    QMutex mutex;
+
+    QQuickTransformAnimatorJob::Helper *acquire(QQuickItem *item) {
+        mutex.lock();
+        QQuickTransformAnimatorJob::Helper *helper = store.value(item);
+        if (!helper) {
+            helper = new QQuickTransformAnimatorJob::Helper();
+            helper->item = item;
+            store[item] = helper;
+        } else {
+            ++helper->ref;
+        }
+        mutex.unlock();
+        return helper;
+    }
+
+    void release(QQuickTransformAnimatorJob::Helper *helper) {
+        mutex.lock();
+        if (--helper->ref == 0) {
+            store.remove(helper->item);
+            delete helper;
+        }
+        mutex.unlock();
+    }
+};
+Q_GLOBAL_STATIC(QQuickTransformAnimatorHelperStore, qquick_transform_animatorjob_helper_store);
+
 QQuickAnimatorProxyJob::QQuickAnimatorProxyJob(QAbstractAnimationJob *job, QObject *item)
-    : m_controller(0)
-    , m_job(job)
+    : m_controller(nullptr)
     , m_internalState(State_Stopped)
-    , m_jobManagedByController(false)
 {
+    m_job.reset(job);
+
     m_isRenderThreadProxy = true;
     m_animation = qobject_cast<QQuickAbstractAnimation *>(item);
 
@@ -87,57 +118,58 @@ QQuickAnimatorProxyJob::QQuickAnimatorProxyJob(QAbstractAnimationJob *job, QObje
         QQuickItem *item = qobject_cast<QQuickItem *>(ctx);
         if (item->window())
             setWindow(item->window());
-
-        qmlobject_connect(item, QQuickItem, SIGNAL(windowChanged(QQuickWindow*)), this, QQuickAnimatorProxyJob, SLOT(windowChanged(QQuickWindow*)));
+        connect(item, &QQuickItem::windowChanged, this, &QQuickAnimatorProxyJob::windowChanged);
     }
 }
 
 QQuickAnimatorProxyJob::~QQuickAnimatorProxyJob()
 {
-    deleteJob();
-    if (m_controller)
-        m_controller->proxyWasDestroyed(this);
-}
-
-void QQuickAnimatorProxyJob::deleteJob()
-{
-    if (m_job) {
-        // If we have a controller, we might have posted the job to be started
-        // so delete it through the controller to clean up properly.
-        if (m_controller)
-            m_controller->deleteJob(m_job);
-
-        // We explicitly delete the job if the animator controller has never touched
-        // it. If it has, it will have ownership as well.
-        else if (!m_jobManagedByController)
-            delete m_job;
-        m_job = 0;
-    }
+    if (m_job && m_controller)
+        m_controller->cancel(m_job);
+    m_job.reset();
 }
 
 QObject *QQuickAnimatorProxyJob::findAnimationContext(QQuickAbstractAnimation *a)
 {
     QObject *p = a->parent();
-    while (p != 0 && qobject_cast<QQuickWindow *>(p) == 0 && qobject_cast<QQuickItem *>(p) == 0)
+    while (p != nullptr && qobject_cast<QQuickWindow *>(p) == nullptr && qobject_cast<QQuickItem *>(p) == nullptr)
         p = p->parent();
     return p;
 }
 
 void QQuickAnimatorProxyJob::updateCurrentTime(int)
 {
+    // We do a simple check here to see if the animator has run and stopped on
+    // the render thread. isPendingStart() will perform a check against jobs
+    // that have been scheduled for start, but that will not yet have entered
+    // the actual running state.
+    // Secondly, we make an unprotected read of the job's state to figure out
+    // if it is running, but this is ok, since we're only reading the state
+    // and if the render thread should happen to be writing it concurrently,
+    // we might get the wrong value for this update,  but then we'll simply
+    // pick it up on the next iterationm when the job is stopped and render
+    // thread is no longer using it.
+    if (m_internalState == State_Running
+        && !m_controller->isPendingStart(m_job)
+        && !m_job->isRunning()) {
+        stop();
+    }
 }
 
 void QQuickAnimatorProxyJob::updateState(QAbstractAnimationJob::State newState, QAbstractAnimationJob::State)
 {
     if (m_state == Running) {
         m_internalState = State_Starting;
-        if (m_controller)
-            m_controller->startJob(this, m_job);
+        if (m_controller) {
+            m_internalState = State_Running;
+            m_controller->start(m_job);
+        }
+
     } else if (newState == Stopped) {
         syncBackCurrentValues();
         m_internalState = State_Stopped;
         if (m_controller) {
-            m_controller->stopJob(this, m_job);
+            m_controller->cancel(m_job);
         }
     }
 }
@@ -154,69 +186,55 @@ void QQuickAnimatorProxyJob::windowChanged(QQuickWindow *window)
     setWindow(window);
 }
 
-void QQuickAnimatorProxyJob::controllerWasDeleted()
-{
-    m_controller = 0;
-    m_job = 0;
-}
-
 void QQuickAnimatorProxyJob::setWindow(QQuickWindow *window)
 {
     if (!window) {
-        stop();
-        deleteJob();
-
-        // Upon leaving a window, we reset the controller. This means that
-        // animators will only enter the Starting phase and won't be making
-        // calls to QQuickAnimatorController::startjob().
-        if (m_controller)
-            m_controller->proxyWasDestroyed(this);
-        m_controller = 0;
+        if (m_job && m_controller)
+            m_controller->cancel(m_job);
+        m_controller = nullptr;
 
     } else if (!m_controller && m_job) {
         m_controller = QQuickWindowPrivate::get(window)->animationController;
         if (window->isSceneGraphInitialized())
             readyToAnimate();
         else
-            connect(window, SIGNAL(sceneGraphInitialized()), this, SLOT(sceneGraphInitialized()));
+            connect(window, &QQuickWindow::sceneGraphInitialized, this, &QQuickAnimatorProxyJob::sceneGraphInitialized);
     }
 }
 
 void QQuickAnimatorProxyJob::sceneGraphInitialized()
 {
+    disconnect(m_controller->window(), &QQuickWindow::sceneGraphInitialized, this, &QQuickAnimatorProxyJob::sceneGraphInitialized);
     readyToAnimate();
-    disconnect(this, SLOT(sceneGraphInitialized()));
 }
 
 void QQuickAnimatorProxyJob::readyToAnimate()
 {
-    if (m_internalState == State_Starting)
-        m_controller->startJob(this, m_job);
-}
-
-void QQuickAnimatorProxyJob::startedByController()
-{
-    m_internalState = State_Running;
+    Q_ASSERT(m_controller);
+    if (m_internalState == State_Starting) {
+        m_internalState = State_Running;
+        m_controller->start(m_job);
+    }
 }
 
 static void qquick_syncback_helper(QAbstractAnimationJob *job)
 {
     if (job->isRenderThreadJob()) {
-        QQuickAnimatorJob *a = static_cast<QQuickAnimatorJob *>(job);
-        // Sync back only those jobs that actually have been running
-        if (a->controller() && a->hasBeenRunning())
-            a->writeBack();
+        Q_ASSERT(!job->isRunning());
+        static_cast<QQuickAnimatorJob *>(job)->writeBack();
+
     } else if (job->isGroup()) {
         QAnimationGroupJob *g = static_cast<QAnimationGroupJob *>(job);
         for (QAbstractAnimationJob *a = g->firstChild(); a; a = a->nextSibling())
             qquick_syncback_helper(a);
     }
+
 }
 
 void QQuickAnimatorProxyJob::syncBackCurrentValues()
 {
     if (m_job)
-        qquick_syncback_helper(m_job);
+        qquick_syncback_helper(m_job.data());
 }
 
 QQuickAnimatorJob::QQuickAnimatorJob()
@@ -228,7 +246,6 @@ QQuickAnimatorJob::QQuickAnimatorJob()
     , m_duration(0)
     , m_isTransform(false)
     , m_isUniform(false)
-    , m_hasBeenRunning(false)
 {
     m_isRenderThreadJob = true;
 }
@@ -244,13 +261,10 @@ qreal QQuickAnimatorJob::progress(int time) const
 {
     return m_easing.valueForProgress((m_duration == 0) ? qreal(1) : qreal(time) / qreal(m_duration));
 }
+
 qreal QQuickAnimatorJob::value() const
 {
-    qreal v;
-    m_controller->lock();
-    v = m_value;
-    m_controller->unlock();
-    return v;
+    return m_value;
 }
 
 void QQuickAnimatorJob::setTarget(QQuickItem *target)
@@ -263,62 +277,81 @@ void QQuickAnimatorJob::initialize(QQuickAnimatorController *controller)
     m_controller = controller;
 }
 
-void QQuickAnimatorJob::targetWasDeleted()
-{
-    m_target = 0;
-    m_controller = 0;
-}
-
 QQuickTransformAnimatorJob::QQuickTransformAnimatorJob()
-    : m_helper(0)
+    : m_helper(nullptr)
 {
     m_isTransform = true;
 }
 
 QQuickTransformAnimatorJob::~QQuickTransformAnimatorJob()
 {
-    if (m_helper && --m_helper->ref == 0) {
-        // The only condition for not having a controller is when target was
-        // destroyed, in which case we have neither m_helper nor m_contorller.
-        Q_ASSERT(m_controller);
-        Q_ASSERT(m_helper->item);
-        m_controller->m_transforms.remove(m_helper->item);
-        delete m_helper;
-    }
+    if (m_helper)
+        qquick_transform_animatorjob_helper_store()->release(m_helper);
 }
 
-void QQuickTransformAnimatorJob::initialize(QQuickAnimatorController *controller)
+void QQuickTransformAnimatorJob::setTarget(QQuickItem *item)
 {
-    QQuickAnimatorJob::initialize(controller);
+    // In the extremely unlikely event that the target of an animator has been
+    // changed into a new item that sits in the exact same pointer address, we
+    // want to force syncing it again.
+    if (m_helper && m_target)
+        m_helper->wasSynced = false;
+    QQuickAnimatorJob::setTarget(item);
+}
 
-    if (m_controller) {
-        bool newHelper = m_helper == 0;
-        m_helper = m_controller->m_transforms.value(m_target);
-        if (!m_helper) {
-            m_helper = new Helper();
-            m_helper->item = m_target;
-            m_controller->m_transforms.insert(m_target, m_helper);
-            QObject::connect(m_target, SIGNAL(destroyed(QObject*)), m_controller, SLOT(itemDestroyed(QObject*)), Qt::DirectConnection);
-        } else {
-            if (newHelper) // only add reference the first time around..
-                ++m_helper->ref;
-            // Make sure leftovers from previous runs are being used...
-            m_helper->wasSynced = false;
-        }
-        m_helper->sync();
+void QQuickTransformAnimatorJob::preSync()
+{
+    // If the target has changed or become null, release and reset the helper
+    if (m_helper && (m_helper->item != m_target || !m_target)) {
+        qquick_transform_animatorjob_helper_store()->release(m_helper);
+        m_helper = nullptr;
+    }
+
+    if (!m_target)
+        return;
+
+    if (!m_helper) {
+        m_helper = qquick_transform_animatorjob_helper_store()->acquire(m_target);
+
+        // This is a bit superfluous, but it ends up being simpler than the
+        // alternative.  When an item happens to land on the same address as a
+        // previous item, that helper might not have been fully cleaned up by
+        // the time it gets taken back into use. As an alternative to storing
+        // connections to each and every item's QObject::destroyed() and
+        // having to clean those up afterwards, we simply sync all helpers on
+        // the first run. The sync is only done once for the run of an
+        // animation and it is a fairly light function (compared to storing
+        // potentially thousands of connections and managing their lifetime.
+        m_helper->wasSynced = false;
     }
+
+    m_helper->sync();
 }
 
-void QQuickTransformAnimatorJob::nodeWasDestroyed()
+void QQuickTransformAnimatorJob::postSync()
 {
-    if (m_helper)
-        m_helper->node = 0;
+    Q_ASSERT((m_helper != nullptr) == (m_target != nullptr)); // If there is a target, there should also be a helper, ref: preSync
+    Q_ASSERT(!m_helper || m_helper->item == m_target); // If there is a helper, it should point to our target
+
+    if (!m_target || !m_helper) {
+        invalidate();
+        return;
+    }
+
+    QQuickItemPrivate *d = QQuickItemPrivate::get(m_target);
+    if (d->extra.isAllocated()
+            && d->extra->layer
+            && d->extra->layer->enabled()) {
+        d = QQuickItemPrivate::get(d->extra->layer->m_effectSource);
+    }
+
+    m_helper->node = d->itemNode();
 }
 
-void QQuickTransformAnimatorJob::targetWasDeleted()
+void QQuickTransformAnimatorJob::invalidate()
 {
-    m_helper = 0;
-    QQuickAnimatorJob::targetWasDeleted();
+    if (m_helper)
+        m_helper->node = nullptr;
 }
 
 void QQuickTransformAnimatorJob::Helper::sync()
@@ -364,7 +397,7 @@ void QQuickTransformAnimatorJob::Helper::sync()
     }
 }
 
-void QQuickTransformAnimatorJob::Helper::apply()
+void QQuickTransformAnimatorJob::Helper::commit()
 {
     if (!wasChanged || !node)
         return;
@@ -380,7 +413,11 @@ void QQuickTransformAnimatorJob::Helper::apply()
     wasChanged = false;
 }
 
-
+void QQuickTransformAnimatorJob::commit()
+{
+    if (m_helper)
+        m_helper->commit();
+}
 
 void QQuickXAnimatorJob::writeBack()
 {
@@ -390,7 +427,8 @@ void QQuickXAnimatorJob::writeBack()
 
 void QQuickXAnimatorJob::updateCurrentTime(int time)
 {
-    if (!m_controller)
+    Q_ASSERT(!m_controller || !m_controller->m_window->openglContext() || m_controller->m_window->openglContext()->thread() == QThread::currentThread());
+    if (!m_helper)
         return;
 
     m_value = m_from + (m_to - m_from) * progress(time);
@@ -406,7 +444,9 @@ void QQuickYAnimatorJob::writeBack()
 
 void QQuickYAnimatorJob::updateCurrentTime(int time)
 {
-    if (!m_controller)
+    Q_ASSERT(!m_controller || !m_controller->m_window->openglContext() || m_controller->m_window->openglContext()->thread() == QThread::currentThread());
+
+    if (!m_helper)
         return;
 
     m_value = m_from + (m_to - m_from) * progress(time);
@@ -414,22 +454,93 @@ void QQuickYAnimatorJob::updateCurrentTime(int time)
     m_helper->wasChanged = true;
 }
 
+void QQuickScaleAnimatorJob::writeBack()
+{
+    if (m_target)
+        m_target->setScale(value());
+}
+
+void QQuickScaleAnimatorJob::updateCurrentTime(int time)
+{
+    Q_ASSERT(!m_controller || !m_controller->m_window->openglContext() || m_controller->m_window->openglContext()->thread() == QThread::currentThread());
+
+    if (!m_helper)
+        return;
+
+    m_value = m_from + (m_to - m_from) * progress(time);
+    m_helper->scale = m_value;
+    m_helper->wasChanged = true;
+}
+
+
+QQuickRotationAnimatorJob::QQuickRotationAnimatorJob()
+    : m_direction(QQuickRotationAnimator::Numerical)
+{
+}
+
+extern QVariant _q_interpolateShortestRotation(qreal &f, qreal &t, qreal progress);
+extern QVariant _q_interpolateClockwiseRotation(qreal &f, qreal &t, qreal progress);
+extern QVariant _q_interpolateCounterclockwiseRotation(qreal &f, qreal &t, qreal progress);
+
+void QQuickRotationAnimatorJob::updateCurrentTime(int time)
+{
+    Q_ASSERT(!m_controller || !m_controller->m_window->openglContext() || m_controller->m_window->openglContext()->thread() == QThread::currentThread());
+
+    if (!m_helper)
+        return;
+
+    float t = progress(time);
+
+    switch (m_direction) {
+    case QQuickRotationAnimator::Clockwise:
+        m_value = _q_interpolateClockwiseRotation(m_from, m_to, t).toFloat();
+        // The logic in _q_interpolateClockwise comes out a bit wrong
+        // for the case of X->0 where 0<X<360. It ends on 360 which it
+        // shouldn't.
+        if (t == 1)
+            m_value = m_to;
+        break;
+    case QQuickRotationAnimator::Counterclockwise:
+        m_value = _q_interpolateCounterclockwiseRotation(m_from, m_to, t).toFloat();
+        break;
+    case QQuickRotationAnimator::Shortest:
+        m_value = _q_interpolateShortestRotation(m_from, m_to, t).toFloat();
+        break;
+    case QQuickRotationAnimator::Numerical:
+        m_value = m_from + (m_to - m_from) * t;
+        break;
+    }
+    m_helper->rotation = m_value;
+    m_helper->wasChanged = true;
+}
+
+void QQuickRotationAnimatorJob::writeBack()
+{
+    if (m_target)
+        m_target->setRotation(value());
+}
+
+
 QQuickOpacityAnimatorJob::QQuickOpacityAnimatorJob()
-    : m_opacityNode(0)
+    : m_opacityNode(nullptr)
 {
 }
 
-void QQuickOpacityAnimatorJob::initialize(QQuickAnimatorController *controller)
+void QQuickOpacityAnimatorJob::postSync()
 {
-    QQuickAnimatorJob::initialize(controller);
+    if (!m_target) {
+        invalidate();
+        return;
+    }
+
     QQuickItemPrivate *d = QQuickItemPrivate::get(m_target);
     if (d->extra.isAllocated()
             && d->extra->layer
             && d->extra->layer->enabled()) {
         d = QQuickItemPrivate::get(d->extra->layer->m_effectSource);
     }
-
     m_opacityNode = d->opacityNode();
+
     if (!m_opacityNode) {
         m_opacityNode = new QSGOpacityNode();
 
@@ -460,11 +571,12 @@ void QQuickOpacityAnimatorJob::initialize(QQuickAnimatorController *controller)
 
         d->extra.value().opacityNode = m_opacityNode;
     }
+    Q_ASSERT(m_opacityNode);
 }
 
-void QQuickOpacityAnimatorJob::nodeWasDestroyed()
+void QQuickOpacityAnimatorJob::invalidate()
 {
-    m_opacityNode = 0;
+    m_opacityNode = nullptr;
 }
 
 void QQuickOpacityAnimatorJob::writeBack()
@@ -475,77 +587,19 @@ void QQuickOpacityAnimatorJob::writeBack()
 
 void QQuickOpacityAnimatorJob::updateCurrentTime(int time)
 {
-    if (!m_controller || !m_opacityNode)
-        return;
+    Q_ASSERT(!m_controller || !m_controller->m_window->openglContext() || m_controller->m_window->openglContext()->thread() == QThread::currentThread());
 
-    m_value = m_from + (m_to - m_from) * progress(time);
-    m_opacityNode->setOpacity(m_value);
-}
-
-void QQuickScaleAnimatorJob::writeBack()
-{
-    if (m_target)
-        m_target->setScale(value());
-}
-
-void QQuickScaleAnimatorJob::updateCurrentTime(int time)
-{
-    if (!m_controller)
+    if (!m_opacityNode)
         return;
 
     m_value = m_from + (m_to - m_from) * progress(time);
-    m_helper->scale = m_value;
-    m_helper->wasChanged = true;
-}
-
-QQuickRotationAnimatorJob::QQuickRotationAnimatorJob()
-    : m_direction(QQuickRotationAnimator::Numerical)
-{
-}
-
-extern QVariant _q_interpolateShortestRotation(qreal &f, qreal &t, qreal progress);
-extern QVariant _q_interpolateClockwiseRotation(qreal &f, qreal &t, qreal progress);
-extern QVariant _q_interpolateCounterclockwiseRotation(qreal &f, qreal &t, qreal progress);
-
-void QQuickRotationAnimatorJob::updateCurrentTime(int time)
-{
-    if (!m_controller)
-        return;
-
-    float t = progress(time);
-
-    switch (m_direction) {
-    case QQuickRotationAnimator::Clockwise:
-        m_value = _q_interpolateClockwiseRotation(m_from, m_to, t).toFloat();
-        // The logic in _q_interpolateClockwise comes out a bit wrong
-        // for the case of X->0 where 0<X<360. It ends on 360 which it
-        // shouldn't.
-        if (t == 1)
-            m_value = m_to;
-        break;
-    case QQuickRotationAnimator::Counterclockwise:
-        m_value = _q_interpolateCounterclockwiseRotation(m_from, m_to, t).toFloat();
-        break;
-    case QQuickRotationAnimator::Shortest:
-        m_value = _q_interpolateShortestRotation(m_from, m_to, t).toFloat();
-        break;
-    case QQuickRotationAnimator::Numerical:
-        m_value = m_from + (m_to - m_from) * t;
-        break;
-    }
-    m_helper->rotation = m_value;
-    m_helper->wasChanged = true;
+    m_opacityNode->setOpacity(m_value);
 }
 
-void QQuickRotationAnimatorJob::writeBack()
-{
-    if (m_target)
-        m_target->setRotation(value());
-}
 
 #ifndef QT_NO_OPENGL
 QQuickUniformAnimatorJob::QQuickUniformAnimatorJob()
-    : m_node(0)
+    : m_node(nullptr)
     , m_uniformIndex(-1)
     , m_uniformType(-1)
 {
@@ -554,19 +608,24 @@ QQuickUniformAnimatorJob::QQuickUniformAnimatorJob()
 
 void QQuickUniformAnimatorJob::setTarget(QQuickItem *target)
 {
-    if (qobject_cast<QQuickOpenGLShaderEffect *>(target) != 0)
+    if (qobject_cast<QQuickOpenGLShaderEffect *>(target) != nullptr)
         m_target = target;
 }
 
-void QQuickUniformAnimatorJob::nodeWasDestroyed()
+void QQuickUniformAnimatorJob::invalidate()
 {
-    m_node = 0;
+    m_node = nullptr;
     m_uniformIndex = -1;
     m_uniformType = -1;
 }
 
-void QQuickUniformAnimatorJob::afterNodeSync()
+void QQuickUniformAnimatorJob::postSync()
 {
+    if (!m_target) {
+        invalidate();
+        return;
+    }
+
     m_node = static_cast<QQuickOpenGLShaderEffectNode *>(QQuickItemPrivate::get(m_target)->paintNode);
 
     if (m_node && m_uniformIndex == -1 && m_uniformType == -1) {
diff --git a/src/quick/util/qquickanimatorjob_p.h b/src/quick/util/qquickanimatorjob_p.h
index 64e849d322..d7aaa988a9 100644
--- a/src/quick/util/qquickanimatorjob_p.h
+++ b/src/quick/util/qquickanimatorjob_p.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2016 Gunnar Sletta <gunnar@sletta.org>
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtQuick module of the Qt Toolkit.
@@ -80,25 +81,20 @@ public:
     QQuickAnimatorProxyJob(QAbstractAnimationJob *job, QObject *item);
     ~QQuickAnimatorProxyJob();
 
-    int duration() const Q_DECL_OVERRIDE { return m_duration; }
+    int duration() const override { return m_duration; }
 
-    QAbstractAnimationJob *job() const { return m_job; }
-
-    void startedByController();
-    void controllerWasDeleted();
-    void markJobManagedByController() { m_jobManagedByController = true; }
+    const QSharedPointer<QAbstractAnimationJob> &job() const { return m_job; }
 
 protected:
-    void updateCurrentTime(int) Q_DECL_OVERRIDE;
-    void updateState(QAbstractAnimationJob::State newState, QAbstractAnimationJob::State oldState) Q_DECL_OVERRIDE;
-    void debugAnimation(QDebug d) const Q_DECL_OVERRIDE;
+    void updateCurrentTime(int) override;
+    void updateState(QAbstractAnimationJob::State newState, QAbstractAnimationJob::State oldState) override;
+    void debugAnimation(QDebug d) const override;
 
 public Q_SLOTS:
     void windowChanged(QQuickWindow *window);
     void sceneGraphInitialized();
 
 private:
-    void deleteJob();
     void syncBackCurrentValues();
     void readyToAnimate();
     void setWindow(QQuickWindow *window);
@@ -106,7 +102,7 @@ private:
 
     QPointer<QQuickAnimatorController> m_controller;
     QQuickAbstractAnimation *m_animation;
-    QAbstractAnimationJob *m_job;
+    QSharedPointer<QAbstractAnimationJob> m_job;
     int m_duration;
 
     enum InternalState {
@@ -117,7 +113,6 @@ private:
     };
 
     InternalState m_internalState;
-    bool m_jobManagedByController;
 };
 
 class Q_QUICK_PRIVATE_EXPORT QQuickAnimatorJob : public QAbstractAnimationJob
@@ -126,37 +121,53 @@ public:
     virtual void setTarget(QQuickItem *target);
     QQuickItem *target() const { return m_target; }
 
-    void setFrom(qreal scale) { m_from = scale; }
+    void setFrom(qreal from) { m_from = from; }
     qreal from() const { return m_from; }
 
     void setTo(qreal to) { m_to = to; }
     qreal to() const { return m_to; }
 
     void setDuration(int duration) { m_duration = duration; }
-    int duration() const Q_DECL_OVERRIDE { return m_duration; }
+    int duration() const override { return m_duration; }
 
     QEasingCurve easingCurve() const { return m_easing; }
     void setEasingCurve(const QEasingCurve &curve) { m_easing = curve; }
 
-    virtual void targetWasDeleted();
+    // Initialize is called on the GUI thread just before it is started
+    // and taken over on the render thread.
     virtual void initialize(QQuickAnimatorController *controller);
+
+    // Called on the render thread during SG shutdown.
+    virtual void invalidate() = 0;
+
+    // Called on the GUI thread after a complete render thread animation job
+    // has been completed to write back a given animator's result to the
+    // source item.
     virtual void writeBack() = 0;
-    virtual void nodeWasDestroyed() = 0;
-    virtual void afterNodeSync() { }
+
+    // Called before the SG sync on the render thread. The GUI thread is
+    // locked during this call.
+    virtual void preSync() { }
+
+    // Called after the SG sync on the render thread. The GUI thread is
+    // locked during this call.
+    virtual void postSync() { }
+
+    // Called after animations have ticked on the render thread. No locks are
+    // held at this time, so synchronization needs to be taken into account
+    // if applicable.
+    virtual void commit() { }
 
     bool isTransform() const { return m_isTransform; }
     bool isUniform() const { return m_isUniform; }
 
-    bool hasBeenRunning() const { return m_hasBeenRunning; }
-    void setHasBeenRunning(bool has) { m_hasBeenRunning = has; }
-
     qreal value() const;
 
     QQuickAnimatorController *controller() const { return m_controller; }
 
 protected:
     QQuickAnimatorJob();
-    void debugAnimation(QDebug d) const Q_DECL_OVERRIDE;
+    void debugAnimation(QDebug d) const override;
 
     qreal progress(int time) const;
 
@@ -173,7 +184,6 @@ protected:
 
     uint m_isTransform : 1;
     uint m_isUniform : 1;
-    uint m_hasBeenRunning : 1;
 };
 
 class QQuickTransformAnimatorJob : public QQuickAnimatorJob
@@ -197,7 +207,7 @@ public:
         }
 
         void sync();
-        void apply();
+        void commit();
 
         int ref;
         QQuickItem *item;
@@ -217,13 +227,16 @@ public:
     };
 
     ~QQuickTransformAnimatorJob();
-    Helper *transformHelper() const { return m_helper; }
+
+    void commit() override;
+    void preSync() override;
+
+    void setTarget(QQuickItem *item) override;
 
 protected:
     QQuickTransformAnimatorJob();
-    void initialize(QQuickAnimatorController *controller) Q_DECL_OVERRIDE;
-    void nodeWasDestroyed() Q_DECL_OVERRIDE;
-    void targetWasDeleted() Q_DECL_OVERRIDE;
+    void postSync() override;
+    void invalidate() override;
 
     Helper *m_helper;
 };
@@ -231,22 +244,22 @@ protected:
 class Q_QUICK_PRIVATE_EXPORT QQuickScaleAnimatorJob : public QQuickTransformAnimatorJob
 {
 public:
-    void updateCurrentTime(int time) Q_DECL_OVERRIDE;
-    void writeBack() Q_DECL_OVERRIDE;
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
 };
 
 class Q_QUICK_PRIVATE_EXPORT QQuickXAnimatorJob : public QQuickTransformAnimatorJob
 {
 public:
-    void updateCurrentTime(int time) Q_DECL_OVERRIDE;
-    void writeBack() Q_DECL_OVERRIDE;
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
 };
 
 class Q_QUICK_PRIVATE_EXPORT QQuickYAnimatorJob : public QQuickTransformAnimatorJob
 {
 public:
-    void updateCurrentTime(int time) Q_DECL_OVERRIDE;
-    void writeBack() Q_DECL_OVERRIDE;
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
 };
 
 class Q_QUICK_PRIVATE_EXPORT QQuickRotationAnimatorJob : public QQuickTransformAnimatorJob
@@ -254,8 +267,8 @@ class Q_QUICK_PRIVATE_EXPORT QQuickRotationAnimatorJob : public QQuickTransformA
 public:
     QQuickRotationAnimatorJob();
 
-    void updateCurrentTime(int time) Q_DECL_OVERRIDE;
-    void writeBack() Q_DECL_OVERRIDE;
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
 
     void setDirection(QQuickRotationAnimator::RotationDirection direction) { m_direction = direction; }
     QQuickRotationAnimator::RotationDirection direction() const { return m_direction; }
@@ -269,10 +282,10 @@ class Q_QUICK_PRIVATE_EXPORT QQuickOpacityAnimatorJob : public QQuickAnimatorJob
 public:
     QQuickOpacityAnimatorJob();
 
-    void initialize(QQuickAnimatorController *controller) Q_DECL_OVERRIDE;
-    void updateCurrentTime(int time) Q_DECL_OVERRIDE;
-    void writeBack() Q_DECL_OVERRIDE;
-    void nodeWasDestroyed() Q_DECL_OVERRIDE;
+    void invalidate() override;
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
+    void postSync() override;
 
 private:
     QSGOpacityNode *m_opacityNode;
@@ -283,16 +296,17 @@ class Q_QUICK_PRIVATE_EXPORT QQuickUniformAnimatorJob : public QQuickAnimatorJob
 public:
     QQuickUniformAnimatorJob();
 
-    void setTarget(QQuickItem *target) Q_DECL_OVERRIDE;
+    void setTarget(QQuickItem *target) override;
 
     void setUniform(const QByteArray &uniform) { m_uniform = uniform; }
     QByteArray uniform() const { return m_uniform; }
 
-    void afterNodeSync() Q_DECL_OVERRIDE;
+    void postSync() override;
+
+    void updateCurrentTime(int time) override;
+    void writeBack() override;
 
-    void updateCurrentTime(int time) Q_DECL_OVERRIDE;
-    void writeBack() Q_DECL_OVERRIDE;
-    void nodeWasDestroyed() Q_DECL_OVERRIDE;
+    void invalidate() override;
 
 private:
     QByteArray m_uniform;