Introduce a GLShader class

GLShader is renderer specific shader implementation for OpenGL.
Shader now contains only backend information for a QShaderProgram frontend
node.
- Similar to the GLTexture handling, a generic adopt/abandon manager for
shaders was introduced (regardless of the actually GraphicsAPIShader class).
- The renderer and renderviews were adapted to the new changes.

This was the last major thing preventing the modularisation of the
QRenderAspect and renderers

Change-Id: If671d60928b433977e9d6e5c58199827f9408a3f
Task-number: QTBUG-61151
Reviewed-by: Mike Krus <mike.krus@kdab.com>

6 files changed, 299 insertions, 357 deletions

diff --git a/tests/auto/render/shadercache/shadercache.pro b/tests/auto/render/glshadermanager/glshadermanager.pro
index 38499588d..27aadf84f 100644
--- a/tests/auto/render/shadercache/shadercache.pro
+++ b/tests/auto/render/glshadermanager/glshadermanager.pro
@@ -1,11 +1,12 @@
 TEMPLATE = app
 
-TARGET = tst_shadercache
+TARGET = tst_glshadermanager
 
 QT += core-private 3dcore 3dcore-private 3drender 3drender-private testlib
 
 CONFIG += testcase
 
-SOURCES += tst_shadercache.cpp
+SOURCES += tst_glshadermanager.cpp
 
 include(../../core/common/common.pri)
+include(../commons/commons.pri)
diff --git a/tests/auto/render/glshadermanager/tst_glshadermanager.cpp b/tests/auto/render/glshadermanager/tst_glshadermanager.cpp
new file mode 100644
index 000000000..c18fb4793
--- /dev/null
+++ b/tests/auto/render/glshadermanager/tst_glshadermanager.cpp
@@ -0,0 +1,199 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** 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 General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** 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-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QTest>
+#include <Qt3DRender/private/glresourcemanagers_p.h>
+#include <Qt3DCore/qnodeid.h>
+#include "qbackendnodetester.h"
+#include "testrenderer.h"
+
+class tst_GLShaderManager : public Qt3DCore::QBackendNodeTester
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void adopt();
+    void lookupResource();
+    void abandon();
+    void insertAfterRemoval();
+};
+
+void tst_GLShaderManager::adopt()
+{
+    // GIVEN
+    Qt3DRender::Render::GLShaderManager cache;
+    Qt3DRender::QShaderProgram frontendShader1;
+    Qt3DRender::QShaderProgram frontendShader2;
+    TestRenderer renderer;
+    Qt3DRender::Render::Shader backendShaderNode1;
+    Qt3DRender::Render::Shader backendShaderNode2;
+
+    backendShaderNode1.setRenderer(&renderer);
+    backendShaderNode2.setRenderer(&renderer);
+    simulateInitialization(&frontendShader1, &backendShaderNode1);
+    simulateInitialization(&frontendShader2, &backendShaderNode2);
+
+    // THEN
+    QVERIFY(cache.lookupResource(backendShaderNode1.peerId()) == nullptr);
+    QVERIFY(cache.lookupResource(backendShaderNode2.peerId()) == nullptr);
+    QVERIFY(backendShaderNode1.peerId() != backendShaderNode2.peerId());
+
+    // WHEN
+    Qt3DRender::Render::GLShader *glShader1 = cache.createOrAdoptExisting(&backendShaderNode1);
+
+    // THEN
+    QVERIFY(glShader1 != nullptr);
+    QVector<Qt3DCore::QNodeId> shaderNodeIds = cache.shaderIdsForProgram(glShader1);
+    QCOMPARE(shaderNodeIds.size(), 1);
+    QCOMPARE(shaderNodeIds.first(), backendShaderNode1.peerId());
+
+    // WHEN
+    Qt3DRender::Render::GLShader *glShader2 = cache.createOrAdoptExisting(&backendShaderNode2);
+
+    // THEN
+    QCOMPARE(glShader1, glShader2);
+
+    shaderNodeIds = cache.shaderIdsForProgram(glShader2);
+    QCOMPARE(shaderNodeIds.size(), 2);
+    QCOMPARE(shaderNodeIds.first(), backendShaderNode1.peerId());
+    QCOMPARE(shaderNodeIds.last(), backendShaderNode2.peerId());
+}
+
+void tst_GLShaderManager::lookupResource()
+{
+    // GIVEN
+    Qt3DRender::Render::GLShaderManager cache;
+    Qt3DRender::QShaderProgram frontendShader1;
+    Qt3DRender::QShaderProgram frontendShader2;
+    TestRenderer renderer;
+    Qt3DRender::Render::Shader backendShaderNode1;
+    Qt3DRender::Render::Shader backendShaderNode2;
+
+    backendShaderNode1.setRenderer(&renderer);
+    backendShaderNode2.setRenderer(&renderer);
+    simulateInitialization(&frontendShader1, &backendShaderNode1);
+    simulateInitialization(&frontendShader2, &backendShaderNode2);
+
+    // WHEN
+    cache.createOrAdoptExisting(&backendShaderNode1);
+    cache.createOrAdoptExisting(&backendShaderNode2);
+
+    // THEN
+    Qt3DRender::Render::GLShader *glShader1 = cache.lookupResource(backendShaderNode1.peerId());
+    Qt3DRender::Render::GLShader *glShader2 = cache.lookupResource(backendShaderNode2.peerId());
+    QVERIFY(glShader1 != nullptr);
+    QCOMPARE(glShader1, glShader2);
+    const QVector<Qt3DCore::QNodeId> shaderNodeIds = cache.shaderIdsForProgram(glShader1);
+    QCOMPARE(shaderNodeIds.size(), 2);
+    QVERIFY(shaderNodeIds.contains(frontendShader1.id()));
+    QVERIFY(shaderNodeIds.contains(frontendShader2.id()));
+}
+
+void tst_GLShaderManager::abandon()
+{
+    // GIVEN
+    Qt3DRender::Render::GLShaderManager cache;
+    Qt3DRender::QShaderProgram frontendShader1;
+    Qt3DRender::QShaderProgram frontendShader2;
+    TestRenderer renderer;
+    Qt3DRender::Render::Shader backendShaderNode1;
+    Qt3DRender::Render::Shader backendShaderNode2;
+
+    backendShaderNode1.setRenderer(&renderer);
+    backendShaderNode2.setRenderer(&renderer);
+    simulateInitialization(&frontendShader1, &backendShaderNode1);
+    simulateInitialization(&frontendShader2, &backendShaderNode2);
+    cache.createOrAdoptExisting(&backendShaderNode1);
+    cache.createOrAdoptExisting(&backendShaderNode2);
+
+    // WHEN
+    Qt3DRender::Render::GLShader *glShader = cache.lookupResource(backendShaderNode1.peerId());
+    cache.abandon(glShader, &backendShaderNode1);
+
+    // THEN
+    QVector<Qt3DCore::QNodeId> shaderNodeIds = cache.shaderIdsForProgram(glShader);
+    QVERIFY(cache.takeAbandonned().isEmpty());
+    QCOMPARE(shaderNodeIds.size(), 1);
+    QCOMPARE(shaderNodeIds.first(), backendShaderNode2.peerId());
+
+    // WHEN
+    cache.abandon(glShader, &backendShaderNode2);
+
+    // THEN
+    shaderNodeIds = cache.shaderIdsForProgram(glShader);
+    QCOMPARE(shaderNodeIds.size(), 0);
+    const QVector<Qt3DRender::Render::GLShader *> releasedShaders = cache.takeAbandonned();
+    QCOMPARE(releasedShaders.size(), 1);
+    QCOMPARE(releasedShaders.first(), glShader);
+}
+
+void tst_GLShaderManager::insertAfterRemoval()
+{
+    // GIVEN
+    Qt3DRender::Render::GLShaderManager cache;
+    Qt3DRender::QShaderProgram frontendShader;
+    TestRenderer renderer;
+    Qt3DRender::Render::Shader backendShaderNode;
+
+
+    backendShaderNode.setRenderer(&renderer);
+    simulateInitialization(&frontendShader, &backendShaderNode);
+
+    // WHEN
+    Qt3DRender::Render::GLShader *apiShader1 = cache.createOrAdoptExisting(&backendShaderNode);
+    const Qt3DRender::Render::GLShader *originalApiShader = apiShader1;
+
+    // THEN
+    auto apiShader2 = cache.lookupResource(frontendShader.id());
+    QVERIFY(apiShader1 != nullptr);
+    QVERIFY(apiShader2 != nullptr);
+    QVERIFY(apiShader1 == originalApiShader);
+    QVERIFY(apiShader1 == apiShader2);
+
+    // WHEN
+    cache.abandon(apiShader1, &backendShaderNode);
+
+    // THEN
+    Qt3DRender::Render::GLShader *apiShaderEmpty = cache.lookupResource(frontendShader.id());
+    QVERIFY(apiShaderEmpty == nullptr);
+
+    // WHEN
+    apiShader1 = cache.createOrAdoptExisting(&backendShaderNode);
+    cache.purge();
+    apiShader2 = cache.lookupResource(frontendShader.id());
+
+    // THEN
+    QVERIFY(apiShader1 != nullptr);
+    QVERIFY(apiShader2 != nullptr);
+    QVERIFY(apiShader1 == apiShader2);
+    QVERIFY(apiShader2 == originalApiShader);
+}
+
+QTEST_APPLESS_MAIN(tst_GLShaderManager)
+
+#include "tst_glshadermanager.moc"
diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro
index 908426570..2b73ec8b7 100644
--- a/tests/auto/render/render.pro
+++ b/tests/auto/render/render.pro
@@ -42,7 +42,6 @@ qtConfig(private_tests) {
 #        boundingvolumedebug \
         ddstextures \
         ktxtextures \
-        shadercache \
         layerfiltering \
         filterentitybycomponent \
         genericlambdajob \
@@ -130,6 +129,7 @@ qtConfig(qt3d-opengl-renderer):qtConfig(private_tests) {
         graphicshelpergl3_3 \
         graphicshelpergl3_2 \
         graphicshelpergl2 \
+        glshadermanager \
         materialparametergathererjob \
         textures \
         renderer \
diff --git a/tests/auto/render/renderviews/tst_renderviews.cpp b/tests/auto/render/renderviews/tst_renderviews.cpp
index 086ff0220..b434fe83a 100644
--- a/tests/auto/render/renderviews/tst_renderviews.cpp
+++ b/tests/auto/render/renderviews/tst_renderviews.cpp
@@ -36,6 +36,9 @@
 #include <private/rendercommand_p.h>
 #include <testpostmanarbiter.h>
 #include <testrenderer.h>
+#include <private/shader_p.h>
+#include <private/glresourcemanagers_p.h>
+#include <Qt3DRender/qshaderprogram.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -64,6 +67,7 @@ void compareShaderParameterPacks(const ShaderParameterPack &t1,
 class tst_RenderViews : public Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
+
 private Q_SLOTS:
 
     void checkRenderViewSizeFitsWithAllocator()
@@ -132,10 +136,15 @@ private Q_SLOTS:
     void checkRenderCommandBackToFrontSorting()
     {
         // GIVEN
+        Qt3DRender::Render::NodeManagers nodeManagers;
+        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
+        renderer.setNodeManagers(&nodeManagers);
+        renderView.setRenderer(&renderer);
+
         sortTypes.push_back(QSortPolicy::BackToFront);
 
         for (int i = 0; i < 200; ++i) {
@@ -156,28 +165,34 @@ private Q_SLOTS:
             QVERIFY(sortedCommands.at(j - 1).m_depth > sortedCommands.at(j).m_depth);
 
         // RenderCommands are deleted by RenderView dtor
+        renderer.shutdown();
     }
 
     void checkRenderCommandMaterialSorting()
     {
         // GIVEN
+        Qt3DRender::Render::NodeManagers nodeManagers;
+        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
+        renderer.setNodeManagers(&nodeManagers);
+        renderView.setRenderer(&renderer);
+
         sortTypes.push_back(QSortPolicy::Material);
 
-        ProgramDNA dnas[5] = {
-            ProgramDNA(250),
-            ProgramDNA(500),
-            ProgramDNA(1000),
-            ProgramDNA(1500),
-            ProgramDNA(2000),
+        GLShader *dnas[5] = {
+            reinterpret_cast<GLShader *>(0x250),
+            reinterpret_cast<GLShader *>(0x500),
+            reinterpret_cast<GLShader *>(0x1000),
+            reinterpret_cast<GLShader *>(0x1500),
+            reinterpret_cast<GLShader *>(0x2000)
         };
 
         for (int i = 0; i < 20; ++i) {
             RenderCommand c;
-            c.m_shaderDna = dnas[i % 5];
+            c.m_glShader = dnas[i % 5];
             rawCommands.push_back(c);
         }
 
@@ -189,24 +204,25 @@ private Q_SLOTS:
         // THEN
         const QVector<RenderCommand> sortedCommands = renderView.commands();
         QCOMPARE(rawCommands.size(), sortedCommands.size());
-        ProgramDNA targetDNA;
+        GLShader *targetShader;
 
         for (int j = 0; j < sortedCommands.size(); ++j) {
 
             if (j % 4 == 0) {
-                targetDNA = sortedCommands.at(j).m_shaderDna;
+                targetShader = sortedCommands.at(j).m_glShader;
                 if (j > 0)
-                    QVERIFY(targetDNA != sortedCommands.at(j - 1).m_shaderDna);
+                    QVERIFY(targetShader != sortedCommands.at(j - 1).m_glShader);
             }
-            QCOMPARE(targetDNA, sortedCommands.at(j).m_shaderDna);
+            QCOMPARE(targetShader, sortedCommands.at(j).m_glShader);
         }
 
         // RenderCommands are deleted by RenderView dtor
+        renderer.shutdown();
     }
 
     void checkRenderViewUniformMinification_data()
     {
-        QTest::addColumn<QVector<ProgramDNA>>("programDNAs");
+        QTest::addColumn<QVector<QShaderProgram*>>("shaders");
         QTest::addColumn<QVector<ShaderParameterPack>>("rawParameters");
         QTest::addColumn<QVector<ShaderParameterPack>>("expectedMinimizedParameters");
 
@@ -217,36 +233,56 @@ private Q_SLOTS:
         pack1.setUniform(2, UniformValue(1584.0f));
         pack1.setTexture(3, 0, fakeTextureNodeId);
 
+        QShaderProgram *shader1 = new QShaderProgram();
+        QShaderProgram *shader2 = new QShaderProgram();
+
+        shader1->setShaderCode(QShaderProgram::Vertex, QByteArrayLiteral("1"));
+        shader2->setShaderCode(QShaderProgram::Vertex, QByteArrayLiteral("2"));
+
         ShaderParameterPack minifiedPack1;
 
         QTest::newRow("NoMinification")
-                << (QVector<ProgramDNA>() << ProgramDNA(883) << ProgramDNA(1584))
+                << (QVector<QShaderProgram*>() << shader1 << shader2)
                 << (QVector<ShaderParameterPack>() << pack1 << pack1)
                 << (QVector<ShaderParameterPack>() << pack1 << pack1);
 
         QTest::newRow("SingleShaderMinified")
-                << (QVector<ProgramDNA>() << ProgramDNA(883) << ProgramDNA(883) << ProgramDNA(883))
+                << (QVector<QShaderProgram*>() << shader1 << shader1 << shader1)
                 << (QVector<ShaderParameterPack>() << pack1 << pack1 << pack1)
                 << (QVector<ShaderParameterPack>() << pack1 << minifiedPack1 << minifiedPack1);
 
         QTest::newRow("MultipleShadersMinified")
-                << (QVector<ProgramDNA>() << ProgramDNA(883) << ProgramDNA(883) << ProgramDNA(883) << ProgramDNA(1584) << ProgramDNA(1584) << ProgramDNA(1584))
+                << (QVector<QShaderProgram*>() << shader1 << shader1 << shader1 << shader2 << shader2 << shader2)
                 << (QVector<ShaderParameterPack>() << pack1 << pack1 << pack1 << pack1 << pack1 << pack1)
                 << (QVector<ShaderParameterPack>() << pack1 << minifiedPack1 << minifiedPack1 << pack1 << minifiedPack1 << minifiedPack1);
     }
 
     void checkRenderViewUniformMinification()
     {
-        QFETCH(QVector<ProgramDNA>, programDNAs);
+        QFETCH(QVector<QShaderProgram*>, shaders);
         QFETCH(QVector<ShaderParameterPack>, rawParameters);
         QFETCH(QVector<ShaderParameterPack>, expectedMinimizedParameters);
 
+        Qt3DRender::Render::NodeManagers nodeManagers;
+        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
+        renderer.setNodeManagers(&nodeManagers);
+
+        GLShaderManager *shaderManager = renderer.glResourceManagers()->glShaderManager();
+        for (int i = 0, m = shaders.size(); i < m; ++i) {
+            Shader* backend = new Shader();
+            backend->setRenderer(&renderer);
+            simulateInitializationSync(shaders.at(i), backend);
+            shaderManager->createOrAdoptExisting(backend);
+        }
+
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
+        renderView.setRenderer(&renderer);
 
-        for (int i = 0, m = programDNAs.size(); i < m; ++i) {
+        for (int i = 0, m = shaders.size(); i < m; ++i) {
             RenderCommand c;
-            c.m_shaderDna = programDNAs.at(i);
+            c.m_shaderId = shaders.at(i)->id();
+            c.m_glShader = shaderManager->lookupResource(c.m_shaderId);
             c.m_parameterPack = rawParameters.at(i);
             rawCommands.push_back(c);
         }
@@ -260,21 +296,28 @@ private Q_SLOTS:
         const QVector<RenderCommand> sortedCommands = renderView.commands();
         QCOMPARE(rawCommands, sortedCommands);
 
-        for (int i = 0, m = programDNAs.size(); i < m; ++i) {
+        for (int i = 0, m = shaders.size(); i < m; ++i) {
             const RenderCommand c = sortedCommands.at(i);
-            QCOMPARE(c.m_shaderDna, programDNAs.at(i));
+            QCOMPARE(c.m_shaderId, shaders.at(i)->id());
             compareShaderParameterPacks(c.m_parameterPack, expectedMinimizedParameters.at(i));
         }
+
+        renderer.shutdown();
     }
 
 
     void checkRenderCommandFrontToBackSorting()
     {
         // GIVEN
+        Qt3DRender::Render::NodeManagers nodeManagers;
+        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
+        renderer.setNodeManagers(&nodeManagers);
+        renderView.setRenderer(&renderer);
+
         sortTypes.push_back(QSortPolicy::FrontToBack);
 
         for (int i = 0; i < 200; ++i) {
@@ -295,15 +338,21 @@ private Q_SLOTS:
             QVERIFY(sortedCommands.at(j - 1).m_depth < sortedCommands.at(j).m_depth);
 
         // RenderCommands are deleted by RenderView dtor
+        renderer.shutdown();
     }
 
     void checkRenderCommandStateCostSorting()
     {
         // GIVEN
+        Qt3DRender::Render::NodeManagers nodeManagers;
+        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
+        renderer.setNodeManagers(&nodeManagers);
+        renderView.setRenderer(&renderer);
+
         sortTypes.push_back(QSortPolicy::StateChangeCost);
 
         for (int i = 0; i < 200; ++i) {
@@ -324,24 +373,31 @@ private Q_SLOTS:
             QVERIFY(sortedCommands.at(j - 1).m_changeCost > sortedCommands.at(j).m_changeCost);
 
         // RenderCommands are deleted by RenderView dtor
+        renderer.shutdown();
     }
 
     void checkRenderCommandCombinedStateMaterialDepthSorting()
     {
         // GIVEN
+        Qt3DRender::Render::NodeManagers nodeManagers;
+        Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous);
         RenderView renderView;
         QVector<RenderCommand> rawCommands;
         QVector<QSortPolicy::SortType> sortTypes;
 
+        renderer.setNodeManagers(&nodeManagers);
+        renderView.setRenderer(&renderer);
+
         sortTypes.push_back(QSortPolicy::StateChangeCost);
         sortTypes.push_back(QSortPolicy::Material);
         sortTypes.push_back(QSortPolicy::BackToFront);
 
-        ProgramDNA dna[4] = {
-            ProgramDNA(250),
-            ProgramDNA(500),
-            ProgramDNA(1000),
-            ProgramDNA(1500)
+        GLShader *dna[5] = {
+            reinterpret_cast<GLShader *>(0x250),
+            reinterpret_cast<GLShader *>(0x500),
+            reinterpret_cast<GLShader *>(0x1000),
+            reinterpret_cast<GLShader *>(0x1500),
+            reinterpret_cast<GLShader *>(0x2000)
         };
 
         float depth[3] = {
@@ -355,9 +411,9 @@ private Q_SLOTS:
             200
         };
 
-        auto buildRC = [] (ProgramDNA dna, float depth, int changeCost) {
+        auto buildRC = [] (GLShader *dna, float depth, int changeCost) {
             RenderCommand c;
-            c.m_shaderDna = dna;
+            c.m_glShader = dna;
             c.m_depth = depth;
             c.m_changeCost = changeCost;
             return c;
@@ -400,6 +456,7 @@ private Q_SLOTS:
         QCOMPARE(c9, sortedCommands.at(6));
 
         // RenderCommands are deleted by RenderView dtor
+        renderer.shutdown();
     }
 
     void checkRenderCommandTextureSorting()
diff --git a/tests/auto/render/shader/tst_shader.cpp b/tests/auto/render/shader/tst_shader.cpp
index d1578aee7..3f0714907 100644
--- a/tests/auto/render/shader/tst_shader.cpp
+++ b/tests/auto/render/shader/tst_shader.cpp
@@ -79,15 +79,9 @@ void tst_RenderShader::hasCoherentInitialState()
 {
     Qt3DRender::Render::Shader *shader = new Qt3DRender::Render::Shader();
 
-    QCOMPARE(shader->isLoaded(), false);
-    QCOMPARE(shader->dna(), 0U);
-    QVERIFY(shader->uniformsNames().isEmpty());
-    QVERIFY(shader->attributesNames().isEmpty());
-    QVERIFY(shader->uniformBlockNames().isEmpty());
-    QVERIFY(shader->uniforms().isEmpty());
-    QVERIFY(shader->attributes().isEmpty());
-    QVERIFY(shader->uniformBlocks().isEmpty());
     QCOMPARE(shader->status(), Qt3DRender::QShaderProgram::NotReady);
+    QVERIFY(shader->log().isEmpty());
+    QCOMPARE(shader->isDirty(), false);
 }
 
 void tst_RenderShader::matchesFrontendPeer()
@@ -98,8 +92,7 @@ void tst_RenderShader::matchesFrontendPeer()
 
     backend.setRenderer(&renderer);
     simulateInitializationSync(frontend.data(), &backend);
-    QCOMPARE(backend.isLoaded(), false);
-    QVERIFY(backend.dna() != 0U);
+    QCOMPARE(backend.isDirty(), true);
 
     for (int i = Qt3DRender::QShaderProgram::Vertex; i <= Qt3DRender::QShaderProgram::Compute; ++i)
         QCOMPARE(backend.shaderCode()[i],
@@ -117,14 +110,7 @@ void tst_RenderShader::cleanupLeavesACoherentState()
 
     shader.cleanup();
 
-    QCOMPARE(shader.isLoaded(), false);
-    QCOMPARE(shader.dna(), 0U);
-    QVERIFY(shader.uniformsNames().isEmpty());
-    QVERIFY(shader.attributesNames().isEmpty());
-    QVERIFY(shader.uniformBlockNames().isEmpty());
-    QVERIFY(shader.uniforms().isEmpty());
-    QVERIFY(shader.attributes().isEmpty());
-    QVERIFY(shader.uniformBlocks().isEmpty());
+    QCOMPARE(shader.isDirty(), false);
     QCOMPARE(shader.status(), Qt3DRender::QShaderProgram::NotReady);
 }
 
@@ -152,7 +138,7 @@ void tst_RenderShader::dealWithPropertyChanges()
 
     Qt3DRender::Render::Shader backend;
     Qt3DRender::QShaderProgram shader;
-    backend.setLoaded(true);
+
     TestRenderer renderer;
     backend.setRenderer(&renderer);
     simulateInitializationSync(&shader, &backend);
@@ -162,11 +148,13 @@ void tst_RenderShader::dealWithPropertyChanges()
     backend.syncFromFrontEnd(&shader, false);
 
     // THEN
-    QCOMPARE(backend.shaderCode().at(type), QByteArrayLiteral("foo"));
-    QVERIFY(!backend.isLoaded());
+    QCOMPARE(backend.shaderCode().at(type), QStringLiteral("foo"));
     QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty);
+    QCOMPARE(backend.isDirty(), true);
+
     renderer.resetDirty();
-    backend.setLoaded(true);
+    QCOMPARE(renderer.dirtyBits(), 0);
+    backend.unsetDirty();
 
     // WHEN
     shader.setShaderCode(type, QByteArrayLiteral("foo"));
@@ -174,10 +162,8 @@ void tst_RenderShader::dealWithPropertyChanges()
 
     // THEN
     QCOMPARE(backend.shaderCode().at(type), QByteArrayLiteral("foo"));
-    QVERIFY(backend.isLoaded());
     QCOMPARE(renderer.dirtyBits(), 0);
-    renderer.resetDirty();
-    backend.setLoaded(true);
+    QCOMPARE(backend.isDirty(), false);
 
     // WHEN
     shader.setShaderCode(type, QByteArrayLiteral("bar"));
@@ -185,10 +171,9 @@ void tst_RenderShader::dealWithPropertyChanges()
 
     // THEN
     QCOMPARE(backend.shaderCode().at(type), QByteArrayLiteral("bar"));
-    QVERIFY(!backend.isLoaded());
     QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty);
     renderer.resetDirty();
-    backend.setLoaded(true);
+    QCOMPARE(backend.isDirty(), true);
 }
 
 void tst_RenderShader::checkSetRendererDirtyOnInitialization()
@@ -221,7 +206,6 @@ void tst_RenderShader::allowToChangeShaderCode()
     QFETCH(Qt3DRender::QShaderProgram::ShaderType, type);
 
     Qt3DRender::Render::Shader backend;
-    backend.setLoaded(true);
     TestRenderer renderer;
     backend.setRenderer(&renderer);
 
@@ -230,30 +214,24 @@ void tst_RenderShader::allowToChangeShaderCode()
 
     // THEN
     QCOMPARE(backend.shaderCode().at(type), QStringLiteral("foo"));
-    QVERIFY(!backend.isLoaded());
     QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty);
     renderer.resetDirty();
-    backend.setLoaded(true);
 
     // WHEN
     backend.setShaderCode(type, QByteArrayLiteral("foo"));
 
     // THEN
     QCOMPARE(backend.shaderCode().at(type), QStringLiteral("foo"));
-    QVERIFY(backend.isLoaded());
     QCOMPARE(renderer.dirtyBits(), 0);
     renderer.resetDirty();
-    backend.setLoaded(true);
 
     // WHEN
     backend.setShaderCode(type, QByteArrayLiteral("bar"));
 
     // THEN
     QCOMPARE(backend.shaderCode().at(type), QStringLiteral("bar"));
-    QVERIFY(!backend.isLoaded());
     QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty);
     renderer.resetDirty();
-    backend.setLoaded(true);
 }
 
 QTEST_APPLESS_MAIN(tst_RenderShader)
diff --git a/tests/auto/render/shadercache/tst_shadercache.cpp b/tests/auto/render/shadercache/tst_shadercache.cpp
deleted file mode 100644
index 261548d69..000000000
--- a/tests/auto/render/shadercache/tst_shadercache.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** 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 General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** 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-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <QtTest/QTest>
-#include <Qt3DRender/private/shadercache_p.h>
-#include <Qt3DCore/qnodeid.h>
-#include <QtGui/qopenglshaderprogram.h>
-#include <QtCore/qobject.h>
-#include <QtCore/qpointer.h>
-
-QT_BEGIN_NAMESPACE
-
-using namespace Qt3DCore;
-
-namespace Qt3DRender {
-namespace Render {
-
-class tst_ShaderCache : public QObject
-{
-    Q_OBJECT
-
-private Q_SLOTS:
-    void insert();
-    void insertAfterRemoval();
-    void value();
-    void removeRef();
-    void purge();
-    void destruction();
-};
-
-void tst_ShaderCache::insert()
-{
-    // GIVEN
-    ShaderCache cache;
-
-    // THEN
-    QCOMPARE(cache.m_programHash.isEmpty(), true);
-    QCOMPARE(cache.m_programRefs.isEmpty(), true);
-    QCOMPARE(cache.m_pendingRemoval.isEmpty(), true);
-
-    // WHEN
-    auto dna = ProgramDNA(12345);
-    auto nodeId = QNodeId::createId();
-    auto shaderProgram = new QOpenGLShaderProgram;
-    cache.insert(dna, nodeId, shaderProgram);
-
-    // THEN
-    QCOMPARE(cache.m_programHash.size(), 1);
-    QCOMPARE(cache.m_programHash.keys().first(), dna);
-    QCOMPARE(cache.m_programHash.values().first(), shaderProgram);
-
-    QCOMPARE(cache.m_programRefs.size(), 1);
-    QCOMPARE(cache.m_programRefs.keys().first(), dna);
-    QCOMPARE(cache.m_programRefs.values().first().size(), 1);
-    QCOMPARE(cache.m_programRefs.values().first().first(), nodeId);
-
-    QCOMPARE(cache.m_pendingRemoval.isEmpty(), true);
-}
-
-void tst_ShaderCache::insertAfterRemoval()
-{
-    // GIVEN
-    ShaderCache cache;
-    auto dna = ProgramDNA(12345);
-    auto nodeId = QNodeId::createId();
-
-    // WHEN
-    QOpenGLShaderProgram *shaderProgram = new QOpenGLShaderProgram();
-    cache.insert(dna, nodeId, shaderProgram);
-    cache.getShaderProgramAndAddRef(dna, nodeId);
-    cache.removeRef(dna, nodeId);
-    shaderProgram = cache.getShaderProgramAndAddRef(dna, nodeId);
-
-    // THEN
-    QVERIFY(!cache.m_pendingRemoval.contains(dna));
-
-    // WHEN
-    cache.removeRef(dna, nodeId);
-    cache.getShaderProgramAndAddRef(dna, nodeId);
-    cache.purge();
-
-    // THEN
-    QCOMPARE(cache.m_programHash.size(), 1);
-}
-
-void tst_ShaderCache::value()
-{
-    // GIVEN
-    ShaderCache cache;
-
-    // WHEN
-    auto dnaA = ProgramDNA(12345);
-    auto nodeIdA = QNodeId::createId();
-    auto shaderProgramA = new QOpenGLShaderProgram;
-    cache.insert(dnaA, nodeIdA, shaderProgramA);
-    auto cachedProgramA = cache.getShaderProgramAndAddRef(dnaA, nodeIdA);
-
-    // THEN
-    QCOMPARE(shaderProgramA, cachedProgramA);
-
-    // WHEN
-    auto nodeIdA2 = QNodeId::createId();
-    auto cachedProgramA2 = cache.getShaderProgramAndAddRef(dnaA, nodeIdA2);
-
-    // THEN
-    QCOMPARE(shaderProgramA, cachedProgramA2);
-    QCOMPARE(cache.m_programHash.size(), 1);
-    QCOMPARE(cache.m_programHash.keys().first(), dnaA);
-    QCOMPARE(cache.m_programHash.values().first(), shaderProgramA);
-
-    QCOMPARE(cache.m_programRefs.size(), 1);
-    QCOMPARE(cache.m_programRefs.keys().first(), dnaA);
-    const QVector<Qt3DCore::QNodeId> refsA = cache.m_programRefs.values().first();
-    QCOMPARE(refsA.size(), 2);
-    QCOMPARE(refsA.at(0), nodeIdA);
-    QCOMPARE(refsA.at(1), nodeIdA2);
-
-    // WHEN
-    auto dnaB = ProgramDNA(67890);
-    auto nodeIdB = QNodeId::createId();
-    auto shaderProgramB = new QOpenGLShaderProgram;
-    cache.insert(dnaB, nodeIdB, shaderProgramB);
-
-    // THEN
-    QCOMPARE(cache.m_programHash.size(), 2);
-    QCOMPARE(cache.m_programRefs.size(), 2);
-
-    // WHEN
-    auto cachedProgramB = cache.getShaderProgramAndAddRef(dnaB, nodeIdB);
-    QCOMPARE(shaderProgramB, cachedProgramB);
-
-    // WHEN
-    auto dnaC = ProgramDNA(54321);
-    auto uncachedProgram = cache.getShaderProgramAndAddRef(dnaC, nodeIdB);
-    QVERIFY(uncachedProgram == nullptr);
-
-    cache.clear();
-    // Test inserting nullptr.
-    cache.insert(dnaA, nodeIdA, nullptr);
-    bool wasPresent = false;
-    cachedProgramA = cache.getShaderProgramAndAddRef(dnaA, nodeIdA, &wasPresent);
-    QCOMPARE(wasPresent, true);
-    QCOMPARE(cachedProgramA, nullptr);
-    cache.clear();
-    // Test wasPresent==false.
-    cachedProgramB = cache.getShaderProgramAndAddRef(dnaB, nodeIdB, &wasPresent);
-    QCOMPARE(wasPresent, false);
-    QCOMPARE(cachedProgramB, nullptr);
-}
-
-void tst_ShaderCache::removeRef()
-{
-    // GIVEN
-    ShaderCache cache;
-
-    // WHEN we add 2 references and remove one
-    auto dnaA = ProgramDNA(12345);
-    auto nodeIdA = QNodeId::createId();
-    auto shaderProgramA = new QOpenGLShaderProgram;
-    cache.insert(dnaA, nodeIdA, shaderProgramA);
-    auto cachedProgramA = cache.getShaderProgramAndAddRef(dnaA, nodeIdA);
-
-    auto nodeIdA2 = QNodeId::createId();
-    auto cachedProgramA2 = cache.getShaderProgramAndAddRef(dnaA, nodeIdA2);
-
-    cache.removeRef(dnaA, nodeIdA);
-
-    // THEN
-    QCOMPARE(cachedProgramA, shaderProgramA);
-    QCOMPARE(cachedProgramA2, shaderProgramA);
-    QCOMPARE(cache.m_programHash.size(), 1);
-    QCOMPARE(cache.m_programRefs.size(), 1);
-    const auto refs = cache.m_programRefs.value(dnaA);
-    QCOMPARE(refs.size(), 1);
-    QCOMPARE(refs.first(), nodeIdA2);
-    QCOMPARE(cache.m_pendingRemoval.size(), 0);
-
-    // WHEN we remove same ref again
-    cache.removeRef(dnaA, nodeIdA);
-
-    // THEN no change
-    QCOMPARE(cache.m_programHash.size(), 1);
-    QCOMPARE(cache.m_programRefs.size(), 1);
-    const auto refs2 = cache.m_programRefs.value(dnaA);
-    QCOMPARE(refs2.size(), 1);
-    QCOMPARE(refs.first(), nodeIdA2);
-
-    // WHEN we remove other reference
-    cache.removeRef(dnaA, nodeIdA2);
-
-    // THEN
-    QCOMPARE(cache.m_programHash.size(), 1);
-    QCOMPARE(cache.m_programRefs.size(), 1);
-    const auto refs3 = cache.m_programRefs.value(dnaA);
-    QCOMPARE(refs3.size(), 0);
-    QCOMPARE(cache.m_pendingRemoval.size(), 1);
-    QCOMPARE(cache.m_pendingRemoval.first(), dnaA);
-}
-
-void tst_ShaderCache::purge()
-{
-    // GIVEN
-    ShaderCache cache;
-
-    // WHEN we add 2 references and remove one and purge
-    auto dnaA = ProgramDNA(12345);
-    auto nodeIdA = QNodeId::createId();
-    auto shaderProgramA = new QOpenGLShaderProgram;
-    QPointer<QOpenGLShaderProgram> progPointer(shaderProgramA);
-    cache.insert(dnaA, nodeIdA, shaderProgramA);
-    auto cachedProgramA = cache.getShaderProgramAndAddRef(dnaA, nodeIdA);
-
-    auto nodeIdA2 = QNodeId::createId();
-    auto cachedProgramA2 = cache.getShaderProgramAndAddRef(dnaA, nodeIdA2);
-
-    cache.removeRef(dnaA, nodeIdA);
-    cache.purge();
-
-    // THEN no removal
-    QCOMPARE(cachedProgramA, shaderProgramA);
-    QCOMPARE(cachedProgramA2, shaderProgramA);
-    QCOMPARE(cache.m_programHash.size(), 1);
-    QCOMPARE(cache.m_programRefs.size(), 1);
-    QCOMPARE(cache.m_pendingRemoval.isEmpty(), true);
-
-    // WHEN we remove final ref and purge
-    cache.removeRef(dnaA, nodeIdA2);
-    cache.purge();
-
-    // THEN shader program is removed from cache and deleted
-    QCOMPARE(cache.m_programHash.isEmpty(), true);
-    QCOMPARE(cache.m_programRefs.isEmpty(), true);
-    QCOMPARE(progPointer.isNull(), true);
-}
-
-void tst_ShaderCache::destruction()
-{
-    // GIVEN
-    auto cache = new ShaderCache;
-
-    // WHEN
-    auto dnaA = ProgramDNA(12345);
-    auto nodeIdA = QNodeId::createId();
-    auto shaderProgramA = new QOpenGLShaderProgram;
-    QPointer<QOpenGLShaderProgram> progPointerA(shaderProgramA);
-
-    auto dnaB = ProgramDNA(67890);
-    auto nodeIdB = QNodeId::createId();
-    auto shaderProgramB = new QOpenGLShaderProgram;
-    QPointer<QOpenGLShaderProgram> progPointerB(shaderProgramB);
-
-    cache->insert(dnaA, nodeIdA, shaderProgramA);
-    cache->insert(dnaB, nodeIdB, shaderProgramB);
-    delete cache;
-
-    // THEN
-    QCOMPARE(progPointerA.isNull(), true);
-    QCOMPARE(progPointerB.isNull(), true);
-}
-
-} // namespace Render
-} // namespace Qt3DRender
-
-QT_END_NAMESPACE
-
-QTEST_APPLESS_MAIN(Qt3DRender::Render::tst_ShaderCache)
-
-#include "tst_shadercache.moc"