Remove the 'windows' render loop

For compatibility, QSG_RENDER_LOOP=windows shows a warning and uses
basic.

For OpenGL proper, threaded is the default on Windows since Qt 5.5, so
this will not affect there in any way.

By default the windows loop was only used with ANGLE, or a non-standard opengl32
implementation like the Mesa llvmpipe shipped with the pre-built Qt packages.
(and only on Windows, as the name suggests, even though the implementation of this
loop is not tied to Windows in any way)

For these we default to basic now. This will make no difference in practice:
The windows render loop's value is that it takes the custom animation driver
(advanced per frame, assuming that vsync-based throttling is active) approach from
the threaded loop, while behaving like basic otherwise, thus providing smoother
animations compared to basic, in theory. But due to its relatively little use (not
the default since 5.5), ANGLE being removed in the near future, and not
making much sense for the software rasterizer cases (those will have
bigger problems than smoothly advancing animations, often providing no vsync,
so they are better off with basic anyways), it makes no sense to invest into
adding QRhi support for this loop too.

Task-number: QTBUG-78578
Task-number: QTBUG-82997
Change-Id: I8ccd2e5e375799df5bb5018df247aa5b8197032a
Reviewed-by: Andy Nichols <andy.nichols@qt.io>

7 files changed, 27 insertions, 728 deletions

diff --git a/src/quick/CMakeLists.txt b/src/quick/CMakeLists.txt
index 466c9aedb0..0b0c3e0538 100644
--- a/src/quick/CMakeLists.txt
+++ b/src/quick/CMakeLists.txt
@@ -472,7 +472,6 @@ qt_extend_target(Quick CONDITION QT_FEATURE_opengl OR QT_FEATURE_opengles2 OR QT
         scenegraph/qsgrhilayer.cpp scenegraph/qsgrhilayer_p.h
         scenegraph/qsgrhishadereffectnode.cpp scenegraph/qsgrhishadereffectnode_p.h
         scenegraph/qsgrhitextureglyphcache.cpp scenegraph/qsgrhitextureglyphcache_p.h
-        scenegraph/qsgwindowsrenderloop.cpp scenegraph/qsgwindowsrenderloop_p.h
         scenegraph/util/qsgdefaultimagenode.cpp scenegraph/util/qsgdefaultimagenode_p.h
         scenegraph/util/qsgdefaultninepatchnode.cpp scenegraph/util/qsgdefaultninepatchnode_p.h
         scenegraph/util/qsgdefaultpainternode.cpp scenegraph/util/qsgdefaultpainternode_p.h
diff --git a/src/quick/doc/src/concepts/visualcanvas/scenegraph.qdoc b/src/quick/doc/src/concepts/visualcanvas/scenegraph.qdoc
index e09c430e43..f312bde552 100644
--- a/src/quick/doc/src/concepts/visualcanvas/scenegraph.qdoc
+++ b/src/quick/doc/src/concepts/visualcanvas/scenegraph.qdoc
@@ -179,17 +179,15 @@ render loop.
 For detailed description of how the scene graph renderer works, see \l {Qt
 Quick Scene Graph Default Renderer}.
 
-There are three render loop variants available: \c basic, \c windows,
-and \c threaded. Out of these, \c basic and \c windows are
-single-threaded, while \c threaded performs scene graph rendering on a
-dedicated thread. Qt attempts to choose a suitable loop based on the
-platform and possibly the graphics drivers in use. When this is not
-satisfactory, or for testing purposes, the environment variable
-\c QSG_RENDER_LOOP can be used to force the usage of a given loop. To
-verify which render loop is in use, enable the \c qt.scenegraph.general
-\l {QLoggingCategory}{logging category}.
-
-\note The \c threaded and \c windows render loops rely on the graphics API
+There are two render loop variants available: \c basic, and \c threaded.
+\c basic is single-threaded, while \c threaded performs scene graph rendering on a
+dedicated thread. Qt attempts to choose a suitable loop based on the platform
+and possibly the graphics drivers in use. When this is not satisfactory, or for
+testing purposes, the environment variable \c QSG_RENDER_LOOP can be used to
+force the usage of a given loop. To verify which render loop is in use, enable
+the \c qt.scenegraph.general \l {QLoggingCategory}{logging category}.
+
+\note The \c threaded render loop relies on the graphics API
 implementation for throttling, for example, by requesting a swap interval of 1
 in case of OpenGL. Some graphics drivers allow users to override this setting
 and turn it off, ignoring Qt's request. Without blocking in the swap buffers
@@ -280,15 +278,15 @@ platform, but this is subject to change. It is always possible to force use of
 the threaded renderer by setting \c {QSG_RENDER_LOOP=threaded} in the
 environment.
 
-\section2 Non-threaded Render Loops ("basic" and "windows")
+\section2 Non-threaded Render Loop ("basic")
 
-The non-threaded render loop is currently used by default on Windows with ANGLE
-or a non-default opengl32 implementation, \macos with OpenGL, and Linux with
-some drivers. For the latter this is mostly a precautionary measure, as not all
-combinations of OpenGL drivers and windowing systems have been tested. At the
-same time implementations like ANGLE or Mesa llvmpipe are not able to function
-properly with threaded rendering at all so not using threaded rendering is
-essential for these.
+The non-threaded render loop is currently used by default on Windows with
+OpenGL when not using the system's standard opengl32.dll, \macos with OpenGL,
+and Linux with some drivers. For the latter this is mostly a precautionary
+measure, as not all combinations of OpenGL drivers and windowing systems have
+been tested. At the same time implementations like ANGLE or Mesa llvmpipe are
+not able to function properly with threaded rendering at all so not using
+threaded rendering is essential for these.
 
 On macOS and OpenGL, the threaded render loop is not supported when building
 with XCode 10 (10.14 SDK) or later, since this opts in to layer-backed views on
@@ -296,10 +294,6 @@ macOS 10.14. You can build with Xcode 9 (10.13 SDK) to opt out of
 layer-backing, in which case the threaded render loop is available and used by
 default. There is no such restriction with Metal.
 
-By default \c windows is used for non-threaded rendering on Windows with ANGLE,
-while \c basic is used for all other platforms when non-threaded rendering is
-needed.
-
 Even when using the non-threaded render loop, you should write your code as if
 you are using the threaded renderer, as failing to do so will make the code
 non-portable.
diff --git a/src/quick/scenegraph/qsgrenderloop.cpp b/src/quick/scenegraph/qsgrenderloop.cpp
index cb9f7f331f..a9f7a3a963 100644
--- a/src/quick/scenegraph/qsgrenderloop.cpp
+++ b/src/quick/scenegraph/qsgrenderloop.cpp
@@ -39,7 +39,6 @@
 
 #include "qsgrenderloop_p.h"
 #include "qsgthreadedrenderloop_p.h"
-#include "qsgwindowsrenderloop_p.h"
 #include "qsgrhisupport_p.h"
 #include <private/qquickanimatorcontroller_p.h>
 
@@ -238,13 +237,10 @@ QSGRenderLoop *QSGRenderLoop::instance()
             } else {
                 loopType = BasicRenderLoop;
 #ifdef Q_OS_WIN
-                // With desktop OpenGL (opengl32.dll), use threaded. Otherwise (ANGLE) use windows.
                 if (QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGL
                         && QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedOpenGL))
                 {
                     loopType = ThreadedRenderLoop;
-                } else {
-                    loopType = WindowsRenderLoop;
                 }
 #else
                 if (QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedOpenGL))
@@ -271,10 +267,6 @@ QSGRenderLoop *QSGRenderLoop::instance()
                 default:
                     break;
                 }
-
-                // no 'windows' because that's not yet ported to the rhi
-                if (loopType == WindowsRenderLoop)
-                    loopType = BasicRenderLoop;
             }
 
             // The environment variables can always override. This is good
@@ -288,12 +280,14 @@ QSGRenderLoop *QSGRenderLoop::instance()
 
             if (Q_UNLIKELY(qEnvironmentVariableIsSet("QSG_RENDER_LOOP"))) {
                 const QByteArray loopName = qgetenv("QSG_RENDER_LOOP");
-                if (loopName == "windows")
-                    loopType = WindowsRenderLoop;
-                else if (loopName == "basic")
+                if (loopName == "windows") {
+                    qWarning("The 'windows' render loop is no longer supported. Using 'basic' instead.");
+                    loopType = BasicRenderLoop;
+                } else if (loopName == "basic") {
                     loopType = BasicRenderLoop;
-                else if (loopName == "threaded")
+                } else if (loopName == "threaded") {
                     loopType = ThreadedRenderLoop;
+                }
             }
 
             switch (loopType) {
@@ -303,12 +297,8 @@ QSGRenderLoop *QSGRenderLoop::instance()
                 s_instance = new QSGThreadedRenderLoop();
                 break;
 #endif
-            case WindowsRenderLoop:
-                qCDebug(QSG_LOG_INFO, "windows render loop");
-                s_instance = new QSGWindowsRenderLoop();
-                break;
             default:
-                qCDebug(QSG_LOG_INFO, "QSG: basic render loop");
+                qCDebug(QSG_LOG_INFO, "basic render loop");
                 s_instance = new QSGGuiThreadRenderLoop();
                 break;
             }
diff --git a/src/quick/scenegraph/qsgrenderloop_p.h b/src/quick/scenegraph/qsgrenderloop_p.h
index 9fd0ab02f5..e9357f2061 100644
--- a/src/quick/scenegraph/qsgrenderloop_p.h
+++ b/src/quick/scenegraph/qsgrenderloop_p.h
@@ -126,8 +126,7 @@ private:
 enum QSGRenderLoopType
 {
     BasicRenderLoop,
-    ThreadedRenderLoop,
-    WindowsRenderLoop
+    ThreadedRenderLoop
 };
 
 QT_END_NAMESPACE
diff --git a/src/quick/scenegraph/qsgwindowsrenderloop.cpp b/src/quick/scenegraph/qsgwindowsrenderloop.cpp
deleted file mode 100644
index 03c9183126..0000000000
--- a/src/quick/scenegraph/qsgwindowsrenderloop.cpp
+++ /dev/null
@@ -1,552 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtQuick module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qsgwindowsrenderloop_p.h"
-#include <QtCore/QCoreApplication>
-#include <QtCore/QLibraryInfo>
-#include <QtCore/QThread>
-
-#include <QtGui/QScreen>
-#include <QtGui/QGuiApplication>
-#include <QtGui/QOffscreenSurface>
-
-#include <QtQuick/private/qsgcontext_p.h>
-#include <QtQuick/private/qquickwindow_p.h>
-#include <QtQuick/private/qquickitem_p.h>
-#include <QtQuick/private/qsgrenderer_p.h>
-#include <QtQuick/private/qsgdefaultrendercontext_p.h>
-
-#include <QtQuick/QQuickWindow>
-
-#include <private/qquickprofiler_p.h>
-#include <private/qquickanimatorcontroller_p.h>
-
-#if QT_CONFIG(quick_shadereffect) && QT_CONFIG(opengl)
-#include <private/qquickopenglshadereffectnode_p.h>
-#endif
-
-#include <qtquick_tracepoints_p.h>
-
-QT_BEGIN_NAMESPACE
-
-// Single-threaded render loop with a custom animation driver. Like a
-// combination of basic+threaded but still working on the main thread. Only
-// compatible with direct OpenGL, no RHI support here.
-
-extern Q_GUI_EXPORT QImage qt_gl_read_framebuffer(const QSize &size, bool alpha_format, bool include_alpha);
-
-#define RLDEBUG(x) qCDebug(QSG_LOG_RENDERLOOP, x)
-
-static QElapsedTimer qsg_render_timer;
-#define QSG_LOG_TIME_SAMPLE(sampleName) \
-    qint64 sampleName = 0;                                                  \
-    if (QSG_LOG_TIME_RENDERLOOP().isDebugEnabled())  \
-        sampleName = qsg_render_timer.nsecsElapsed(); \
-
-#define QSG_RENDER_TIMING_SAMPLE(frameType, sampleName, position) \
-    QSG_LOG_TIME_SAMPLE(sampleName) \
-    Q_QUICK_SG_PROFILE_RECORD(frameType, position);
-
-
-QSGWindowsRenderLoop::QSGWindowsRenderLoop()
-    : m_gl(nullptr)
-    , m_sg(QSGContext::createDefaultContext())
-    , m_updateTimer(0)
-    , m_animationTimer(0)
-{
-    m_rc = static_cast<QSGDefaultRenderContext *>(m_sg->createRenderContext());
-
-    m_vsyncDelta = 1000 / QGuiApplication::primaryScreen()->refreshRate();
-    if (m_vsyncDelta <= 0)
-        m_vsyncDelta = 16;
-
-    RLDEBUG("Windows Render Loop created");
-
-    m_animationDriver = m_sg->createAnimationDriver(m_sg);
-    connect(m_animationDriver, SIGNAL(started()), this, SLOT(started()));
-    connect(m_animationDriver, SIGNAL(stopped()), this, SLOT(stopped()));
-    m_animationDriver->install();
-
-    qsg_render_timer.start();
-}
-
-QSGWindowsRenderLoop::~QSGWindowsRenderLoop()
-{
-    delete m_rc;
-    delete m_sg;
-}
-
-bool QSGWindowsRenderLoop::interleaveIncubation() const
-{
-    return m_animationDriver->isRunning() && anyoneShowing();
-}
-
-QSGWindowsRenderLoop::WindowData *QSGWindowsRenderLoop::windowData(QQuickWindow *window)
-{
-    for (int i=0; i<m_windows.size(); ++i) {
-        WindowData &wd = m_windows[i];
-        if (wd.window == window)
-            return &wd;
-    }
-    return nullptr;
-}
-
-void QSGWindowsRenderLoop::maybePostUpdateTimer()
-{
-    if (!m_updateTimer) {
-        RLDEBUG(" - posting event");
-        m_updateTimer = startTimer(m_vsyncDelta / 3);
-    }
-}
-
-/*
- * If no windows are showing, start ticking animations using a timer,
- * otherwise, start rendering
- */
-void QSGWindowsRenderLoop::started()
-{
-    RLDEBUG("Animations started...");
-    if (!anyoneShowing()) {
-        if (m_animationTimer == 0) {
-            RLDEBUG(" - starting non-visual animation timer");
-            m_animationTimer = startTimer(m_vsyncDelta);
-        }
-    } else {
-        maybePostUpdateTimer();
-    }
-}
-
-void QSGWindowsRenderLoop::stopped()
-{
-    RLDEBUG("Animations stopped...");
-    if (m_animationTimer) {
-        RLDEBUG(" - stopping non-visual animation timer");
-        killTimer(m_animationTimer);
-        m_animationTimer = 0;
-    }
-}
-
-void QSGWindowsRenderLoop::show(QQuickWindow *window)
-{
-    RLDEBUG("show");
-    if (windowData(window) != nullptr)
-        return;
-
-    // This happens before the platform window is shown, but after
-    // it is created. Creating the GL context takes a lot of time
-    // (hundreds of milliseconds) and will prevent us from rendering
-    // the first frame in time for the initial show on screen.
-    // By preparing the GL context here, it is feasible (if the app
-    // is quick enough) to have a perfect first frame.
-    if (!m_gl) {
-        RLDEBUG(" - creating GL context");
-        m_gl = new QOpenGLContext();
-        m_gl->setFormat(window->requestedFormat());
-        m_gl->setScreen(window->screen());
-        if (qt_gl_global_share_context())
-            m_gl->setShareContext(qt_gl_global_share_context());
-        bool created = m_gl->create();
-        if (!created) {
-            delete m_gl;
-            m_gl = nullptr;
-            handleContextCreationFailure(window);
-            return;
-        }
-
-        QQuickWindowPrivate::get(window)->fireOpenGLContextCreated(m_gl);
-
-        RLDEBUG(" - making current");
-        bool current = m_gl->makeCurrent(window);
-        RLDEBUG(" - initializing SG");
-        if (current) {
-            QSGDefaultRenderContext::InitParams rcParams;
-            rcParams.sampleCount = qMax(1, m_gl->format().samples());
-            rcParams.openGLContext = m_gl;
-            rcParams.initialSurfacePixelSize = window->size() * window->effectiveDevicePixelRatio();
-            rcParams.maybeSurface = window;
-            m_rc->initialize(&rcParams);
-        }
-    }
-
-    WindowData data;
-    data.window = window;
-    data.pendingUpdate = false;
-    m_windows << data;
-
-    RLDEBUG(" - done with show");
-}
-
-void QSGWindowsRenderLoop::hide(QQuickWindow *window)
-{
-    RLDEBUG("hide");
-    // The expose event is queued while hide is sent synchronously, so
-    // the value might not be updated yet. (plus that the windows plugin
-    // sends exposed=true when it goes to hidden, so it is doubly broken)
-    // The check is made here, after the removal from m_windows, so
-    // anyoneShowing will report the right value.
-    if (window->isExposed())
-        handleObscurity();
-    if (!m_gl)
-        return;
-    QQuickWindowPrivate::get(window)->fireAboutToStop();
-}
-
-void QSGWindowsRenderLoop::windowDestroyed(QQuickWindow *window)
-{
-    RLDEBUG("windowDestroyed");
-    for (int i=0; i<m_windows.size(); ++i) {
-        if (m_windows.at(i).window == window) {
-            m_windows.removeAt(i);
-            break;
-        }
-    }
-
-    hide(window);
-
-    QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
-
-    bool current = false;
-    QScopedPointer<QOffscreenSurface> offscreenSurface;
-    if (m_gl) {
-        QSurface *surface = window;
-        // There may be no platform window if the window got closed.
-        if (!window->handle()) {
-            offscreenSurface.reset(new QOffscreenSurface);
-            offscreenSurface->setFormat(m_gl->format());
-            offscreenSurface->create();
-            surface = offscreenSurface.data();
-        }
-        current = m_gl->makeCurrent(surface);
-    }
-    if (Q_UNLIKELY(!current))
-        RLDEBUG("cleanup without an OpenGL context");
-
-#if QT_CONFIG(quick_shadereffect) && QT_CONFIG(opengl)
-    if (current)
-        QQuickOpenGLShaderEffectMaterial::cleanupMaterialCache();
-#endif
-
-    d->cleanupNodesOnShutdown();
-    if (m_windows.size() == 0) {
-        d->context->invalidate();
-        delete m_gl;
-        m_gl = nullptr;
-    } else if (m_gl && current) {
-        m_gl->doneCurrent();
-    }
-
-    d->animationController.reset();
-}
-
-bool QSGWindowsRenderLoop::anyoneShowing() const
-{
-    for (const WindowData &wd : qAsConst(m_windows))
-        if (wd.window->isVisible() && wd.window->isExposed() && wd.window->size().isValid())
-            return true;
-    return false;
-}
-
-void QSGWindowsRenderLoop::exposureChanged(QQuickWindow *window)
-{
-
-    if (windowData(window) == nullptr)
-        return;
-
-    if (window->isExposed() && window->isVisible()) {
-
-        // Stop non-visual animation timer as we now have a window rendering
-        if (m_animationTimer && anyoneShowing()) {
-            RLDEBUG(" - stopping non-visual animation timer");
-            killTimer(m_animationTimer);
-            m_animationTimer = 0;
-        }
-
-        RLDEBUG("exposureChanged - exposed");
-        WindowData *wd = windowData(window);
-        wd->pendingUpdate = true;
-
-        // If we have a pending timer and we get an expose, we need to stop it.
-        // Otherwise we get two frames and two animation ticks in the same time-interval.
-        if (m_updateTimer) {
-            RLDEBUG(" - killing pending update timer");
-            killTimer(m_updateTimer);
-            m_updateTimer = 0;
-        }
-        render();
-    } else {
-        handleObscurity();
-    }
-}
-
-void QSGWindowsRenderLoop::handleObscurity()
-{
-    RLDEBUG("handleObscurity");
-    // Potentially start the non-visual animation timer if nobody is rendering
-    if (m_animationDriver->isRunning() && !anyoneShowing() && !m_animationTimer) {
-        RLDEBUG(" - starting non-visual animation timer");
-        m_animationTimer = startTimer(m_vsyncDelta);
-    }
-}
-
-QImage QSGWindowsRenderLoop::grab(QQuickWindow *window)
-{
-    RLDEBUG("grab");
-    if (!m_gl)
-        return QImage();
-
-    m_gl->makeCurrent(window);
-
-    QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
-    d->polishItems();
-    d->syncSceneGraph();
-    d->renderSceneGraph(window->size());
-
-    bool alpha = window->format().alphaBufferSize() > 0 && window->color().alpha() != 255;
-    QImage image = qt_gl_read_framebuffer(window->size() * window->effectiveDevicePixelRatio(), alpha, alpha);
-    image.setDevicePixelRatio(window->effectiveDevicePixelRatio());
-    return image;
-}
-
-void QSGWindowsRenderLoop::update(QQuickWindow *window)
-{
-    RLDEBUG("update");
-    maybeUpdate(window);
-}
-
-void QSGWindowsRenderLoop::maybeUpdate(QQuickWindow *window)
-{
-    RLDEBUG("maybeUpdate");
-
-    WindowData *wd = windowData(window);
-    if (!wd || !anyoneShowing())
-        return;
-
-    wd->pendingUpdate = true;
-    maybePostUpdateTimer();
-}
-
-QSGRenderContext *QSGWindowsRenderLoop::createRenderContext(QSGContext *) const
-{
-    return m_rc;
-}
-
-bool QSGWindowsRenderLoop::event(QEvent *event)
-{
-    switch (event->type()) {
-    case QEvent::Timer: {
-        QTimerEvent *te = static_cast<QTimerEvent *>(event);
-        if (te->timerId() == m_animationTimer) {
-            RLDEBUG("event : animation tick while nothing is showing");
-            m_animationDriver->advance();
-        } else if (te->timerId() == m_updateTimer) {
-            RLDEBUG("event : update");
-            killTimer(m_updateTimer);
-            m_updateTimer = 0;
-            render();
-        }
-        return true; }
-    default:
-        break;
-    }
-
-    return QObject::event(event);
-}
-
-/*
- * Go through all windows we control and render them in turn.
- * Then tick animations if active.
- */
-void QSGWindowsRenderLoop::render()
-{
-    RLDEBUG("render");
-    Q_TRACE(QSG_render_entry);
-    bool rendered = false;
-    for (const WindowData &wd : qAsConst(m_windows)) {
-        if (wd.pendingUpdate) {
-            const_cast<WindowData &>(wd).pendingUpdate = false;
-            renderWindow(wd.window);
-            rendered = true;
-        }
-    }
-
-    if (!rendered) {
-        RLDEBUG("no changes, sleep");
-        QThread::msleep(m_vsyncDelta);
-    }
-
-    Q_TRACE(QSG_render_exit);
-
-    if (m_animationDriver->isRunning()) {
-        RLDEBUG("advancing animations");
-        QSG_LOG_TIME_SAMPLE(time_start);
-        Q_QUICK_SG_PROFILE_START(QQuickProfiler::SceneGraphWindowsAnimations);
-        Q_TRACE(QSG_animations_entry);
-        m_animationDriver->advance();
-        RLDEBUG("animations advanced");
-
-        qCDebug(QSG_LOG_TIME_RENDERLOOP,
-                "animations ticked in %dms",
-                int((qsg_render_timer.nsecsElapsed() - time_start)/1000000));
-
-        Q_TRACE(QSG_animations_exit);
-        Q_QUICK_SG_PROFILE_END(QQuickProfiler::SceneGraphWindowsAnimations, 1);
-
-        // It is not given that animations triggered another maybeUpdate()
-        // and thus another render pass, so to keep things running,
-        // make sure there is another frame pending.
-        maybePostUpdateTimer();
-
-        emit timeToIncubate();
-    }
-}
-
-/*
- * Render the contents of this window. First polish, then sync, render
- * then finally swap.
- *
- * Note: This render function does not implement aborting
- * the render call when sync step results in no scene graph changes,
- * like the threaded renderer does.
- */
-void QSGWindowsRenderLoop::renderWindow(QQuickWindow *window)
-{
-    RLDEBUG("renderWindow");
-    QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
-
-    if (!d->isRenderable())
-        return;
-
-    if (!m_gl->makeCurrent(window)) {
-        // Check for context loss.
-        if (!m_gl->isValid()) {
-            d->cleanupNodesOnShutdown();
-            m_rc->invalidate();
-            if (m_gl->create() && m_gl->makeCurrent(window)) {
-                QSGDefaultRenderContext::InitParams rcParams;
-                rcParams.sampleCount = qMax(1, m_gl->format().samples());
-                rcParams.openGLContext = m_gl;
-                rcParams.initialSurfacePixelSize = window->size() * window->effectiveDevicePixelRatio();
-                rcParams.maybeSurface = window;
-                m_rc->initialize(&rcParams);
-            } else {
-                return;
-            }
-        }
-    }
-
-    bool lastDirtyWindow = true;
-    for (int i=0; i<m_windows.size(); ++i) {
-        if ( m_windows[i].pendingUpdate) {
-            lastDirtyWindow = false;
-            break;
-        }
-    }
-
-    d->flushFrameSynchronousEvents();
-    // Event delivery or processing has caused the window to stop rendering.
-    if (!windowData(window))
-        return;
-
-    Q_TRACE_SCOPE(QSG_renderWindow);
-
-    QSG_LOG_TIME_SAMPLE(time_start);
-    Q_QUICK_SG_PROFILE_START(QQuickProfiler::SceneGraphPolishFrame);
-    Q_TRACE(QSG_polishItems_entry);
-
-    RLDEBUG(" - polishing");
-    d->polishItems();
-    QSG_LOG_TIME_SAMPLE(time_polished);
-    Q_TRACE(QSG_polishItems_exit);
-    Q_QUICK_SG_PROFILE_SWITCH(QQuickProfiler::SceneGraphPolishFrame,
-                              QQuickProfiler::SceneGraphRenderLoopFrame,
-                              QQuickProfiler::SceneGraphPolishPolish);
-    Q_TRACE(QSG_sync_entry);
-
-    emit window->afterAnimating();
-
-    RLDEBUG(" - syncing");
-    d->syncSceneGraph();
-    if (lastDirtyWindow)
-        m_rc->endSync();
-    Q_TRACE(QSG_sync_exit);
-    QSG_RENDER_TIMING_SAMPLE(QQuickProfiler::SceneGraphRenderLoopFrame, time_synced,
-                             QQuickProfiler::SceneGraphRenderLoopSync);
-    Q_TRACE(QSG_render_entry);
-
-    RLDEBUG(" - rendering");
-    d->renderSceneGraph(window->size());
-    Q_TRACE(QSG_render_exit);
-    QSG_RENDER_TIMING_SAMPLE(QQuickProfiler::SceneGraphRenderLoopFrame, time_rendered,
-                             QQuickProfiler::SceneGraphRenderLoopRender);
-    Q_TRACE(QSG_swap_entry);
-
-    RLDEBUG(" - swapping");
-    if (!d->customRenderStage || !d->customRenderStage->swap())
-        m_gl->swapBuffers(window);
-    Q_TRACE(QSG_swap_exit);
-    QSG_RENDER_TIMING_SAMPLE(QQuickProfiler::SceneGraphRenderLoopFrame, time_swapped,
-                             QQuickProfiler::SceneGraphRenderLoopSwap);
-
-    RLDEBUG(" - frameDone");
-    d->fireFrameSwapped();
-
-    qCDebug(QSG_LOG_TIME_RENDERLOOP()).nospace()
-            << "Frame rendered with 'windows' renderloop in: " << (time_swapped - time_start) / 1000000 << "ms"
-            << ", polish=" << (time_polished - time_start) / 1000000
-            << ", sync=" << (time_synced - time_polished) / 1000000
-            << ", render=" << (time_rendered - time_synced) / 1000000
-            << ", swap=" << (time_swapped - time_rendered) / 1000000
-            << " - " << window;
-
-    Q_QUICK_SG_PROFILE_REPORT(QQuickProfiler::SceneGraphRenderLoopFrame,
-                              QQuickProfiler::SceneGraphRenderLoopSwap);
-}
-
-void QSGWindowsRenderLoop::releaseResources(QQuickWindow *w)
-{
-    // No full invalidation of the rendercontext, just clear some caches.
-    RLDEBUG("releaseResources");
-    QQuickWindowPrivate *d = QQuickWindowPrivate::get(w);
-    if (d->renderer)
-        d->renderer->releaseCachedResources();
-}
-
-QT_END_NAMESPACE
-
-#include "moc_qsgwindowsrenderloop_p.cpp"
diff --git a/src/quick/scenegraph/qsgwindowsrenderloop_p.h b/src/quick/scenegraph/qsgwindowsrenderloop_p.h
deleted file mode 100644
index 4021ddb369..0000000000
--- a/src/quick/scenegraph/qsgwindowsrenderloop_p.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtQuick module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QSGWINDOWSRENDERLOOP_P_H
-#define QSGWINDOWSRENDERLOOP_P_H
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Qt API.  It exists purely as an
-// implementation detail.  This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <QtCore/QObject>
-#include <QtCore/QElapsedTimer>
-
-#include <QOpenGLContext>
-
-#include "qsgrenderloop_p.h"
-
-QT_BEGIN_NAMESPACE
-
-class QSGRenderContext;
-class QSGDefaultRenderContext;
-
-class QSGWindowsRenderLoop : public QSGRenderLoop
-{
-    Q_OBJECT
-public:
-    explicit QSGWindowsRenderLoop();
-    ~QSGWindowsRenderLoop();
-
-    void show(QQuickWindow *window) override;
-    void hide(QQuickWindow *window) override;
-
-    void windowDestroyed(QQuickWindow *window) override;
-
-    void exposureChanged(QQuickWindow *window) override;
-    QImage grab(QQuickWindow *window) override;
-
-    void update(QQuickWindow *window) override;
-    void maybeUpdate(QQuickWindow *window) override;
-
-    QAnimationDriver *animationDriver() const override { return m_animationDriver; }
-
-    QSGContext *sceneGraphContext() const override { return m_sg; }
-    QSGRenderContext *createRenderContext(QSGContext *) const override;
-
-    void releaseResources(QQuickWindow *) override;
-
-    void render();
-    void renderWindow(QQuickWindow *window);
-
-    bool event(QEvent *event) override;
-    bool anyoneShowing() const;
-
-    bool interleaveIncubation() const override;
-
-public Q_SLOTS:
-    void started();
-    void stopped();
-
-private:
-    struct WindowData {
-        QQuickWindow *window;
-        bool pendingUpdate;
-    };
-
-    void handleObscurity();
-    void maybePostUpdateTimer();
-    WindowData *windowData(QQuickWindow *window);
-
-    QList<WindowData> m_windows;
-
-    QOpenGLContext *m_gl;
-    QSGContext *m_sg;
-    QSGDefaultRenderContext *m_rc;
-
-    QAnimationDriver *m_animationDriver;
-
-    int m_updateTimer;
-    int m_animationTimer;
-
-    int m_vsyncDelta;
-};
-
-QT_END_NAMESPACE
-
-#endif // QSGWINDOWSRENDERLOOP_P_H
diff --git a/src/quick/scenegraph/scenegraph.pri b/src/quick/scenegraph/scenegraph.pri
index 494ff7276e..87146dcac8 100644
--- a/src/quick/scenegraph/scenegraph.pri
+++ b/src/quick/scenegraph/scenegraph.pri
@@ -137,8 +137,7 @@ qtConfig(opengl(es1|es2)?) {
         $$PWD/util/qsgdefaultrectanglenode.cpp \
         $$PWD/util/qsgdefaultimagenode.cpp \
         $$PWD/util/qsgdefaultninepatchnode.cpp \
-        $$PWD/qsgopengllayer.cpp \
-        $$PWD/qsgwindowsrenderloop.cpp
+        $$PWD/qsgopengllayer.cpp
     HEADERS += \
         $$PWD/qsgdefaultglyphnode_p.h \
         $$PWD/qsgopengldistancefieldglyphcache_p.h \
@@ -153,8 +152,7 @@ qtConfig(opengl(es1|es2)?) {
         $$PWD/util/qsgdefaultrectanglenode_p.h \
         $$PWD/util/qsgdefaultimagenode_p.h \
         $$PWD/util/qsgdefaultninepatchnode_p.h \
-        $$PWD/qsgopengllayer_p.h \
-        $$PWD/qsgwindowsrenderloop_p.h
+        $$PWD/qsgopengllayer_p.h
 
     qtConfig(thread) {
         SOURCES += \