Cleanup: move CPU item implementation into cpp file

This will make it easier to split the RHI implementation out
into separate files.

Change-Id: I4173b46871ba1e84310f9f6bebaae7754879b70b
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>
(cherry picked from commit f92b88e99f2802f85af10e6e19c9c5e6800ee75c)
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

8 files changed, 403 insertions, 363 deletions

diff --git a/src/location/quickmapitems/qdeclarativecirclemapitem.cpp b/src/location/quickmapitems/qdeclarativecirclemapitem.cpp
index ed1b5e5d..8f0ba330 100644
--- a/src/location/quickmapitems/qdeclarativecirclemapitem.cpp
+++ b/src/location/quickmapitems/qdeclarativecirclemapitem.cpp
@@ -712,4 +712,121 @@ void QDeclarativeCircleMapItemPrivate::calculatePeripheralPoints(QList<QGeoCoord
 
 //////////////////////////////////////////////////////////////////////
 
+void QDeclarativeCircleMapItemPrivateCPU::updatePolish()
+{
+    if (!m_circle.m_circle.isValid()) {
+        m_geometry.clear();
+        m_borderGeometry.clear();
+        m_circle.setWidth(0);
+        m_circle.setHeight(0);
+        return;
+    }
+
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_circle.map()->geoProjection());
+    QScopedValueRollback<bool> rollback(m_circle.m_updatingGeometry);
+    m_circle.m_updatingGeometry = true;
+
+    QList<QDoubleVector2D> circlePath = m_circlePath;
+
+    int pathCount = circlePath.size();
+    bool preserve = preserveCircleGeometry(circlePath, m_circle.m_circle.center(),
+                                           m_circle.m_circle.radius(), p);
+    // using leftBound_ instead of the analytically calculated
+    // circle_.boundingGeoRectangle().topLeft());
+    // to fix QTBUG-62154
+    m_geometry.setPreserveGeometry(true, m_leftBound); // to set the geoLeftBound_
+    m_geometry.setPreserveGeometry(preserve, m_leftBound);
+
+    bool invertedCircle = false;
+    if (crossEarthPole(m_circle.m_circle.center(), m_circle.m_circle.radius())
+        && circlePath.size() == pathCount) {
+        // invert fill area for really huge circles
+        m_geometry.updateScreenPointsInvert(circlePath, *m_circle.map());
+        invertedCircle = true;
+    } else {
+        m_geometry.updateSourcePoints(*m_circle.map(), circlePath);
+        m_geometry.updateScreenPoints(*m_circle.map(), m_circle.m_border.width());
+    }
+
+    m_borderGeometry.clear();
+    QList<QGeoMapItemGeometry *> geoms;
+    geoms << &m_geometry;
+
+    if (m_circle.m_border.color() != Qt::transparent && m_circle.m_border.width() > 0) {
+        QList<QDoubleVector2D> closedPath = circlePath;
+        closedPath << closedPath.first();
+
+        if (invertedCircle) {
+            closedPath = m_circlePath;
+            closedPath << closedPath.first();
+            std::reverse(closedPath.begin(), closedPath.end());
+        }
+
+        m_borderGeometry.setPreserveGeometry(true, m_leftBound);
+        m_borderGeometry.setPreserveGeometry(preserve, m_leftBound);
+
+        // Use srcOrigin_ from fill geometry after clipping to ensure that
+        // translateToCommonOrigin won't fail.
+        const QGeoCoordinate &geometryOrigin = m_geometry.origin();
+
+        m_borderGeometry.srcPoints_.clear();
+        m_borderGeometry.srcPointTypes_.clear();
+
+        QDoubleVector2D borderLeftBoundWrapped;
+        QList<QList<QDoubleVector2D >> clippedPaths = m_borderGeometry.clipPath(*m_circle.map(),
+                                                        closedPath, borderLeftBoundWrapped);
+        if (clippedPaths.size()) {
+            borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
+            m_borderGeometry.pathToScreen(*m_circle.map(), clippedPaths, borderLeftBoundWrapped);
+            m_borderGeometry.updateScreenPoints(*m_circle.map(), m_circle.m_border.width());
+            geoms << &m_borderGeometry;
+        } else {
+            m_borderGeometry.clear();
+        }
+    }
+
+    QRectF combined = QGeoMapItemGeometry::translateToCommonOrigin(geoms);
+
+    if (invertedCircle || !preserve) {
+        m_circle.setWidth(combined.width());
+        m_circle.setHeight(combined.height());
+    } else {
+        m_circle.setWidth(combined.width() + 2 * m_circle.m_border.width()); // ToDo: Fix this!
+        m_circle.setHeight(combined.height() + 2 * m_circle.m_border.width());
+    }
+
+    // No offsetting here, even in normal case, because first point offset is already translated
+    m_circle.setPositionOnMap(m_geometry.origin(), m_geometry.firstPointOffset());
+}
+
+QSGNode *QDeclarativeCircleMapItemPrivateCPU::updateMapItemPaintNode(QSGNode *oldNode,
+                                                            QQuickItem::UpdatePaintNodeData *data)
+{
+    Q_UNUSED(data);
+    if (!m_node || !oldNode) { // Apparently the QSG might delete the nodes if they become invisible
+        m_node = new MapPolygonNode();
+        if (oldNode) {
+            delete oldNode;
+            oldNode = nullptr;
+        }
+    } else {
+        m_node = static_cast<MapPolygonNode *>(oldNode);
+    }
+
+    //TODO: update only material
+    if (m_geometry.isScreenDirty() || m_borderGeometry.isScreenDirty() || m_circle.m_dirtyMaterial) {
+        m_node->update(m_circle.m_color, m_circle.m_border.color(), &m_geometry, &m_borderGeometry);
+        m_geometry.setPreserveGeometry(false);
+        m_borderGeometry.setPreserveGeometry(false);
+        m_geometry.markClean();
+        m_borderGeometry.markClean();
+        m_circle.m_dirtyMaterial = false;
+    }
+    return m_node;
+}
+bool QDeclarativeCircleMapItemPrivateCPU::contains(const QPointF &point) const
+{
+    return (m_geometry.contains(point) || m_borderGeometry.contains(point));
+}
+
 QT_END_NAMESPACE
diff --git a/src/location/quickmapitems/qdeclarativecirclemapitem_p_p.h b/src/location/quickmapitems/qdeclarativecirclemapitem_p_p.h
index 2810eb5d..49677e2a 100644
--- a/src/location/quickmapitems/qdeclarativecirclemapitem_p_p.h
+++ b/src/location/quickmapitems/qdeclarativecirclemapitem_p_p.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2020 Paolo Angelelli <paolo.angelelli@gmail.com>
-** Copyright (C) 2020 The Qt Company Ltd.
+** Copyright (C) 2022 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtLocation module of the Qt Toolkit.
@@ -163,115 +163,9 @@ public:
     {
         markSourceDirtyAndUpdate();
     }
-    void updatePolish() override
-    {
-        if (!m_circle.m_circle.isValid()) {
-            m_geometry.clear();
-            m_borderGeometry.clear();
-            m_circle.setWidth(0);
-            m_circle.setHeight(0);
-            return;
-        }
-
-        const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_circle.map()->geoProjection());
-        QScopedValueRollback<bool> rollback(m_circle.m_updatingGeometry);
-        m_circle.m_updatingGeometry = true;
-
-        QList<QDoubleVector2D> circlePath = m_circlePath;
-
-        int pathCount = circlePath.size();
-        bool preserve = preserveCircleGeometry(circlePath, m_circle.m_circle.center(), m_circle.m_circle.radius(), p);
-        // using leftBound_ instead of the analytically calculated circle_.boundingGeoRectangle().topLeft());
-        // to fix QTBUG-62154
-        m_geometry.setPreserveGeometry(true, m_leftBound); // to set the geoLeftBound_
-        m_geometry.setPreserveGeometry(preserve, m_leftBound);
-
-        bool invertedCircle = false;
-        if (crossEarthPole(m_circle.m_circle.center(), m_circle.m_circle.radius()) && circlePath.size() == pathCount) {
-            m_geometry.updateScreenPointsInvert(circlePath, *m_circle.map()); // invert fill area for really huge circles
-            invertedCircle = true;
-        } else {
-            m_geometry.updateSourcePoints(*m_circle.map(), circlePath);
-            m_geometry.updateScreenPoints(*m_circle.map(), m_circle.m_border.width());
-        }
-
-        m_borderGeometry.clear();
-        QList<QGeoMapItemGeometry *> geoms;
-        geoms << &m_geometry;
-
-        if (m_circle.m_border.color() != Qt::transparent && m_circle.m_border.width() > 0) {
-            QList<QDoubleVector2D> closedPath = circlePath;
-            closedPath << closedPath.first();
-
-            if (invertedCircle) {
-                closedPath = m_circlePath;
-                closedPath << closedPath.first();
-                std::reverse(closedPath.begin(), closedPath.end());
-            }
-
-            m_borderGeometry.setPreserveGeometry(true, m_leftBound);
-            m_borderGeometry.setPreserveGeometry(preserve, m_leftBound);
-
-            // Use srcOrigin_ from fill geometry after clipping to ensure that translateToCommonOrigin won't fail.
-            const QGeoCoordinate &geometryOrigin = m_geometry.origin();
-
-            m_borderGeometry.srcPoints_.clear();
-            m_borderGeometry.srcPointTypes_.clear();
-
-            QDoubleVector2D borderLeftBoundWrapped;
-            QList<QList<QDoubleVector2D > > clippedPaths = m_borderGeometry.clipPath(*m_circle.map(), closedPath, borderLeftBoundWrapped);
-            if (clippedPaths.size()) {
-                borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
-                m_borderGeometry.pathToScreen(*m_circle.map(), clippedPaths, borderLeftBoundWrapped);
-                m_borderGeometry.updateScreenPoints(*m_circle.map(), m_circle.m_border.width());
-                geoms << &m_borderGeometry;
-            } else {
-                m_borderGeometry.clear();
-            }
-        }
-
-        QRectF combined = QGeoMapItemGeometry::translateToCommonOrigin(geoms);
-
-        if (invertedCircle || !preserve) {
-            m_circle.setWidth(combined.width());
-            m_circle.setHeight(combined.height());
-        } else {
-            m_circle.setWidth(combined.width() + 2 * m_circle.m_border.width()); // ToDo: Fix this!
-            m_circle.setHeight(combined.height() + 2 * m_circle.m_border.width());
-        }
-
-        // No offsetting here, even in normal case, because first point offset is already translated
-        m_circle.setPositionOnMap(m_geometry.origin(), m_geometry.firstPointOffset());
-    }
-
-    QSGNode * updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *data) override
-    {
-        Q_UNUSED(data);
-        if (!m_node || !oldNode) { // Apparently the QSG might delete the nodes if they become invisible
-            m_node = new MapPolygonNode();
-            if (oldNode) {
-                delete oldNode;
-                oldNode = nullptr;
-            }
-        } else {
-            m_node = static_cast<MapPolygonNode *>(oldNode);
-        }
-
-        //TODO: update only material
-        if (m_geometry.isScreenDirty() || m_borderGeometry.isScreenDirty() || m_circle.m_dirtyMaterial) {
-            m_node->update(m_circle.m_color, m_circle.m_border.color(), &m_geometry, &m_borderGeometry);
-            m_geometry.setPreserveGeometry(false);
-            m_borderGeometry.setPreserveGeometry(false);
-            m_geometry.markClean();
-            m_borderGeometry.markClean();
-            m_circle.m_dirtyMaterial = false;
-        }
-        return m_node;
-    }
-    bool contains(const QPointF &point) const override
-    {
-        return (m_geometry.contains(point) || m_borderGeometry.contains(point));
-    }
+    void updatePolish() override;
+    QSGNode * updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *data) override;
+    bool contains(const QPointF &point) const override;
 
     QGeoMapCircleGeometry m_geometry;
     QGeoMapPolylineGeometry m_borderGeometry;
diff --git a/src/location/quickmapitems/qdeclarativepolygonmapitem.cpp b/src/location/quickmapitems/qdeclarativepolygonmapitem.cpp
index 4e8f701b..af618ae4 100644
--- a/src/location/quickmapitems/qdeclarativepolygonmapitem.cpp
+++ b/src/location/quickmapitems/qdeclarativepolygonmapitem.cpp
@@ -329,6 +329,106 @@ void QGeoMapPolygonGeometry::updateScreenPoints(const QGeoMap &map, qreal stroke
         this->translate(QPointF(strokeWidth, strokeWidth));
 }
 
+/*
+ * QDeclarativePolygonMapItem Private Implementations
+ */
+
+QDeclarativePolygonMapItemPrivate::~QDeclarativePolygonMapItemPrivate() {}
+
+QDeclarativePolygonMapItemPrivateCPU::~QDeclarativePolygonMapItemPrivateCPU() {}
+
+void QDeclarativePolygonMapItemPrivateCPU::updatePolish()
+{
+    if (m_poly.m_geopoly.perimeter().length() == 0) { // Possibly cleared
+        m_geometry.clear();
+        m_borderGeometry.clear();
+        m_poly.setWidth(0);
+        m_poly.setHeight(0);
+        return;
+    }
+    const QGeoMap *map = m_poly.map();
+    const qreal borderWidth = m_poly.m_border.width();
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(map->geoProjection());
+    QScopedValueRollback<bool> rollback(m_poly.m_updatingGeometry);
+    m_poly.m_updatingGeometry = true;
+
+    m_geometry.updateSourcePoints(*map, m_geopathProjected);
+    m_geometry.updateScreenPoints(*map, borderWidth);
+
+    QList<QGeoMapItemGeometry *> geoms;
+    geoms << &m_geometry;
+    m_borderGeometry.clear();
+
+    if (m_poly.m_border.color().alpha() != 0 && borderWidth > 0) {
+        QList<QDoubleVector2D> closedPath = m_geopathProjected;
+        closedPath << closedPath.first();
+
+        m_borderGeometry.setPreserveGeometry(true, m_poly.m_geopoly.boundingGeoRectangle().topLeft());
+
+        const QGeoCoordinate &geometryOrigin = m_geometry.origin();
+
+        m_borderGeometry.srcPoints_.clear();
+        m_borderGeometry.srcPointTypes_.clear();
+
+        QDoubleVector2D borderLeftBoundWrapped;
+        QList<QList<QDoubleVector2D > > clippedPaths = m_borderGeometry.clipPath(*map, closedPath, borderLeftBoundWrapped);
+        if (clippedPaths.size()) {
+            borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
+            m_borderGeometry.pathToScreen(*map, clippedPaths, borderLeftBoundWrapped);
+            m_borderGeometry.updateScreenPoints(*map, borderWidth);
+
+            geoms <<  &m_borderGeometry;
+        } else {
+            m_borderGeometry.clear();
+        }
+    }
+
+    QRectF combined = QGeoMapItemGeometry::translateToCommonOrigin(geoms);
+    m_poly.setWidth(combined.width() + 2 * borderWidth);
+    m_poly.setHeight(combined.height() + 2 * borderWidth);
+
+    m_poly.setPositionOnMap(m_geometry.origin(), -1 * m_geometry.sourceBoundingBox().topLeft()
+                                            + QPointF(borderWidth, borderWidth));
+}
+
+QSGNode *QDeclarativePolygonMapItemPrivateCPU::updateMapItemPaintNode(QSGNode *oldNode,
+                                                            QQuickItem::UpdatePaintNodeData *data)
+{
+    Q_UNUSED(data);
+    if (!m_node || !oldNode) {
+        m_node = new MapPolygonNode();
+        if (oldNode) {
+            delete oldNode;
+            oldNode = nullptr;
+        }
+    } else {
+        m_node = static_cast<MapPolygonNode *>(oldNode);
+    }
+
+    //TODO: update only material
+    if (m_geometry.isScreenDirty()
+            || m_borderGeometry.isScreenDirty()
+            || m_poly.m_dirtyMaterial
+            || !oldNode) {
+        m_node->update(m_poly.m_color,
+                        m_poly.m_border.color(),
+                        &m_geometry,
+                        &m_borderGeometry);
+        m_geometry.setPreserveGeometry(false);
+        m_borderGeometry.setPreserveGeometry(false);
+        m_geometry.markClean();
+        m_borderGeometry.markClean();
+        m_poly.m_dirtyMaterial = false;
+    }
+    return m_node;
+}
+
+bool QDeclarativePolygonMapItemPrivateCPU::contains(const QPointF &point) const
+{
+    return (m_geometry.contains(point) || m_borderGeometry.contains(point));
+}
+
+
 QGeoMapPolygonGeometryOpenGL::QGeoMapPolygonGeometryOpenGL()
 {
 }
@@ -587,13 +687,6 @@ void QGeoMapPolygonGeometryOpenGL::updateQuickGeometry(const QGeoProjectionWebMe
     sourceBounds_.setWidth(brect.width());
     sourceBounds_.setHeight(brect.height());
 }
-/*
- * QDeclarativePolygonMapItem Private Implementations
- */
-
-QDeclarativePolygonMapItemPrivate::~QDeclarativePolygonMapItemPrivate() {}
-
-QDeclarativePolygonMapItemPrivateCPU::~QDeclarativePolygonMapItemPrivateCPU() {}
 
 QDeclarativePolygonMapItemPrivateOpenGL::~QDeclarativePolygonMapItemPrivateOpenGL() {}
 /*
diff --git a/src/location/quickmapitems/qdeclarativepolygonmapitem_p_p.h b/src/location/quickmapitems/qdeclarativepolygonmapitem_p_p.h
index cbea7971..7c5eb9ac 100644
--- a/src/location/quickmapitems/qdeclarativepolygonmapitem_p_p.h
+++ b/src/location/quickmapitems/qdeclarativepolygonmapitem_p_p.h
@@ -52,10 +52,10 @@
 // We mean it.
 //
 
-#include <QList>
+#include <QtCore/QList>
 #include <QtCore/QScopedValueRollback>
 #include <QtGui/QMatrix4x4>
-#include <QColor>
+#include <QtGui/QColor>
 
 #include <QSGGeometryNode>
 #include <QSGFlatColorMaterial>
@@ -342,93 +342,9 @@ public:
     {
         onGeoGeometryChanged();
     }
-    void updatePolish() override
-    {
-        if (m_poly.m_geopoly.perimeter().length() == 0) { // Possibly cleared
-            m_geometry.clear();
-            m_borderGeometry.clear();
-            m_poly.setWidth(0);
-            m_poly.setHeight(0);
-            return;
-        }
-        const QGeoMap *map = m_poly.map();
-        const qreal borderWidth = m_poly.m_border.width();
-        const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(map->geoProjection());
-        QScopedValueRollback<bool> rollback(m_poly.m_updatingGeometry);
-        m_poly.m_updatingGeometry = true;
-
-        m_geometry.updateSourcePoints(*map, m_geopathProjected);
-        m_geometry.updateScreenPoints(*map, borderWidth);
-
-        QList<QGeoMapItemGeometry *> geoms;
-        geoms << &m_geometry;
-        m_borderGeometry.clear();
-
-        if (m_poly.m_border.color().alpha() != 0 && borderWidth > 0) {
-            QList<QDoubleVector2D> closedPath = m_geopathProjected;
-            closedPath << closedPath.first();
-
-            m_borderGeometry.setPreserveGeometry(true, m_poly.m_geopoly.boundingGeoRectangle().topLeft());
-
-            const QGeoCoordinate &geometryOrigin = m_geometry.origin();
-
-            m_borderGeometry.srcPoints_.clear();
-            m_borderGeometry.srcPointTypes_.clear();
-
-            QDoubleVector2D borderLeftBoundWrapped;
-            QList<QList<QDoubleVector2D > > clippedPaths = m_borderGeometry.clipPath(*map, closedPath, borderLeftBoundWrapped);
-            if (clippedPaths.size()) {
-                borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
-                m_borderGeometry.pathToScreen(*map, clippedPaths, borderLeftBoundWrapped);
-                m_borderGeometry.updateScreenPoints(*map, borderWidth);
-
-                geoms <<  &m_borderGeometry;
-            } else {
-                m_borderGeometry.clear();
-            }
-        }
-
-        QRectF combined = QGeoMapItemGeometry::translateToCommonOrigin(geoms);
-        m_poly.setWidth(combined.width() + 2 * borderWidth);
-        m_poly.setHeight(combined.height() + 2 * borderWidth);
-
-        m_poly.setPositionOnMap(m_geometry.origin(), -1 * m_geometry.sourceBoundingBox().topLeft()
-                                                + QPointF(borderWidth, borderWidth));
-    }
-    QSGNode *updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *data) override
-    {
-        Q_UNUSED(data);
-        if (!m_node || !oldNode) {
-            m_node = new MapPolygonNode();
-            if (oldNode) {
-                delete oldNode;
-                oldNode = nullptr;
-            }
-        } else {
-            m_node = static_cast<MapPolygonNode *>(oldNode);
-        }
-
-        //TODO: update only material
-        if (m_geometry.isScreenDirty()
-                || m_borderGeometry.isScreenDirty()
-                || m_poly.m_dirtyMaterial
-                || !oldNode) {
-            m_node->update(m_poly.m_color,
-                         m_poly.m_border.color(),
-                         &m_geometry,
-                         &m_borderGeometry);
-            m_geometry.setPreserveGeometry(false);
-            m_borderGeometry.setPreserveGeometry(false);
-            m_geometry.markClean();
-            m_borderGeometry.markClean();
-            m_poly.m_dirtyMaterial = false;
-        }
-        return m_node;
-    }
-    bool contains(const QPointF &point) const override
-    {
-        return (m_geometry.contains(point) || m_borderGeometry.contains(point));
-    }
+    void updatePolish() override;
+    QSGNode *updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *data) override;
+    bool contains(const QPointF &point) const override;
 
     QList<QDoubleVector2D> m_geopathProjected;
     QGeoMapPolygonGeometry m_geometry;
diff --git a/src/location/quickmapitems/qdeclarativepolylinemapitem.cpp b/src/location/quickmapitems/qdeclarativepolylinemapitem.cpp
index de3a9fd1..3a9af634 100644
--- a/src/location/quickmapitems/qdeclarativepolylinemapitem.cpp
+++ b/src/location/quickmapitems/qdeclarativepolylinemapitem.cpp
@@ -743,6 +743,87 @@ bool QGeoMapPolylineGeometry::contains(const QPointF &point) const
     return false;
 }
 
+/*
+ * QDeclarativePolygonMapItem Private Implementations
+ */
+
+QDeclarativePolylineMapItemPrivate::~QDeclarativePolylineMapItemPrivate() {}
+
+QDeclarativePolylineMapItemPrivateCPU::~QDeclarativePolylineMapItemPrivateCPU() {}
+
+
+void QDeclarativePolylineMapItemPrivateCPU::regenerateCache()
+{
+    if (!m_poly.map() || m_poly.map()->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
+        return;
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_poly.map()->geoProjection());
+    m_geopathProjected.clear();
+    m_geopathProjected.reserve(m_poly.m_geopath.size());
+    for (const QGeoCoordinate &c : m_poly.m_geopath.path())
+        m_geopathProjected << p.geoToMapProjection(c);
+}
+
+void QDeclarativePolylineMapItemPrivateCPU::updateCache()
+{
+    if (!m_poly.map() || m_poly.map()->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
+        return;
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_poly.map()->geoProjection());
+    m_geopathProjected << p.geoToMapProjection(m_poly.m_geopath.path().last());
+}
+
+void QDeclarativePolylineMapItemPrivateCPU::updatePolish()
+{
+    if (m_poly.m_geopath.path().length() < 2) { // Possibly cleared
+        m_geometry.clear();
+        m_poly.setWidth(0);
+        m_poly.setHeight(0);
+        return;
+    }
+    QScopedValueRollback<bool> rollback(m_poly.m_updatingGeometry);
+    m_poly.m_updatingGeometry = true;
+
+    const QGeoMap *map = m_poly.map();
+    const qreal borderWidth = m_poly.m_line.width();
+
+    m_geometry.updateSourcePoints(*map, m_geopathProjected, m_poly.m_geopath.boundingGeoRectangle().topLeft());
+    m_geometry.updateScreenPoints(*map, borderWidth);
+
+    m_poly.setWidth(m_geometry.sourceBoundingBox().width() + borderWidth);
+    m_poly.setHeight(m_geometry.sourceBoundingBox().height() + borderWidth);
+
+    // it has to be shifted so that the center of the line is on the correct geocoord
+    m_poly.setPositionOnMap(m_geometry.origin(), -1 * m_geometry.sourceBoundingBox().topLeft()
+                            + QPointF(borderWidth, borderWidth) * 0.5 );
+}
+
+QSGNode *QDeclarativePolylineMapItemPrivateCPU::updateMapItemPaintNode(QSGNode *oldNode,
+                                                        QQuickItem::UpdatePaintNodeData * /*data*/)
+{
+    if (!m_node || !oldNode) {
+        m_node = new MapPolylineNode();
+        if (oldNode) {
+            delete oldNode;
+            oldNode = nullptr;
+        }
+    } else {
+        m_node = static_cast<MapPolylineNode *>(oldNode);
+    }
+
+    //TODO: update only material
+    if (m_geometry.isScreenDirty() || m_poly.m_dirtyMaterial || !oldNode) {
+        m_node->update(m_poly.m_line.color(), &m_geometry);
+        m_geometry.setPreserveGeometry(false);
+        m_geometry.markClean();
+        m_poly.m_dirtyMaterial = false;
+    }
+    return m_node;
+}
+bool QDeclarativePolylineMapItemPrivateCPU::contains(const QPointF &point) const
+{
+    return m_geometry.contains(point);
+}
+
+
 void QGeoMapPolylineGeometryOpenGL::updateSourcePoints(const QGeoMap &map, const QGeoPolygon &poly)
 {
     if (!sourceDirty_)
@@ -896,13 +977,6 @@ void QGeoMapPolylineGeometryOpenGL::updateQuickGeometry(const QGeoProjectionWebM
     sourceBounds_.setHeight(brect.height() + strokeWidth);
 }
 
-/*
- * QDeclarativePolygonMapItem Private Implementations
- */
-
-QDeclarativePolylineMapItemPrivate::~QDeclarativePolylineMapItemPrivate() {}
-
-QDeclarativePolylineMapItemPrivateCPU::~QDeclarativePolylineMapItemPrivateCPU() {}
 
 QDeclarativePolylineMapItemPrivateOpenGLLineStrip::~QDeclarativePolylineMapItemPrivateOpenGLLineStrip() {}
 
diff --git a/src/location/quickmapitems/qdeclarativepolylinemapitem_p_p.h b/src/location/quickmapitems/qdeclarativepolylinemapitem_p_p.h
index 963f7279..3a446a10 100644
--- a/src/location/quickmapitems/qdeclarativepolylinemapitem_p_p.h
+++ b/src/location/quickmapitems/qdeclarativepolylinemapitem_p_p.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2020 Paolo Angelelli <paolo.angelelli@gmail.com>
-** Copyright (C) 2020 The Qt Company Ltd.
+** Copyright (C) 2022 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtLocation module of the Qt Toolkit.
@@ -529,23 +529,8 @@ public:
         m_geometry.markSourceDirty();
         m_poly.polishAndUpdate();
     }
-    void regenerateCache()
-    {
-        if (!m_poly.map() || m_poly.map()->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
-            return;
-        const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_poly.map()->geoProjection());
-        m_geopathProjected.clear();
-        m_geopathProjected.reserve(m_poly.m_geopath.size());
-        for (const QGeoCoordinate &c : m_poly.m_geopath.path())
-            m_geopathProjected << p.geoToMapProjection(c);
-    }
-    void updateCache()
-    {
-        if (!m_poly.map() || m_poly.map()->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
-            return;
-        const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_poly.map()->geoProjection());
-        m_geopathProjected << p.geoToMapProjection(m_poly.m_geopath.path().last());
-    }
+    void regenerateCache();
+    void updateCache();
     void preserveGeometry()
     {
         m_geometry.setPreserveGeometry(true, m_poly.m_geopath.boundingGeoRectangle().topLeft());
@@ -577,54 +562,9 @@ public:
     {
         onGeoGeometryChanged();
     }
-    void updatePolish() override
-    {
-        if (m_poly.m_geopath.path().length() < 2) { // Possibly cleared
-            m_geometry.clear();
-            m_poly.setWidth(0);
-            m_poly.setHeight(0);
-            return;
-        }
-        QScopedValueRollback<bool> rollback(m_poly.m_updatingGeometry);
-        m_poly.m_updatingGeometry = true;
-
-        const QGeoMap *map = m_poly.map();
-        const qreal borderWidth = m_poly.m_line.width();
-
-        m_geometry.updateSourcePoints(*map, m_geopathProjected, m_poly.m_geopath.boundingGeoRectangle().topLeft());
-        m_geometry.updateScreenPoints(*map, borderWidth);
-
-        m_poly.setWidth(m_geometry.sourceBoundingBox().width() + borderWidth);
-        m_poly.setHeight(m_geometry.sourceBoundingBox().height() + borderWidth);
-
-        m_poly.setPositionOnMap(m_geometry.origin(), -1 * m_geometry.sourceBoundingBox().topLeft()
-                                + QPointF(borderWidth, borderWidth) * 0.5 ); // it has to be shifted so that the center of the line is on the correct geocoord
-    }
-    QSGNode *updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData * /*data*/) override
-    {
-        if (!m_node || !oldNode) {
-            m_node = new MapPolylineNode();
-            if (oldNode) {
-                delete oldNode;
-                oldNode = nullptr;
-            }
-        } else {
-            m_node = static_cast<MapPolylineNode *>(oldNode);
-        }
-
-        //TODO: update only material
-        if (m_geometry.isScreenDirty() || m_poly.m_dirtyMaterial || !oldNode) {
-            m_node->update(m_poly.m_line.color(), &m_geometry);
-            m_geometry.setPreserveGeometry(false);
-            m_geometry.markClean();
-            m_poly.m_dirtyMaterial = false;
-        }
-        return m_node;
-    }
-    bool contains(const QPointF &point) const override
-    {
-        return m_geometry.contains(point);
-    }
+    void updatePolish() override;
+    QSGNode *updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData * /*data*/) override;
+    bool contains(const QPointF &point) const override;
 
     QList<QDoubleVector2D> m_geopathProjected;
     QGeoMapPolylineGeometry m_geometry;
diff --git a/src/location/quickmapitems/qdeclarativerectanglemapitem.cpp b/src/location/quickmapitems/qdeclarativerectanglemapitem.cpp
index a3aa54c4..4c18335b 100644
--- a/src/location/quickmapitems/qdeclarativerectanglemapitem.cpp
+++ b/src/location/quickmapitems/qdeclarativerectanglemapitem.cpp
@@ -405,6 +405,92 @@ QDeclarativeRectangleMapItemPrivate::~QDeclarativeRectangleMapItemPrivate() {}
 
 QDeclarativeRectangleMapItemPrivateCPU::~QDeclarativeRectangleMapItemPrivateCPU() {}
 
+void QDeclarativeRectangleMapItemPrivateCPU::updatePolish()
+{
+    if (!m_rect.topLeft().isValid() || !m_rect.bottomRight().isValid()) {
+        m_geometry.clear();
+        m_borderGeometry.clear();
+        m_rect.setWidth(0);
+        m_rect.setHeight(0);
+        return;
+    }
+
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_rect.map()->geoProjection());
+
+    QScopedValueRollback<bool> rollback(m_rect.m_updatingGeometry);
+    m_rect.m_updatingGeometry = true;
+
+    const QList<QGeoCoordinate> perimeter = path(m_rect.m_rectangle);
+    const QList<QDoubleVector2D> pathMercator_ = pathMercator(perimeter);
+    m_geometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft());
+    m_geometry.updateSourcePoints(*m_rect.map(), pathMercator_);
+    m_geometry.updateScreenPoints(*m_rect.map(), m_rect.m_border.width());
+
+    QList<QGeoMapItemGeometry *> geoms;
+    geoms << &m_geometry;
+    m_borderGeometry.clear();
+
+    if (m_rect.m_border.color().alpha() != 0 && m_rect.m_border.width() > 0) {
+        QList<QDoubleVector2D> closedPath = pathMercator_;
+        closedPath << closedPath.first();
+
+        m_borderGeometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft());
+        const QGeoCoordinate &geometryOrigin = m_geometry.origin();
+
+        m_borderGeometry.srcPoints_.clear();
+        m_borderGeometry.srcPointTypes_.clear();
+
+        QDoubleVector2D borderLeftBoundWrapped;
+        QList<QList<QDoubleVector2D > > clippedPaths = m_borderGeometry.clipPath(*m_rect.map(), closedPath, borderLeftBoundWrapped);
+        if (clippedPaths.size()) {
+            borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
+            m_borderGeometry.pathToScreen(*m_rect.map(), clippedPaths, borderLeftBoundWrapped);
+            m_borderGeometry.updateScreenPoints(*m_rect.map(), m_rect.m_border.width());
+
+            geoms << &m_borderGeometry;
+        } else {
+            m_borderGeometry.clear();
+        }
+    }
+
+    QRectF combined = QGeoMapItemGeometry::translateToCommonOrigin(geoms);
+    m_rect.setWidth(combined.width()  + 2 * m_rect.m_border.width()); // ToDo: fix this! 2 is incorrect
+    m_rect.setHeight(combined.height()  + 2 * m_rect.m_border.width());
+
+    m_rect.setPositionOnMap(m_geometry.origin(), m_geometry.firstPointOffset());
+}
+
+QSGNode *QDeclarativeRectangleMapItemPrivateCPU::updateMapItemPaintNode(QSGNode *oldNode,
+                                                            QQuickItem::UpdatePaintNodeData *data)
+{
+    Q_UNUSED(data);
+    if (!m_node || !oldNode) {
+        m_node = new MapPolygonNode();
+        if (oldNode) {
+            delete oldNode;
+            oldNode = nullptr;
+        }
+    } else {
+        m_node = static_cast<MapPolygonNode *>(oldNode);
+    }
+
+    //TODO: update only material
+    if (m_geometry.isScreenDirty() || m_borderGeometry.isScreenDirty() || m_rect.m_dirtyMaterial) {
+        m_node->update(m_rect.m_color, m_rect.m_border.color(), &m_geometry, &m_borderGeometry);
+        m_geometry.setPreserveGeometry(false);
+        m_borderGeometry.setPreserveGeometry(false);
+        m_geometry.markClean();
+        m_borderGeometry.markClean();
+        m_rect.m_dirtyMaterial = false;
+    }
+    return m_node;
+}
+
+bool QDeclarativeRectangleMapItemPrivateCPU::contains(const QPointF &point) const
+{
+    return (m_geometry.contains(point) || m_borderGeometry.contains(point));
+}
+
 QDeclarativeRectangleMapItemPrivateOpenGL::~QDeclarativeRectangleMapItemPrivateOpenGL() {}
 
 QT_END_NAMESPACE
diff --git a/src/location/quickmapitems/qdeclarativerectanglemapitem_p_p.h b/src/location/quickmapitems/qdeclarativerectanglemapitem_p_p.h
index 09d8b3d2..ff2350e5 100644
--- a/src/location/quickmapitems/qdeclarativerectanglemapitem_p_p.h
+++ b/src/location/quickmapitems/qdeclarativerectanglemapitem_p_p.h
@@ -1,7 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2020 Paolo Angelelli <paolo.angelelli@gmail.com>
-** Copyright (C) 2020 The Qt Company Ltd.
+** Copyright (C) 2022 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtLocation module of the Qt Toolkit.
@@ -129,89 +129,9 @@ public:
         m_borderGeometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft());
         markSourceDirtyAndUpdate();
     }
-    void updatePolish() override
-    {
-        if (!m_rect.topLeft().isValid() || !m_rect.bottomRight().isValid()) {
-            m_geometry.clear();
-            m_borderGeometry.clear();
-            m_rect.setWidth(0);
-            m_rect.setHeight(0);
-            return;
-        }
-
-        const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_rect.map()->geoProjection());
-
-        QScopedValueRollback<bool> rollback(m_rect.m_updatingGeometry);
-        m_rect.m_updatingGeometry = true;
-
-        const QList<QGeoCoordinate> perimeter = path(m_rect.m_rectangle);
-        const QList<QDoubleVector2D> pathMercator_ = pathMercator(perimeter);
-        m_geometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft());
-        m_geometry.updateSourcePoints(*m_rect.map(), pathMercator_);
-        m_geometry.updateScreenPoints(*m_rect.map(), m_rect.m_border.width());
-
-        QList<QGeoMapItemGeometry *> geoms;
-        geoms << &m_geometry;
-        m_borderGeometry.clear();
-
-        if (m_rect.m_border.color().alpha() != 0 && m_rect.m_border.width() > 0) {
-            QList<QDoubleVector2D> closedPath = pathMercator_;
-            closedPath << closedPath.first();
-
-            m_borderGeometry.setPreserveGeometry(true, m_rect.m_rectangle.topLeft());
-            const QGeoCoordinate &geometryOrigin = m_geometry.origin();
-
-            m_borderGeometry.srcPoints_.clear();
-            m_borderGeometry.srcPointTypes_.clear();
-
-            QDoubleVector2D borderLeftBoundWrapped;
-            QList<QList<QDoubleVector2D > > clippedPaths = m_borderGeometry.clipPath(*m_rect.map(), closedPath, borderLeftBoundWrapped);
-            if (clippedPaths.size()) {
-                borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
-                m_borderGeometry.pathToScreen(*m_rect.map(), clippedPaths, borderLeftBoundWrapped);
-                m_borderGeometry.updateScreenPoints(*m_rect.map(), m_rect.m_border.width());
-
-                geoms << &m_borderGeometry;
-            } else {
-                m_borderGeometry.clear();
-            }
-        }
-
-        QRectF combined = QGeoMapItemGeometry::translateToCommonOrigin(geoms);
-        m_rect.setWidth(combined.width()  + 2 * m_rect.m_border.width()); // ToDo: fix this! 2 is incorrect
-        m_rect.setHeight(combined.height()  + 2 * m_rect.m_border.width());
-
-        m_rect.setPositionOnMap(m_geometry.origin(), m_geometry.firstPointOffset());
-    }
-
-    QSGNode * updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *data) override
-    {
-        Q_UNUSED(data);
-        if (!m_node || !oldNode) {
-            m_node = new MapPolygonNode();
-            if (oldNode) {
-                delete oldNode;
-                oldNode = nullptr;
-            }
-        } else {
-            m_node = static_cast<MapPolygonNode *>(oldNode);
-        }
-
-        //TODO: update only material
-        if (m_geometry.isScreenDirty() || m_borderGeometry.isScreenDirty() || m_rect.m_dirtyMaterial) {
-            m_node->update(m_rect.m_color, m_rect.m_border.color(), &m_geometry, &m_borderGeometry);
-            m_geometry.setPreserveGeometry(false);
-            m_borderGeometry.setPreserveGeometry(false);
-            m_geometry.markClean();
-            m_borderGeometry.markClean();
-            m_rect.m_dirtyMaterial = false;
-        }
-        return m_node;
-    }
-    bool contains(const QPointF &point) const override
-    {
-        return (m_geometry.contains(point) || m_borderGeometry.contains(point));
-    }
+    void updatePolish() override;
+    QSGNode * updateMapItemPaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *data) override;
+    bool contains(const QPointF &point) const override;
 
     static QList<QGeoCoordinate> path(const QGeoRectangle &rect)
     {