Merge 5.15 to dev and fix resulting compile issues

 Conflicts:
	src/imports/location/location.cpp

The change fixes the bare minimum of what needs to be done
to compile and run. This includes the following issues:

1.  Fix build failures as a result of QMetaType changes in qtbase

    moc now stores the QMetaType of properties as a result of
    46f407126ef3e94d59254012cdc34d6a4ad2faf2 in qtbase, which requires
    full type information about the property type inside the moc generated
    source file.

    Many of the property types were forward-declared, and this resulted
    in build errors like:

    "invalid application of 'sizeof' to an incomplete type 'QDeclarativeGeoMap'"

2.  Adopts QtQML API changes. A private QJSValue ctor was removed.
    The "replacement" is QJSValuePrivate::fromReturnedValue(..).

3.  The mapboxgl 3rdparty backend does not compile at this point in time
    and seems unmaintained. For the time being, the mapboxgl backend is disabled
    in the interest of keeping qtlocation closer to dev HEAD of other
    Qt modules.

Change-Id: I756e1c2effb29eaaf96a61a28c1c17338774b77c

1 files changed, 218 insertions, 54 deletions

diff --git a/src/location/labs/qsg/qmapcircleobjectqsg.cpp b/src/location/labs/qsg/qmapcircleobjectqsg.cpp
index 32f3030b..750b20f2 100644
--- a/src/location/labs/qsg/qmapcircleobjectqsg.cpp
+++ b/src/location/labs/qsg/qmapcircleobjectqsg.cpp
@@ -41,16 +41,19 @@ QT_BEGIN_NAMESPACE
 static const int CircleSamples = 128;
 
 QMapCircleObjectPrivateQSG::QMapCircleObjectPrivateQSG(QGeoMapObject *q)
-    : QMapCircleObjectPrivateDefault(q)
+    : QMapCircleObjectPrivateDefault(q), m_dataCPU(new CircleDataCPU)
 {
 
 }
 
 QMapCircleObjectPrivateQSG::QMapCircleObjectPrivateQSG(const QMapCircleObjectPrivate &other)
-    : QMapCircleObjectPrivateDefault(other)
+    : QMapCircleObjectPrivateDefault(other), m_dataCPU(new CircleDataCPU)
 {
     // Data already cloned by the *Default copy constructor, but necessary
     // update operations triggered only by setters overrides
+    if (!QDeclarativeCircleMapItemPrivateCPU::crossEarthPole(center(), radius()))
+        switchToGL(); // this marks source dirty
+
     updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
@@ -62,47 +65,54 @@ QMapCircleObjectPrivateQSG::~QMapCircleObjectPrivateQSG()
         m_map->removeMapObject(q);
 }
 
-void QMapCircleObjectPrivateQSG::updateCirclePath()
+void QMapCircleObjectPrivateQSG::updateGeometry()
+{
+    if (!m_dataGL.isNull())
+        updateGeometryGL();
+    else
+        updateGeometryCPU();
+}
+
+void QMapCircleObjectPrivateQSG::CircleDataCPU::updateCirclePath(const QGeoCoordinate &center, qreal radius, const QGeoProjectionWebMercator &p)
 {
-    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
     QList<QGeoCoordinate> path;
-    QDeclarativeCircleMapItem::calculatePeripheralPoints(path, center(), radius(), CircleSamples, m_leftBound);
+    QDeclarativeCircleMapItemPrivateCPU::calculatePeripheralPoints(path, center, radius, CircleSamples, m_leftBound);
     m_circlePath.clear();
     for (const QGeoCoordinate &c : path)
         m_circlePath << p.geoToMapProjection(c);
 }
 
-void QMapCircleObjectPrivateQSG::updateGeometry()
+void QMapCircleObjectPrivateQSG::updateGeometryCPU()
 {
     if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator
             || !qIsFinite(radius()) || !center().isValid())
         return;
 
     const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
-    QScopedValueRollback<bool> rollback(m_updatingGeometry);
-    m_updatingGeometry = true;
+    QScopedValueRollback<bool> rollback(m_dataCPU->m_updatingGeometry);
+    m_dataCPU->m_updatingGeometry = true;
 
-    updateCirclePath();
-    QList<QDoubleVector2D> circlePath = m_circlePath;
+    m_dataCPU->updateCirclePath(center(), radius(), p);
+    QList<QDoubleVector2D> circlePath = m_dataCPU->m_circlePath;
 
     int pathCount = circlePath.size();
-    bool preserve = QDeclarativeCircleMapItem::preserveCircleGeometry(circlePath, center(), radius(), p);
+    bool preserve = QDeclarativeCircleMapItemPrivateCPU::preserveCircleGeometry(circlePath, center(), radius(), p);
     // using leftBound_ instead of the analytically calculated circle_.boundingGeoRectangle().topLeft());
     // to fix QTBUG-62154
-    m_geometry.markSourceDirty();
-    m_geometry.setPreserveGeometry(true, m_leftBound); // to set the geoLeftBound_
-    m_geometry.setPreserveGeometry(preserve, m_leftBound);
+    m_dataCPU->m_geometry.markSourceDirty();
+    m_dataCPU->m_geometry.setPreserveGeometry(true, m_dataCPU->m_leftBound); // to set the geoLeftBound_
+    m_dataCPU->m_geometry.setPreserveGeometry(preserve, m_dataCPU->m_leftBound);
 
     bool invertedCircle = false;
-    if (QDeclarativeCircleMapItem::crossEarthPole(center(), radius()) && circlePath.size() == pathCount) {
-        m_geometry.updateScreenPointsInvert(circlePath, *m_map); // invert fill area for really huge circles
+    if (QDeclarativeCircleMapItemPrivateCPU::crossEarthPole(center(), radius()) && circlePath.size() == pathCount) {
+        m_dataCPU->m_geometry.updateScreenPointsInvert(circlePath, *m_map); // invert fill area for really huge circles
         invertedCircle = true;
     } else {
-        m_geometry.updateSourcePoints(*m_map, circlePath);
-        m_geometry.updateScreenPoints(*m_map);
+        m_dataCPU->m_geometry.updateSourcePoints(*m_map, circlePath);
+        m_dataCPU->m_geometry.updateScreenPoints(*m_map);
     }
 
-    m_borderGeometry.clear();
+    m_dataCPU->m_borderGeometry.clear();
 
     //if (borderColor() != Qt::transparent && borderWidth() > 0)
     {
@@ -110,35 +120,76 @@ void QMapCircleObjectPrivateQSG::updateGeometry()
         closedPath << closedPath.first();
 
         if (invertedCircle) {
-            closedPath = m_circlePath;
+            closedPath = m_dataCPU->m_circlePath;
             closedPath << closedPath.first();
             std::reverse(closedPath.begin(), closedPath.end());
         }
 
-        m_borderGeometry.markSourceDirty();
-        m_borderGeometry.setPreserveGeometry(true, m_leftBound);
-        m_borderGeometry.setPreserveGeometry(preserve, m_leftBound);
+        m_dataCPU->m_borderGeometry.markSourceDirty();
+        m_dataCPU->m_borderGeometry.setPreserveGeometry(true, m_dataCPU->m_leftBound);
+        m_dataCPU->m_borderGeometry.setPreserveGeometry(preserve, m_dataCPU->m_leftBound);
 
         // Use srcOrigin_ from fill geometry after clipping to ensure that translateToCommonOrigin won't fail.
-        const QGeoCoordinate &geometryOrigin = m_geometry.origin();
+        const QGeoCoordinate &geometryOrigin = m_dataCPU->m_geometry.origin();
 
-        m_borderGeometry.clearSource();
+        m_dataCPU->m_borderGeometry.clearSource();
 
         QDoubleVector2D borderLeftBoundWrapped;
         QList<QList<QDoubleVector2D > > clippedPaths =
-                m_borderGeometry.clipPath(*m_map, closedPath, borderLeftBoundWrapped);
+                m_dataCPU->m_borderGeometry.clipPath(*m_map, closedPath, borderLeftBoundWrapped);
         if (clippedPaths.size()) {
             borderLeftBoundWrapped = p.geoToWrappedMapProjection(geometryOrigin);
-            m_borderGeometry.pathToScreen(*m_map, clippedPaths, borderLeftBoundWrapped);
-            m_borderGeometry.updateScreenPoints(*m_map, borderWidth(), false);
+            m_dataCPU->m_borderGeometry.pathToScreen(*m_map, clippedPaths, borderLeftBoundWrapped);
+            m_dataCPU->m_borderGeometry.updateScreenPoints(*m_map, borderWidth(), false);
         } else {
-            m_borderGeometry.clear();
+            m_dataCPU->m_borderGeometry.clear();
         }
     }
 
-    QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_geometry.origin(), false).toPointF();
-    m_geometry.translate(origin - m_geometry.firstPointOffset());
-    m_borderGeometry.translate(origin - m_borderGeometry.firstPointOffset());
+    QPointF origin = m_map->geoProjection().coordinateToItemPosition(m_dataCPU->m_geometry.origin(), false).toPointF();
+    m_dataCPU->m_geometry.translate(origin - m_dataCPU->m_geometry.firstPointOffset());
+    m_dataCPU->m_borderGeometry.translate(origin - m_dataCPU->m_borderGeometry.firstPointOffset());
+}
+
+void QMapCircleObjectPrivateQSG::CircleDataGL::updateCirclePath(const QGeoCoordinate &center, qreal radius, const QGeoProjectionWebMercator &p)
+{
+    m_circlePath.clear();
+    if (radius < 0.001) // 1mm is small enough, probably already way too small.
+        return;
+    QDeclarativeCircleMapItemPrivate::calculatePeripheralPoints(m_circlePath,
+                                                                center,
+                                                                radius,
+                                                                CircleSamples,
+                                                                m_leftBound);
+
+    m_leftBoundMercator = p.geoToMapProjection(m_leftBound);
+    m_geometry.setPreserveGeometry(true, m_leftBound);
+    m_borderGeometry.setPreserveGeometry(true, m_leftBound);
+}
+
+void QMapCircleObjectPrivateQSG::updateGeometryGL()
+{
+    if (!m_map || m_map->geoProjection().projectionType() != QGeoProjection::ProjectionWebMercator)
+        return;
+
+    const QGeoProjectionWebMercator &p = static_cast<const QGeoProjectionWebMercator&>(m_map->geoProjection());
+    if (m_dataGL->m_geometry.isSourceDirty()
+            || m_dataGL->m_borderGeometry.isSourceDirty()) {
+        m_dataGL->updateCirclePath(center(), radius(), p);
+
+        if (m_dataGL->m_circlePath.length() == 0) { // Possibly cleared
+            m_dataGL->m_geometry.clear();
+            m_dataGL->m_borderGeometry.clear();
+            return;
+        }
+        m_dataGL->m_geometry.m_dataChanged = m_dataGL->m_borderGeometry.m_dataChanged = true;
+        m_dataGL->m_geometry.updateSourcePoints(*m_map, m_dataGL->m_circlePath);
+        m_dataGL->m_borderGeometry.updateSourcePoints(*m_map, QGeoCircle(center(), radius()));
+        m_dataGL->m_circlePath.clear(); // not needed anymore
+    }
+    m_dataGL->m_geometry.markScreenDirty();       // ToDo: this needs refactor. It's useless, remove screenDirty_ altogether.
+    m_dataGL->m_borderGeometry.markScreenDirty();
+    m_dataGL->m_borderGeometry.m_wrapOffset = m_dataGL->m_geometry.m_wrapOffset = p.projectionWrapFactor(m_dataGL->m_leftBoundMercator) + 1;
 }
 
 QGeoMapObjectPrivate *QMapCircleObjectPrivateQSG::clone()
@@ -146,41 +197,144 @@ QGeoMapObjectPrivate *QMapCircleObjectPrivateQSG::clone()
     return new QMapCircleObjectPrivateQSG(static_cast<QMapCircleObjectPrivate &>(*this));
 }
 
+void QMapCircleObjectPrivateQSG::switchToGL()
+{
+    if (!m_dataGL.isNull())
+        return;
+    QScopedPointer<CircleDataGL> data(new CircleDataGL);
+    m_dataGL.swap(data);
+    m_dataGL->markSourceDirty();
+    m_dataCPU.reset(nullptr);
+}
+
+void QMapCircleObjectPrivateQSG::switchToCPU()
+{
+    if (!m_dataCPU.isNull())
+        return;
+    QScopedPointer<CircleDataCPU> data(new CircleDataCPU);
+    m_dataCPU.swap(data);
+    m_dataGL.reset(nullptr);
+}
+
 QSGNode *QMapCircleObjectPrivateQSG::updateMapObjectNode(QSGNode *oldNode,
                                                          VisibleNode **visibleNode,
                                                          QSGNode *root,
-                                                         QQuickWindow * /*window*/)
+                                                         QQuickWindow * window)
 {
-//    Q_UNUSED(visibleNode); // coz of -Werror=unused-but-set-parameter
-    MapPolygonNode *node = static_cast<MapPolygonNode *>(oldNode);
+    if (!m_dataGL.isNull())
+        return updateMapObjectNodeGL(oldNode, visibleNode, root, window);
+    else
+        return updateMapObjectNodeCPU(oldNode, visibleNode, root, window);
+}
 
-    bool created = false;
-    if (!node) {
-        node = new MapPolygonNode();
-        *visibleNode = static_cast<VisibleNode *>(node);
-        created = true;
+QSGNode *QMapCircleObjectPrivateQSG::updateMapObjectNodeCPU(QSGNode *oldNode,
+                                                            VisibleNode **visibleNode,
+                                                            QSGNode *root,
+                                                            QQuickWindow */*window*/)
+{
+    if (!m_dataCPU->m_node || !oldNode) {
+        m_dataCPU->m_node = new MapPolygonNode();
+        *visibleNode = static_cast<VisibleNode *>(m_dataCPU->m_node);
+        if (oldNode)
+            delete oldNode;
+    } else {
+        m_dataCPU->m_node = static_cast<MapPolygonNode *>(oldNode);
+    }
+
+    if (!m_dataCPU->m_geometry.size() && !m_dataCPU->m_borderGeometry.size()) {
+        visibleNode = nullptr;
+        return nullptr;
     }
 
     //TODO: update only material
-    if (m_geometry.isScreenDirty() || !m_borderGeometry.isScreenDirty() || !oldNode || created) {
+    if (m_dataCPU->m_geometry.isScreenDirty() || m_dataCPU->m_borderGeometry.isScreenDirty() || oldNode != m_dataCPU->m_node) {
         //QMapPolygonObject *p = static_cast<QMapPolygonObject *>(q);
-        node->update(color(), borderColor(), &m_geometry, &m_borderGeometry);
-        m_geometry.setPreserveGeometry(false);
-        m_borderGeometry.setPreserveGeometry(false);
-        m_geometry.markClean();
-        m_borderGeometry.markClean();
+        m_dataCPU->m_node->update(color(), borderColor(), &m_dataCPU->m_geometry, &m_dataCPU->m_borderGeometry);
+        m_dataCPU->m_geometry.setPreserveGeometry(false);
+        m_dataCPU->m_borderGeometry.setPreserveGeometry(false);
+        m_dataCPU->m_geometry.markClean();
+        m_dataCPU->m_borderGeometry.markClean();
     }
 
-    if (created)
-        root->appendChildNode(node);
-
-    return node;
+    if (m_dataCPU->m_geometry.size() || m_dataCPU->m_borderGeometry.size()) {
+        root->appendChildNode(m_dataCPU->m_node);
+    } else {
+        delete m_dataCPU->m_node;
+        m_dataCPU->m_node = nullptr;
+        visibleNode = nullptr;
+        return nullptr;
+    }
+    return m_dataCPU->m_node;
 }
 
+QSGNode *QMapCircleObjectPrivateQSG::updateMapObjectNodeGL(QSGNode *oldNode,
+                                                           VisibleNode **visibleNode,
+                                                           QSGNode *root,
+                                                           QQuickWindow */*window*/)
+{
+    if (!m_dataGL->m_rootNode || !oldNode) {
+        m_dataGL->m_rootNode = new QDeclarativePolygonMapItemPrivateOpenGL::RootNode();
+        m_dataGL->m_node = new MapPolygonNodeGL();
+        m_dataGL->m_rootNode->appendChildNode(m_dataGL->m_node);
+        m_dataGL->m_polylinenode = new MapPolylineNodeOpenGLExtruded();
+        m_dataGL->m_rootNode->appendChildNode(m_dataGL->m_polylinenode);
+        m_dataGL->m_rootNode->markDirty(QSGNode::DirtyNodeAdded);
+        *visibleNode = static_cast<VisibleNode *>(m_dataGL->m_rootNode);
+        if (oldNode)
+            delete oldNode;
+    } else {
+        m_dataGL->m_rootNode = static_cast<QDeclarativePolygonMapItemPrivateOpenGL::RootNode *>(oldNode);
+    }
+
+    const QMatrix4x4 &combinedMatrix = m_map->geoProjection().qsgTransform();
+    const QDoubleVector3D &cameraCenter = m_map->geoProjection().centerMercator();
+
+    if (m_dataGL->m_borderGeometry.isScreenDirty()) {
+        /* Do the border update first */
+        m_dataGL->m_polylinenode->update(borderColor(),
+                               float(borderWidth()),
+                               &m_dataGL->m_borderGeometry,
+                               combinedMatrix,
+                               cameraCenter,
+                               Qt::SquareCap,
+                               true); // No LOD for circles ATM
+        m_dataGL->m_borderGeometry.setPreserveGeometry(false);
+        m_dataGL->m_borderGeometry.markClean();
+    }
+    if (m_dataGL->m_geometry.isScreenDirty()) {
+        m_dataGL->m_node->update(color(),
+                     &m_dataGL->m_geometry,
+                     combinedMatrix,
+                     cameraCenter);
+        m_dataGL->m_geometry.setPreserveGeometry(false);
+        m_dataGL->m_geometry.markClean();
+    }
+
+    if (!m_dataGL->m_polylinenode->isSubtreeBlocked() || !m_dataGL->m_node->isSubtreeBlocked()) {
+        m_dataGL->m_rootNode->setSubtreeBlocked(false);
+        root->appendChildNode(m_dataGL->m_rootNode);
+        return m_dataGL->m_rootNode;
+    } else {
+        delete m_dataGL->m_rootNode;
+        m_dataGL->m_rootNode = nullptr;
+        m_dataGL->m_node = nullptr;
+        m_dataGL->m_polylinenode = nullptr;
+        *visibleNode = nullptr;
+        return nullptr;
+    }
+}
 
 void QMapCircleObjectPrivateQSG::setCenter(const QGeoCoordinate &center)
 {
     QMapCircleObjectPrivateDefault::setCenter(center);
+    if (!QDeclarativeCircleMapItemPrivate::crossEarthPole(this->center(), this->radius())) // Switching implementation for circles crossing/not crossing poles
+        switchToGL();
+    else
+        switchToCPU();
+
+    if (!m_dataGL.isNull())
+        m_dataGL->markSourceDirty();
+
     updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
@@ -189,6 +343,14 @@ void QMapCircleObjectPrivateQSG::setCenter(const QGeoCoordinate &center)
 void QMapCircleObjectPrivateQSG::setRadius(qreal radius)
 {
     QMapCircleObjectPrivateDefault::setRadius(radius);
+    if (!QDeclarativeCircleMapItemPrivate::crossEarthPole(this->center(), this->radius())) // Switching implementation for circles crossing/not crossing poles
+        switchToGL();
+    else
+        switchToCPU();
+
+    if (!m_dataGL.isNull())
+        m_dataGL->markSourceDirty();
+
     updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
@@ -197,7 +359,8 @@ void QMapCircleObjectPrivateQSG::setRadius(qreal radius)
 void QMapCircleObjectPrivateQSG::setColor(const QColor &color)
 {
     QMapCircleObjectPrivateDefault::setColor(color);
-    updateGeometry();
+    if (!m_dataCPU.isNull())
+        updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
 }
@@ -205,7 +368,8 @@ void QMapCircleObjectPrivateQSG::setColor(const QColor &color)
 void QMapCircleObjectPrivateQSG::setBorderColor(const QColor &color)
 {
     QMapCircleObjectPrivateDefault::setBorderColor(color);
-    updateGeometry();
+    if (!m_dataCPU.isNull())
+        updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
 }
@@ -213,10 +377,10 @@ void QMapCircleObjectPrivateQSG::setBorderColor(const QColor &color)
 void QMapCircleObjectPrivateQSG::setBorderWidth(qreal width)
 {
     QMapCircleObjectPrivateDefault::setBorderWidth(width);
-    updateGeometry();
+    if (!m_dataCPU.isNull())
+        updateGeometry();
     if (m_map)
         emit m_map->sgNodeChanged();
 }
 
-
 QT_END_NAMESPACE