Class QSortMethod renamed to QSortPolicy

Task-number: QTBUG-51471
Change-Id: I41e9c547a86ff0918ceb2f1e4f2eed75ac948662
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

17 files changed, 119 insertions, 120 deletions

diff --git a/examples/qt3d/gltf/main.qml b/examples/qt3d/gltf/main.qml
index ef162c1a4..cab5d765a 100644
--- a/examples/qt3d/gltf/main.qml
+++ b/examples/qt3d/gltf/main.qml
@@ -77,7 +77,7 @@ Entity {
                 camera: camera
                 ClearBuffer {
                     buffers : ClearBuffer.ColorDepthBuffer
-                    SortMethod {
+                    SortPolicy {
                         criteria: [
                             SortCriterion { sort: SortCriterion.BackToFront }
                         ]
diff --git a/examples/qt3d/materials/SortedForwardRenderer.qml b/examples/qt3d/materials/SortedForwardRenderer.qml
index 1c7258fb5..c92104b9c 100644
--- a/examples/qt3d/materials/SortedForwardRenderer.qml
+++ b/examples/qt3d/materials/SortedForwardRenderer.qml
@@ -78,7 +78,7 @@ TechniqueFilter {
                 objectName : "cameraSelector"
                 ClearBuffer {
                     buffers : ClearBuffer.ColorDepthBuffer
-                    SortMethod {
+                    SortPolicy {
                         criteria: [
                             SortCriterion { sort: SortCriterion.StateChangeCost },
                             SortCriterion { sort: SortCriterion.Material }
diff --git a/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp b/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
index 895a5df5d..5e4484842 100644
--- a/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
+++ b/src/quick3d/imports/render/qt3dquick3drenderplugin.cpp
@@ -126,7 +126,7 @@
 #include <Qt3DQuickRender/private/quick3dscene_p.h>
 #include <Qt3DQuickRender/private/quick3dtexture_p.h>
 #include <Qt3DQuickRender/private/quick3drenderpass_p.h>
-#include <Qt3DQuickRender/private/quick3dsortmethod_p.h>
+#include <Qt3DQuickRender/private/quick3dsortpolicy_p.h>
 #include <Qt3DQuickRender/private/quick3dparameter_p.h>
 #include <Qt3DQuickRender/private/quick3dshaderdata_p.h>
 #include <Qt3DQuickRender/private/quick3dshaderdataarray_p.h>
@@ -287,7 +287,7 @@ void Qt3DQuick3DRenderPlugin::registerTypes(const char *uri)
 
     // Sorting
     qmlRegisterType<Qt3DRender::QSortCriterion>(uri, 2, 0, "SortCriterion");
-    Qt3DRender::Quick::registerExtendedType<Qt3DRender::QSortMethod, Qt3DRender::Render::Quick::Quick3DSortMethod>("QSortMethod", "Qt3D.Render/SortMethod", uri, 2, 0, "SortMethod");
+    Qt3DRender::Quick::registerExtendedType<Qt3DRender::QSortPolicy, Qt3DRender::Render::Quick::Quick3DSortPolicy>("QSortPolicy", "Qt3D.Render/SortPolicy", uri, 2, 0, "SortPolicy");
 
     // RenderStates
     qmlRegisterUncreatableType<Qt3DRender::QRenderState>(uri, 2, 0, "RenderState", QStringLiteral("QRenderState is a base class"));
diff --git a/src/quick3d/quick3drender/items/items.pri b/src/quick3d/quick3drender/items/items.pri
index 1de1f800b..e346e561d 100644
--- a/src/quick3d/quick3drender/items/items.pri
+++ b/src/quick3d/quick3drender/items/items.pri
@@ -10,7 +10,7 @@ HEADERS += \
     $$PWD/quick3dscene_p.h \
     $$PWD/quick3dshaderdata_p.h \
     $$PWD/quick3dshaderdataarray_p.h \
-    $$PWD/quick3dsortmethod_p.h \
+    $$PWD/quick3dsortpolicy_p.h \
     $$PWD/quick3dstateset_p.h \
     $$PWD/quick3dtechnique_p.h \
     $$PWD/quick3dtexture_p.h \
@@ -29,7 +29,7 @@ SOURCES += \
     $$PWD/quick3dscene.cpp \
     $$PWD/quick3dtexture.cpp \
     $$PWD/quick3drenderpass.cpp \
-    $$PWD/quick3dsortmethod.cpp \
+    $$PWD/quick3dsortpolicy.cpp \
     $$PWD/quick3dparameter.cpp \
     $$PWD/quick3dshaderdata.cpp \
     $$PWD/quick3dshaderdataarray.cpp \
diff --git a/src/quick3d/quick3drender/items/quick3dsortmethod.cpp b/src/quick3d/quick3drender/items/quick3dsortpolicy.cpp
index 15f87f739..7a342a3ab 100644
--- a/src/quick3d/quick3drender/items/quick3dsortmethod.cpp
+++ b/src/quick3d/quick3drender/items/quick3dsortpolicy.cpp
@@ -37,7 +37,7 @@
 **
 ****************************************************************************/
 
-#include "quick3dsortmethod_p.h"
+#include "quick3dsortpolicy_p.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -45,49 +45,49 @@ namespace Qt3DRender {
 namespace Render {
 namespace Quick {
 
-Quick3DSortMethod::Quick3DSortMethod(QObject *parent)
+Quick3DSortPolicy::Quick3DSortPolicy(QObject *parent)
     : QObject(parent)
 {
 }
 
-QQmlListProperty<QSortCriterion> Quick3DSortMethod::criteriaList()
+QQmlListProperty<QSortCriterion> Quick3DSortPolicy::criteriaList()
 {
     return QQmlListProperty<QSortCriterion>(this, 0,
-                                            &Quick3DSortMethod::appendCriterion,
-                                            &Quick3DSortMethod::criteriaCount,
-                                            &Quick3DSortMethod::criterionAt,
-                                            &Quick3DSortMethod::clearCriteria);
+                                            &Quick3DSortPolicy::appendCriterion,
+                                            &Quick3DSortPolicy::criteriaCount,
+                                            &Quick3DSortPolicy::criterionAt,
+                                            &Quick3DSortPolicy::clearCriteria);
 }
 
-void Quick3DSortMethod::appendCriterion(QQmlListProperty<QSortCriterion> *list, QSortCriterion *criterion)
+void Quick3DSortPolicy::appendCriterion(QQmlListProperty<QSortCriterion> *list, QSortCriterion *criterion)
 {
-    Quick3DSortMethod *sM = qobject_cast<Quick3DSortMethod *>(list->object);
+    Quick3DSortPolicy *sM = qobject_cast<Quick3DSortPolicy *>(list->object);
     if (sM != Q_NULLPTR)
-        sM->parentSortMethod()->addCriterion(criterion);
+        sM->parentSortPolicy()->addCriterion(criterion);
 }
 
-QSortCriterion *Quick3DSortMethod::criterionAt(QQmlListProperty<QSortCriterion> *list, int index)
+QSortCriterion *Quick3DSortPolicy::criterionAt(QQmlListProperty<QSortCriterion> *list, int index)
 {
-    Quick3DSortMethod *sM = qobject_cast<Quick3DSortMethod *>(list->object);
+    Quick3DSortPolicy *sM = qobject_cast<Quick3DSortPolicy *>(list->object);
     if (sM != Q_NULLPTR)
-        return sM->parentSortMethod()->criteria().at(index);
+        return sM->parentSortPolicy()->criteria().at(index);
     return Q_NULLPTR;
 }
 
-int Quick3DSortMethod::criteriaCount(QQmlListProperty<QSortCriterion> *list)
+int Quick3DSortPolicy::criteriaCount(QQmlListProperty<QSortCriterion> *list)
 {
-    Quick3DSortMethod *sM = qobject_cast<Quick3DSortMethod *>(list->object);
+    Quick3DSortPolicy *sM = qobject_cast<Quick3DSortPolicy *>(list->object);
     if (sM != Q_NULLPTR)
-        return sM->parentSortMethod()->criteria().count();
+        return sM->parentSortPolicy()->criteria().count();
     return -1;
 }
 
-void Quick3DSortMethod::clearCriteria(QQmlListProperty<QSortCriterion> *list)
+void Quick3DSortPolicy::clearCriteria(QQmlListProperty<QSortCriterion> *list)
 {
-    Quick3DSortMethod *sM = qobject_cast<Quick3DSortMethod *>(list->object);
+    Quick3DSortPolicy *sM = qobject_cast<Quick3DSortPolicy *>(list->object);
     if (sM != Q_NULLPTR) {
-        Q_FOREACH (QSortCriterion *c, sM->parentSortMethod()->criteria())
-            sM->parentSortMethod()->removeCriterion(c);
+        Q_FOREACH (QSortCriterion *c, sM->parentSortPolicy()->criteria())
+            sM->parentSortPolicy()->removeCriterion(c);
     }
 }
 
diff --git a/src/quick3d/quick3drender/items/quick3dsortmethod_p.h b/src/quick3d/quick3drender/items/quick3dsortpolicy_p.h
index 782f3fa59..775102b9d 100644
--- a/src/quick3d/quick3drender/items/quick3dsortmethod_p.h
+++ b/src/quick3d/quick3drender/items/quick3dsortpolicy_p.h
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#ifndef QT3DRENDER_RENDER_QUICK_QUICK3DSORTMETHOD_P_H
-#define QT3DRENDER_RENDER_QUICK_QUICK3DSORTMETHOD_P_H
+#ifndef QT3DRENDER_RENDER_QUICK_QUICK3DSORTPOLICY_P_H
+#define QT3DRENDER_RENDER_QUICK_QUICK3DSORTPOLICY_P_H
 
 //
 //  W A R N I N G
@@ -52,7 +52,7 @@
 //
 
 #include <Qt3DQuickRender/private/qt3dquickrender_global_p.h>
-#include <Qt3DRender/qsortmethod.h>
+#include <Qt3DRender/qsortpolicy.h>
 #include <Qt3DRender/qsortcriterion.h>
 #include <QQmlListProperty>
 
@@ -62,14 +62,14 @@ namespace Qt3DRender {
 namespace Render {
 namespace Quick {
 
-class QT3DQUICKRENDERSHARED_PRIVATE_EXPORT Quick3DSortMethod : public QObject
+class QT3DQUICKRENDERSHARED_PRIVATE_EXPORT Quick3DSortPolicy : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QQmlListProperty<Qt3DRender::QSortCriterion> criteria READ criteriaList)
 public:
-    explicit Quick3DSortMethod(QObject *parent = 0);
+    explicit Quick3DSortPolicy(QObject *parent = 0);
 
-    inline QSortMethod *parentSortMethod() const { return qobject_cast<QSortMethod *>(parent()); }
+    inline QSortPolicy *parentSortPolicy() const { return qobject_cast<QSortPolicy *>(parent()); }
 
     QQmlListProperty<QSortCriterion> criteriaList();
 
@@ -86,4 +86,4 @@ private:
 
 QT_END_NAMESPACE
 
-#endif // QT3DRENDER_RENDER_QUICK_QUICK3DSORTMETHOD_P_H
+#endif // QT3DRENDER_RENDER_QUICK_QUICK3DSORTPOLICY_P_H
diff --git a/src/render/framegraph/framegraph.pri b/src/render/framegraph/framegraph.pri
index 1dc749bee..490c7ff3e 100644
--- a/src/render/framegraph/framegraph.pri
+++ b/src/render/framegraph/framegraph.pri
@@ -27,8 +27,8 @@ HEADERS += \
     $$PWD/qrendertargetselector_p.h \
     $$PWD/qsortcriterion.h \
     $$PWD/qsortcriterion_p.h \
-    $$PWD/qsortmethod.h \
-    $$PWD/qsortmethod_p.h \
+    $$PWD/qsortpolicy.h \
+    $$PWD/qsortpolicy_p.h \
     $$PWD/qrenderstateset.h \
     $$PWD/qrenderstateset_p.h \
     $$PWD/qtechniquefilter.h \
@@ -38,7 +38,7 @@ HEADERS += \
     $$PWD/renderpassfilternode_p.h \
     $$PWD/rendertargetselectornode_p.h \
     $$PWD/sortcriterion_p.h \
-    $$PWD/sortmethod_p.h \
+    $$PWD/sortpolicy_p.h \
     $$PWD/statesetnode_p.h \
     $$PWD/techniquefilternode_p.h \
     $$PWD/viewportnode_p.h \
@@ -71,14 +71,14 @@ SOURCES += \
     $$PWD/qrenderpassfilter.cpp \
     $$PWD/qrendertargetselector.cpp \
     $$PWD/qsortcriterion.cpp \
-    $$PWD/qsortmethod.cpp \
+    $$PWD/qsortpolicy.cpp \
     $$PWD/qrenderstateset.cpp \
     $$PWD/qtechniquefilter.cpp \
     $$PWD/qviewport.cpp \
     $$PWD/renderpassfilternode.cpp \
     $$PWD/rendertargetselectornode.cpp \
     $$PWD/sortcriterion.cpp \
-    $$PWD/sortmethod.cpp \
+    $$PWD/sortpolicy.cpp \
     $$PWD/statesetnode.cpp \
     $$PWD/techniquefilternode.cpp \
     $$PWD/viewportnode.cpp \
diff --git a/src/render/framegraph/qsortmethod.cpp b/src/render/framegraph/qsortpolicy.cpp
index 2064db411..5404005a4 100644
--- a/src/render/framegraph/qsortmethod.cpp
+++ b/src/render/framegraph/qsortpolicy.cpp
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#include "qsortmethod.h"
-#include "qsortmethod_p.h"
+#include "qsortpolicy.h"
+#include "qsortpolicy_p.h"
 #include "qsortcriterion_p.h"
 #include <Qt3DCore/qscenepropertychange.h>
 #include <Qt3DRender/qsortcriterion.h>
@@ -49,38 +49,38 @@ using namespace Qt3DCore;
 
 namespace Qt3DRender {
 
-QSortMethodPrivate::QSortMethodPrivate()
+QSortPolicyPrivate::QSortPolicyPrivate()
     : QFrameGraphNodePrivate()
 {
 }
 
-void QSortMethod::copy(const QNode *ref)
+void QSortPolicy::copy(const QNode *ref)
 {
     QFrameGraphNode::copy(ref);
-    const QSortMethod *other = static_cast<const QSortMethod*>(ref);
-    for (QSortCriterion *c : other->d_func()->m_criteria)
+    const QSortPolicy *other = static_cast<const QSortPolicy*>(ref);
+    Q_FOREACH (QSortCriterion *c, other->d_func()->m_criteria)
         addCriterion(qobject_cast<QSortCriterion *>(QNode::clone(c)));
 }
 
-QSortMethod::QSortMethod(QNode *parent)
-    : QFrameGraphNode(*new QSortMethodPrivate, parent)
+QSortPolicy::QSortPolicy(QNode *parent)
+    : QFrameGraphNode(*new QSortPolicyPrivate, parent)
 {
 }
 
-QSortMethod::~QSortMethod()
+QSortPolicy::~QSortPolicy()
 {
     QNode::cleanup();
 }
 
 /*! \internal */
-QSortMethod::QSortMethod(QSortMethodPrivate &dd, QNode *parent)
+QSortPolicy::QSortPolicy(QSortPolicyPrivate &dd, QNode *parent)
     : QFrameGraphNode(dd, parent)
 {
 }
 
-void QSortMethod::addCriterion(QSortCriterion *criterion)
+void QSortPolicy::addCriterion(QSortCriterion *criterion)
 {
-    Q_D(QSortMethod);
+    Q_D(QSortPolicy);
     if (!d->m_criteria.contains(criterion)) {
         d->m_criteria.append(criterion);
 
@@ -96,9 +96,9 @@ void QSortMethod::addCriterion(QSortCriterion *criterion)
     }
 }
 
-void QSortMethod::removeCriterion(QSortCriterion *criterion)
+void QSortPolicy::removeCriterion(QSortCriterion *criterion)
 {
-    Q_D(QSortMethod);
+    Q_D(QSortPolicy);
     if (d->m_changeArbiter != Q_NULLPTR) {
         QScenePropertyChangePtr propertyChange(new QScenePropertyChange(NodeRemoved, QSceneChange::Node, id()));
         propertyChange->setPropertyName("sortCriterion");
@@ -108,9 +108,9 @@ void QSortMethod::removeCriterion(QSortCriterion *criterion)
     d->m_criteria.removeOne(criterion);
 }
 
-QList<QSortCriterion *> QSortMethod::criteria() const
+QList<QSortCriterion *> QSortPolicy::criteria() const
 {
-    Q_D(const QSortMethod);
+    Q_D(const QSortPolicy);
     return d->m_criteria;
 }
 
diff --git a/src/render/framegraph/qsortmethod.h b/src/render/framegraph/qsortpolicy.h
index 22d376e6a..fe1dd40d0 100644
--- a/src/render/framegraph/qsortmethod.h
+++ b/src/render/framegraph/qsortpolicy.h
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#ifndef QT3DRENDER_QSORTMETHOD_H
-#define QT3DRENDER_QSORTMETHOD_H
+#ifndef QT3DRENDER_QSORTPOLICY_H
+#define QT3DRENDER_QSORTPOLICY_H
 
 #include <Qt3DRender/qframegraphnode.h>
 
@@ -47,31 +47,31 @@ QT_BEGIN_NAMESPACE
 namespace Qt3DRender {
 
 class QSortCriterion;
-class QSortMethodPrivate;
+class QSortPolicyPrivate;
 
-class QT3DRENDERSHARED_EXPORT QSortMethod : public QFrameGraphNode
+class QT3DRENDERSHARED_EXPORT QSortPolicy : public QFrameGraphNode
 {
     Q_OBJECT
 
 public:
-    explicit QSortMethod(Qt3DCore::QNode *parent = 0);
-    ~QSortMethod();
+    explicit QSortPolicy(Qt3DCore::QNode *parent = 0);
+    ~QSortPolicy();
 
     void addCriterion(QSortCriterion *criterion);
     void removeCriterion(QSortCriterion *criterion);
     QList<QSortCriterion *> criteria() const;
 
 protected:
-    QSortMethod(QSortMethodPrivate &dd, Qt3DCore::QNode *parent = 0);
+    QSortPolicy(QSortPolicyPrivate &dd, Qt3DCore::QNode *parent = 0);
     void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE;
 
 private:
-    Q_DECLARE_PRIVATE(QSortMethod)
-    QT3D_CLONEABLE(QSortMethod)
+    Q_DECLARE_PRIVATE(QSortPolicy)
+    QT3D_CLONEABLE(QSortPolicy)
 };
 
 } // namespace Qt3DRender
 
 QT_END_NAMESPACE
 
-#endif // QT3DRENDER_QSORTMETHOD_H
+#endif // QT3DRENDER_QSORTPOLICY_H
diff --git a/src/render/framegraph/qsortmethod_p.h b/src/render/framegraph/qsortpolicy_p.h
index 54cedab80..00655e9aa 100644
--- a/src/render/framegraph/qsortmethod_p.h
+++ b/src/render/framegraph/qsortpolicy_p.h
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#ifndef QT3DRENDER_QSORTMETHOD_P_H
-#define QT3DRENDER_QSORTMETHOD_P_H
+#ifndef QT3DRENDER_QSORTPOLICY_P_H
+#define QT3DRENDER_QSORTPOLICY_P_H
 
 //
 //  W A R N I N G
@@ -57,14 +57,14 @@ QT_BEGIN_NAMESPACE
 
 namespace Qt3DRender {
 
-class QSortMethod;
+class QSortPolicy;
 class QSortCriterion;
 
-class QSortMethodPrivate : public QFrameGraphNodePrivate
+class QSortPolicyPrivate : public QFrameGraphNodePrivate
 {
 public:
-    QSortMethodPrivate();
-    Q_DECLARE_PUBLIC(QSortMethod)
+    QSortPolicyPrivate();
+    Q_DECLARE_PUBLIC(QSortPolicy)
     QList<QSortCriterion *> m_criteria;
 };
 
@@ -72,4 +72,4 @@ public:
 
 QT_END_NAMESPACE
 
-#endif // QT3DRENDER_QSORTMETHOD_P_H
+#endif // QT3DRENDER_QSORTPOLICY_P_H
diff --git a/src/render/framegraph/sortmethod.cpp b/src/render/framegraph/sortpolicy.cpp
index 5645b3935..880aa8d9d 100644
--- a/src/render/framegraph/sortmethod.cpp
+++ b/src/render/framegraph/sortpolicy.cpp
@@ -37,7 +37,7 @@
 **
 ****************************************************************************/
 
-#include "sortmethod_p.h"
+#include "sortpolicy_p.h"
 #include <Qt3DRender/qsortcriterion.h>
 #include <Qt3DCore/qscenepropertychange.h>
 
@@ -48,22 +48,21 @@ using namespace Qt3DCore;
 namespace Qt3DRender {
 namespace Render {
 
-SortMethod::SortMethod()
+SortPolicy::SortPolicy()
     : FrameGraphNode(FrameGraphNode::SortMethod)
 {
 }
 
-void SortMethod::updateFromPeer(Qt3DCore::QNode *peer)
+void SortPolicy::updateFromPeer(Qt3DCore::QNode *peer)
 {
-    QSortMethod *sortMethod = static_cast<QSortMethod *>(peer);
+    QSortPolicy *sortPolicy = static_cast<QSortPolicy *>(peer);
     m_criteria.clear();
-    const auto criteria = sortMethod->criteria();
-    for (QSortCriterion *c : criteria)
+    Q_FOREACH (QSortCriterion *c, sortPolicy->criteria())
         m_criteria.append(c->id());
-    setEnabled(sortMethod->isEnabled());
+    setEnabled(sortPolicy->isEnabled());
 }
 
-void SortMethod::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
+void SortPolicy::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
 {
     QScenePropertyChangePtr propertyChange = qSharedPointerCast<QScenePropertyChange>(e);
     if (propertyChange->propertyName() == QByteArrayLiteral("sortCriterion")) {
@@ -80,7 +79,7 @@ void SortMethod::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     markDirty(AbstractRenderer::AllDirty);
 }
 
-QVector<QNodeId> SortMethod::criteria() const
+QVector<QNodeId> SortPolicy::criteria() const
 {
     return m_criteria;
 }
diff --git a/src/render/framegraph/sortmethod_p.h b/src/render/framegraph/sortpolicy_p.h
index 44d59f1d7..a88ba28e6 100644
--- a/src/render/framegraph/sortmethod_p.h
+++ b/src/render/framegraph/sortpolicy_p.h
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#ifndef QT3DRENDER_RENDER_SORTMETHOD_P_H
-#define QT3DRENDER_RENDER_SORTMETHOD_P_H
+#ifndef QT3DRENDER_RENDER_SORTPOLICY_P_H
+#define QT3DRENDER_RENDER_SORTPOLICY_P_H
 
 //
 //  W A R N I N G
@@ -52,7 +52,7 @@
 //
 
 #include <Qt3DRender/private/framegraphnode_p.h>
-#include <Qt3DRender/qsortmethod.h>
+#include <Qt3DRender/qsortpolicy.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -60,10 +60,10 @@ namespace Qt3DRender {
 
 namespace Render {
 
-class SortMethod : public FrameGraphNode
+class SortPolicy : public FrameGraphNode
 {
 public:
-    SortMethod();
+    SortPolicy();
 
     void updateFromPeer(Qt3DCore::QNode *peer) Q_DECL_OVERRIDE;
     void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) Q_DECL_OVERRIDE;
@@ -80,4 +80,4 @@ private:
 
 QT_END_NAMESPACE
 
-#endif // QT3DRENDER_RENDER_SORTMETHOD_P_H
+#endif // QT3DRENDER_RENDER_SORTPOLICY_P_H
diff --git a/src/render/frontend/qrenderaspect.cpp b/src/render/frontend/qrenderaspect.cpp
index c5685cf9f..0593c57a1 100644
--- a/src/render/frontend/qrenderaspect.cpp
+++ b/src/render/frontend/qrenderaspect.cpp
@@ -93,7 +93,7 @@
 #include <Qt3DRender/private/rendertarget_p.h>
 #include <Qt3DRender/private/scenemanager_p.h>
 #include <Qt3DRender/private/clearbuffer_p.h>
-#include <Qt3DRender/private/sortmethod_p.h>
+#include <Qt3DRender/private/sortpolicy_p.h>
 #include <Qt3DRender/private/sortcriterion_p.h>
 #include <Qt3DRender/private/framegraphsubtreeselector_p.h>
 #include <Qt3DRender/private/renderlogging_p.h>
@@ -270,7 +270,7 @@ void QRenderAspect::registerBackendTypes()
     registerBackendType<QRenderTargetSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::RenderTargetSelector, QRenderTargetSelector>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
     registerBackendType<QRenderSurfaceSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::RenderSurfaceSelector, QRenderSurfaceSelector>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
     registerBackendType<QLayerFilter>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::LayerFilterNode, QLayerFilter>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
-    registerBackendType<QSortMethod>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::SortMethod, QSortMethod>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
+    registerBackendType<QSortPolicy>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::SortPolicy, QSortPolicy>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
     registerBackendType<QFrameGraphSelector>(QBackendNodeMapperPtr(new Render::FrameGraphNodeFunctor<Render::FrameGraphSubtreeSelector, QFrameGraphSelector>(d->m_renderer, d->m_nodeManagers->frameGraphManager())));
     registerBackendType<QFrameGraph>(QBackendNodeMapperPtr(new Render::FrameGraphComponentFunctor(d->m_renderer)));
     registerBackendType<QParameter>(QBackendNodeMapperPtr(new Render::NodeFunctor<Render::Parameter, Render::ParameterManager>(d->m_renderer, d->m_nodeManagers->parameterManager())));
diff --git a/src/render/jobs/renderviewjobutils.cpp b/src/render/jobs/renderviewjobutils.cpp
index e77a5cf37..982fa67b0 100644
--- a/src/render/jobs/renderviewjobutils.cpp
+++ b/src/render/jobs/renderviewjobutils.cpp
@@ -53,7 +53,7 @@
 #include <Qt3DRender/private/renderstateset_p.h>
 #include <Qt3DRender/private/rendertargetselectornode_p.h>
 #include <Qt3DRender/private/renderview_p.h>
-#include <Qt3DRender/private/sortmethod_p.h>
+#include <Qt3DRender/private/sortpolicy_p.h>
 #include <Qt3DRender/private/techniquefilternode_p.h>
 #include <Qt3DRender/private/viewportnode_p.h>
 #include <Qt3DRender/private/shadervariables_p.h>
@@ -177,8 +177,8 @@ void setRenderViewConfigFromFrameGraphLeafNode(RenderView *rv, const FrameGraphN
             }
 
             case FrameGraphNode::SortMethod: {
-                const Render::SortMethod *sortMethod = static_cast<const Render::SortMethod *>(node);
-                rv->addSortCriteria(sortMethod->criteria());
+                const Render::SortPolicy *sortPolicy = static_cast<const Render::SortPolicy *>(node);
+                rv->addSortCriteria(sortPolicy->criteria());
                 break;
             }
 
diff --git a/tests/auto/render/qsortmethod/qsortmethod.pro b/tests/auto/render/qsortpolicy/qsortpolicy.pro
index ca9537aa6..1f955d2f0 100644
--- a/tests/auto/render/qsortmethod/qsortmethod.pro
+++ b/tests/auto/render/qsortpolicy/qsortpolicy.pro
@@ -5,6 +5,6 @@ QT += core-private 3dcore 3dcore-private 3drender 3drender-private testlib
 
 CONFIG += testcase
 
-SOURCES += tst_qsortmethod.cpp
+SOURCES += tst_qsortpolicy.cpp
 
 include(../commons/commons.pri)
diff --git a/tests/auto/render/qsortmethod/tst_qsortmethod.cpp b/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp
index 840f06235..f91eb325f 100644
--- a/tests/auto/render/qsortmethod/tst_qsortmethod.cpp
+++ b/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp
@@ -31,18 +31,18 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qentity.h>
 
-#include <Qt3DRender/qsortmethod.h>
+#include <Qt3DRender/qsortpolicy.h>
 #include <Qt3DRender/qsortcriterion.h>
 
 #include "testpostmanarbiter.h"
 
 // We need to call QNode::clone which is protected
 // So we sublcass QNode instead of QObject
-class tst_QSortMethod: public Qt3DCore::QNode
+class tst_QSortPolicy: public Qt3DCore::QNode
 {
     Q_OBJECT
 public:
-    ~tst_QSortMethod()
+    ~tst_QSortPolicy()
     {
         QNode::cleanup();
     }
@@ -51,47 +51,47 @@ private Q_SLOTS:
 
     void checkSaneDefaults()
     {
-        QScopedPointer<Qt3DRender::QSortMethod> defaultsortMethod(new Qt3DRender::QSortMethod);
+        QScopedPointer<Qt3DRender::QSortPolicy> defaultsortPolicy(new Qt3DRender::QSortPolicy);
 
-        QVERIFY(defaultsortMethod->criteria().isEmpty());
+        QVERIFY(defaultsortPolicy->criteria().isEmpty());
     }
 
     void checkCloning_data()
     {
-        QTest::addColumn<Qt3DRender::QSortMethod *>("sortMethod");
+        QTest::addColumn<Qt3DRender::QSortPolicy *>("sortPolicy");
         QTest::addColumn<QList<Qt3DRender::QSortCriterion *> >("criteria");
 
-        Qt3DRender::QSortMethod *defaultConstructed = new Qt3DRender::QSortMethod();
+        Qt3DRender::QSortPolicy *defaultConstructed = new Qt3DRender::QSortPolicy();
         QTest::newRow("defaultConstructed") << defaultConstructed << QList<Qt3DRender::QSortCriterion *>();
 
-        Qt3DRender::QSortMethod *sortMethodWithCriteria = new Qt3DRender::QSortMethod();
+        Qt3DRender::QSortPolicy *sortPolicyWithCriteria = new Qt3DRender::QSortPolicy();
         Qt3DRender::QSortCriterion *criterion1 = new Qt3DRender::QSortCriterion();
         Qt3DRender::QSortCriterion *criterion2 = new Qt3DRender::QSortCriterion();
         criterion1->setSort(Qt3DRender::QSortCriterion::BackToFront);
         criterion2->setSort(Qt3DRender::QSortCriterion::Material);
         QList<Qt3DRender::QSortCriterion *> criteria = QList<Qt3DRender::QSortCriterion *>() << criterion1 << criterion2;
-        sortMethodWithCriteria->addCriterion(criterion1);
-        sortMethodWithCriteria->addCriterion(criterion2);
-        QTest::newRow("sortMethodWithCriteria") << sortMethodWithCriteria << criteria;
+        sortPolicyWithCriteria->addCriterion(criterion1);
+        sortPolicyWithCriteria->addCriterion(criterion2);
+        QTest::newRow("sortPolicyWithCriteria") << sortPolicyWithCriteria << criteria;
     }
 
     void checkCloning()
     {
         // GIVEN
-        QFETCH(Qt3DRender::QSortMethod*, sortMethod);
+        QFETCH(Qt3DRender::QSortPolicy*, sortPolicy);
         QFETCH(QList<Qt3DRender::QSortCriterion *>, criteria);
 
         // THEN
-        QCOMPARE(sortMethod->criteria(), criteria);
+        QCOMPARE(sortPolicy->criteria(), criteria);
 
         // WHEN
-        Qt3DRender::QSortMethod *clone = static_cast<Qt3DRender::QSortMethod *>(QNode::clone(sortMethod));
+        Qt3DRender::QSortPolicy *clone = static_cast<Qt3DRender::QSortPolicy *>(QNode::clone(sortPolicy));
 
         // THEN
         QVERIFY(clone != Q_NULLPTR);
-        QCOMPARE(sortMethod->id(), clone->id());
+        QCOMPARE(sortPolicy->id(), clone->id());
 
-        QCOMPARE(sortMethod->criteria().count(), clone->criteria().count());
+        QCOMPARE(sortPolicy->criteria().count(), clone->criteria().count());
 
         for (int i = 0, m = criteria.count(); i < m; ++i) {
             Qt3DRender::QSortCriterion *cClone = clone->criteria().at(i);
@@ -99,50 +99,50 @@ private Q_SLOTS:
             QCOMPARE(cOrig->id(),cClone->id());
             QCOMPARE(cOrig->sort(), cClone->sort());
             QVERIFY(cClone->parent() == clone);
-            QVERIFY(cOrig->parent() == sortMethod);
+            QVERIFY(cOrig->parent() == sortPolicy);
         }
 
-        delete sortMethod;
+        delete sortPolicy;
         delete clone;
     }
 
     void checkPropertyUpdates()
     {
         // GIVEN
-        QScopedPointer<Qt3DRender::QSortMethod> sortMethod(new Qt3DRender::QSortMethod());
-        TestArbiter arbiter(sortMethod.data());
+        QScopedPointer<Qt3DRender::QSortPolicy> sortPolicy(new Qt3DRender::QSortPolicy());
+        TestArbiter arbiter(sortPolicy.data());
 
         // WHEN
         Qt3DRender::QSortCriterion *criterion1 = new Qt3DRender::QSortCriterion();
-        sortMethod->addCriterion(criterion1);
+        sortPolicy->addCriterion(criterion1);
         QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
         Qt3DCore::QScenePropertyChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QScenePropertyChange>();
         QCOMPARE(change->propertyName(), "sortCriterion");
-        QCOMPARE(change->subjectId(),sortMethod->id());
+        QCOMPARE(change->subjectId(),sortPolicy->id());
         QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), criterion1->id());
         QCOMPARE(change->type(), Qt3DCore::NodeAdded);
 
         arbiter.events.clear();
 
         // WHEN
-        sortMethod->addCriterion(criterion1);
+        sortPolicy->addCriterion(criterion1);
         QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
 
         // WHEN
-        sortMethod->removeCriterion(criterion1);
+        sortPolicy->removeCriterion(criterion1);
         QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
         change = arbiter.events.first().staticCast<Qt3DCore::QScenePropertyChange>();
         QCOMPARE(change->propertyName(), "sortCriterion");
-        QCOMPARE(change->subjectId(), sortMethod->id());
+        QCOMPARE(change->subjectId(), sortPolicy->id());
         QCOMPARE(change->value().value<Qt3DCore::QNodeId>(), criterion1->id());
         QCOMPARE(change->type(), Qt3DCore::NodeRemoved);
 
@@ -157,6 +157,6 @@ protected:
 
 };
 
-QTEST_MAIN(tst_QSortMethod)
+QTEST_MAIN(tst_QSortPolicy)
 
-#include "tst_qsortmethod.moc"
+#include "tst_qsortpolicy.moc"
diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro
index 9df90bde5..0f4ba3035 100644
--- a/tests/auto/render/render.pro
+++ b/tests/auto/render/render.pro
@@ -32,7 +32,7 @@ contains(QT_CONFIG, private_tests) {
         qrenderpassfilter \
         qrendertargetselector \
         qsortcriterion \
-        qsortmethod \
+        qsortpolicy \
         qrenderstateset \
         qtechniquefilter \
         qviewport \