Merge tag 'v5.15.15-lts' into tqtc/lts-5.15-opensourcev5.15.15-lts-lgpl

Qt 5.15.15-lts release

Change-Id: I0272e1ec4b55be362e13e36cd48f532fe4b7c770

4 files changed, 300 insertions, 0 deletions

diff --git a/tests/auto/qml/qjsengine/tst_qjsengine.cpp b/tests/auto/qml/qjsengine/tst_qjsengine.cpp
index f1c34e6142..8e7958c3ef 100644
--- a/tests/auto/qml/qjsengine/tst_qjsengine.cpp
+++ b/tests/auto/qml/qjsengine/tst_qjsengine.cpp
@@ -105,6 +105,8 @@ private slots:
     void collectGarbageNestedWrappersTwoEngines();
     void gcWithNestedDataStructure();
     void stacktrace();
+    void unshiftAndSort();
+    void unshiftAndPushAndSort();
     void numberParsing_data();
     void numberParsing();
     void automaticSemicolonInsertion();
@@ -1982,6 +1984,81 @@ void tst_QJSEngine::stacktrace()
     }
 }
 
+void tst_QJSEngine::unshiftAndSort()
+{
+    QJSEngine engine;
+    QJSValue func = engine.evaluate(R"""(
+    (function (objectArr, currIdx) {
+        objectArr.unshift({"sortIndex": currIdx});
+        objectArr.sort(function(a, b) {
+            if (a.sortIndex > b.sortIndex)
+                return 1;
+            if (a.sortIndex < b.sortIndex)
+                return -1;
+            return 0;
+        });
+        return objectArr;
+    })
+    )""");
+    QVERIFY(func.isCallable());
+    QJSValue objectArr = engine.newArray();
+
+    for (int i = 0; i < 5; ++i) {
+        objectArr = func.call({objectArr, i});
+        QVERIFY2(!objectArr.isError(), qPrintable(objectArr.toString()));
+        const int length = objectArr.property("length").toInt();
+
+        // It did add one element
+        QCOMPARE(length, i + 1);
+
+        for (int x = 0; x < length; ++x) {
+            // We didn't sort cruft into the array.
+            QVERIFY(!objectArr.property(x).isUndefined());
+
+            // The array is actually sorted.
+            QCOMPARE(objectArr.property(x).property("sortIndex").toInt(), x);
+        }
+    }
+}
+
+void tst_QJSEngine::unshiftAndPushAndSort()
+{
+    QJSEngine engine;
+    QJSValue func = engine.evaluate(R"""(
+    (function (objectArr, currIdx) {
+        objectArr.unshift({"sortIndex": currIdx});
+        objectArr.push({"sortIndex": currIdx + 1});
+        objectArr.sort(function(a, b) {
+            if (a.sortIndex > b.sortIndex)
+                return 1;
+            if (a.sortIndex < b.sortIndex)
+                return -1;
+            return 0;
+        });
+        return objectArr;
+    })
+    )""");
+    QVERIFY(func.isCallable());
+    QJSValue objectArr = engine.newArray();
+
+    for (int i = 0; i < 20; i += 2) {
+        objectArr = func.call({objectArr, i});
+        QVERIFY2(!objectArr.isError(), qPrintable(objectArr.toString()));
+        const int length = objectArr.property("length").toInt();
+
+        // It did add 2 elements
+        QCOMPARE(length, i + 2);
+
+        for (int x = 0; x < length; ++x) {
+            // We didn't sort cruft into the array.
+            QVERIFY(!objectArr.property(x).isUndefined());
+
+            // The array is actually sorted.
+            QCOMPARE(objectArr.property(x).property("sortIndex").toInt(), x);
+        }
+    }
+}
+
 void tst_QJSEngine::numberParsing_data()
 {
     QTest::addColumn<QString>("string");
diff --git a/tests/auto/quick/pointerhandlers/qquickpointerhandler/data/clip.qml b/tests/auto/quick/pointerhandlers/qquickpointerhandler/data/clip.qml
new file mode 100644
index 0000000000..63bc94ae5c
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickpointerhandler/data/clip.qml
@@ -0,0 +1,36 @@
+import QtQuick 2.12
+import Qt.test 1.0
+
+Item {
+    width: 200
+    height: 200
+
+    Rectangle {
+        id: circle
+        y: 0
+        width: 100
+        height: width
+        radius: width/2
+        color: "#3e1"
+        clip: true
+
+        // Rectangle contains() is not affected by its 'radius' property
+        containmentMask: QtObject {
+            property alias radius: circle.radius
+            function contains(point: point) : bool {
+                return (Math.pow(point.x - radius, 2) + Math.pow(point.y - radius, 2)) < Math.pow(radius, 2)
+            }
+        }
+        EventHandler {
+            objectName: "circle eventHandler"
+        }
+        Rectangle {
+            width: circle.width/2
+            height: width
+            color: "red"
+            EventHandler {
+                objectName: "eventHandler"
+            }
+        }
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/qquickpointerhandler/data/grabberSceneChange.qml b/tests/auto/quick/pointerhandlers/qquickpointerhandler/data/grabberSceneChange.qml
new file mode 100644
index 0000000000..166f7d4618
--- /dev/null
+++ b/tests/auto/quick/pointerhandlers/qquickpointerhandler/data/grabberSceneChange.qml
@@ -0,0 +1,80 @@
+import QtQuick 2.12
+import QtQuick.Window 2.12
+import Qt.test 1.0
+
+Window {
+    id: root
+    visible: true
+    objectName: "root"
+    width: 320
+    height: 480
+
+    property bool useTimer : false
+    property int grabChangedCounter : 0
+
+    Item {
+        id: back
+        anchors.fill: parent
+
+        Rectangle {
+            id: background
+            anchors.fill: parent
+            color: "blue"
+        }
+
+        Rectangle {
+            id: container
+            objectName: "container"
+            anchors.fill: parent
+            anchors.margins: 50
+            z: 2
+
+            Rectangle {
+                id: likeButton
+                color: "gray"
+                anchors.centerIn: parent
+                width: 200
+                height: 200
+
+                DragHandler {
+                    id: handler
+                    objectName: "dragHandler"
+                    grabPermissions: PointerHandler.CanTakeOverFromItems
+                    onGrabChanged: {
+                        ++grabChangedCounter
+                    }
+                }
+            }
+        }
+
+        Timer {
+            id: reparentTimer
+            running: false
+            interval: 100
+            repeat: false
+            onTriggered: {
+                container.parent = null
+            }
+        }
+
+        Rectangle {
+            id: likeButton2
+            color: "yellow"
+            anchors.centerIn: parent
+            width: 100
+            height: 100
+            z: 3
+
+            MultiPointTouchArea {
+                id: press
+                anchors.fill: parent
+                onPressed: {
+                    if (useTimer)
+                        reparentTimer.running = true
+                    else
+                        container.parent = null
+                }
+            }
+        }
+    }
+}
diff --git a/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp b/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp
index 2b6482465c..7be2198197 100644
--- a/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp
+++ b/tests/auto/quick/pointerhandlers/qquickpointerhandler/tst_qquickpointerhandler.cpp
@@ -244,6 +244,9 @@ private slots:
     void dynamicCreation();
     void handlerInWindow();
     void dynamicCreationInWindow();
+    void grabberSceneChange_data();
+    void grabberSceneChange();
+    void clip();
 
 protected:
     bool eventFilter(QObject *, QEvent *event)
@@ -679,6 +682,110 @@ void tst_PointerHandlers::dynamicCreationInWindow()
     QTRY_COMPARE(handler->releaseEventCount, 1);
 }
 
+/*!
+    Verify that removing an item that has a grabbing handler from the scene
+    does not result in crashes in our event dispatching code. The item's window()
+    pointer will be nullptr, so the handler must have released the grab, or never
+    gotten the grab, depending on when the item gets removed.
+
+    See QTBUG-114475.
+*/
+void tst_PointerHandlers::grabberSceneChange_data()
+{
+    QTest::addColumn<bool>("useTimer");
+    QTest::addColumn<int>("grabChangedCount");
+
+    QTest::addRow("Immediately") << false << 0;
+    QTest::addRow("Delayed") << true << 2;
+}
+
+void tst_PointerHandlers::grabberSceneChange()
+{
+    QFETCH(const bool, useTimer);
+    QFETCH(const int, grabChangedCount);
+
+    QQmlEngine engine;
+    QQmlComponent component(&engine);
+    component.loadUrl(testFileUrl("grabberSceneChange.qml"));
+    QQuickWindow *window = qobject_cast<QQuickWindow*>(component.create());
+    QScopedPointer<QQuickWindow> cleanup(window);
+    QVERIFY(window);
+    window->show();
+    QVERIFY(QTest::qWaitForWindowExposed(window));
+
+    window->setProperty("useTimer", useTimer);
+
+    QQuickItem *container = window->findChild<QQuickItem *>("container");
+
+    QPoint p1 = QPoint(window->width() / 2, window->height() / 2);
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, p1);
+    // The container gets removed from this window, either immediately on
+    // press, or through a timer.
+    QTRY_COMPARE(container->parentItem(), nullptr);
+
+    QCOMPARE(window->property("grabChangedCounter").toInt(), grabChangedCount);
+
+    // this should not crash
+    QTest::mouseMove(window, p1 + QPoint(5, 5));
+}
+
+void tst_PointerHandlers::clip()
+{
+    QScopedPointer<QQuickView> windowPtr;
+    createView(windowPtr, "clip.qml");
+    QQuickView * window = windowPtr.data();
+    QVERIFY(window);
+    window->show();
+    QVERIFY(QTest::qWaitForWindowExposed(window));
+
+    EventHandler *handler = window->contentItem()->findChild<EventHandler*>("eventHandler");
+    EventHandler *circleHandler = window->contentItem()->findChild<EventHandler*>("circle eventHandler");
+
+    QCOMPARE(handler->pressEventCount, 0);
+    QCOMPARE(circleHandler->pressEventCount, 0);
+    QCOMPARE(handler->releaseEventCount, 0);
+    QCOMPARE(circleHandler->releaseEventCount, 0);
+
+    const QPoint rectPt = QPoint(1, 1);
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, rectPt);
+    QCOMPARE(handler->pressEventCount, 1);
+    QCOMPARE(circleHandler->pressEventCount, 0);
+
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, rectPt);
+    QCOMPARE(handler->releaseEventCount, 1);
+    QCOMPARE(circleHandler->releaseEventCount, 0);
+
+
+    handler->pressEventCount = 0;
+    circleHandler->pressEventCount = 0;
+    handler->releaseEventCount = 0;
+    circleHandler->releaseEventCount = 0;
+
+    const QPoint rectAndCirclePt = QPoint(49 ,49);
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, rectAndCirclePt);
+    QCOMPARE(handler->pressEventCount, 1);
+    QCOMPARE(circleHandler->pressEventCount, 1);
+
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, rectAndCirclePt);
+    QCOMPARE(handler->releaseEventCount, 1);
+    QCOMPARE(circleHandler->releaseEventCount, 1);
+
+
+    handler->pressEventCount = 0;
+    circleHandler->pressEventCount = 0;
+    handler->releaseEventCount = 0;
+    circleHandler->releaseEventCount = 0;
+
+    const QPoint circlePt = QPoint(51 ,51);
+    QTest::mousePress(window, Qt::LeftButton, Qt::NoModifier, circlePt);
+    QCOMPARE(handler->pressEventCount, 0);
+    QCOMPARE(circleHandler->pressEventCount, 1);
+
+    QTest::mouseRelease(window, Qt::LeftButton, Qt::NoModifier, circlePt);
+    QCOMPARE(handler->releaseEventCount, 0);
+    QCOMPARE(circleHandler->releaseEventCount, 1);
+}
+
 QTEST_MAIN(tst_PointerHandlers)
 
 #include "tst_qquickpointerhandler.moc"