Add Qt.callLater() function.

Calling the new Qt.callLater() multiple times in quick succession with the same
JS function as argument will result in a single call to that function, thus
eliminating redundant unnecessary calls.

Based on previous patches by Mathias Malmqvist <mathias.malmqvist@nokia.com>
and Chris Adams <chris.adams@jollamobile.com>

Change-Id: Ie71b60d4d48fa73d3deae723775cf36662d199ae
Task-number: QTBUG-22400
Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>

6 files changed, 336 insertions, 0 deletions

diff --git a/tests/auto/qml/qqmlqt/data/LaterComponent.qml b/tests/auto/qml/qqmlqt/data/LaterComponent.qml
new file mode 100644
index 0000000000..7dbd81d93d
--- /dev/null
+++ b/tests/auto/qml/qqmlqt/data/LaterComponent.qml
@@ -0,0 +1,14 @@
+import QtQuick 2.0
+import LaterImports 1.0
+
+TestElement {
+    id: deleteme
+    function testFn() {
+        gc(); // at this point, obj is deleted.
+        dangerousFunction(); // calling this function will throw an exeption
+        // because this object has been deleted and its context is not available
+
+        // which means that we shouldn't get to this line.
+        row.test10_1 = 1;
+    }
+}
diff --git a/tests/auto/qml/qqmlqt/data/LaterComponent2.qml b/tests/auto/qml/qqmlqt/data/LaterComponent2.qml
new file mode 100644
index 0000000000..56bcc0235b
--- /dev/null
+++ b/tests/auto/qml/qqmlqt/data/LaterComponent2.qml
@@ -0,0 +1,13 @@
+import QtQuick 2.0
+
+Item {
+    id: deleteme2
+    function testFn() {
+        // this function shouldn't be called,
+        // since the object will have been deleted.
+        var crashy = Qt.createQmlObject("import QtQuick 2.0; Item { }", deleteme2) // invalid calling context if invoked after gc
+        row.test11_1 = 2;
+    }
+
+    Component.onDestruction: row.test11_1 = 1; // success == the object was deleted, but testFn wasn't called.
+}
diff --git a/tests/auto/qml/qqmlqt/data/LaterComponent3.qml b/tests/auto/qml/qqmlqt/data/LaterComponent3.qml
new file mode 100644
index 0000000000..c6f445253a
--- /dev/null
+++ b/tests/auto/qml/qqmlqt/data/LaterComponent3.qml
@@ -0,0 +1,14 @@
+import QtQuick 2.0
+import LaterImports 1.0
+
+TestElement {
+    id: deleteme3
+    function testFn() {
+        gc(); // at this point, obj is deleted.
+        dangerousFunction(); // calling this function will throw an exeption
+        // because this object has been deleted and its context is not available
+
+        // which means that we shouldn't get to this line.
+        row.test12_1 = 1;
+    }
+}
diff --git a/tests/auto/qml/qqmlqt/data/LaterComponent4.qml b/tests/auto/qml/qqmlqt/data/LaterComponent4.qml
new file mode 100644
index 0000000000..0c53bd368b
--- /dev/null
+++ b/tests/auto/qml/qqmlqt/data/LaterComponent4.qml
@@ -0,0 +1,12 @@
+import QtQuick 2.0
+
+Item {
+    id: deleteme4
+    function testFn() {
+        // this function shouldn't be called,
+        // since the object will have been deleted.
+        row.test13_1 = 2;
+    }
+
+    Component.onDestruction: row.test13_1 = 1; // success == the object was deleted, but testFn wasn't called.
+}
diff --git a/tests/auto/qml/qqmlqt/data/later.qml b/tests/auto/qml/qqmlqt/data/later.qml
new file mode 100644
index 0000000000..a90f3aba9f
--- /dev/null
+++ b/tests/auto/qml/qqmlqt/data/later.qml
@@ -0,0 +1,124 @@
+import QtQuick 2.0
+import LaterImports 1.0
+
+Row {
+    id: row
+    Repeater {
+        id: repeater
+        model: 5
+        delegate: Item { }
+    }
+
+    property bool test1_1: false
+    property bool test1_2: row.focus
+    property bool test2_1: false
+    property bool test2_2: (firstFunctionCallCounter == 1 && secondFunctionCallCounter == 1 && signalCallCounter == 1)
+
+    property int firstFunctionCallCounter: 0
+    property int secondFunctionCallCounter: 0
+    property int signalCallCounter: 0
+
+    signal testSignal
+    onTestSignal: {
+        signalCallCounter++;
+    }
+
+    onChildrenChanged: {
+        Qt.callLater(row.forceActiveFocus); // built-in function
+        Qt.callLater(row.firstFunction);    // JS function
+        Qt.callLater(row.testSignal);       // signal
+    }
+
+    function firstFunction() {
+        firstFunctionCallCounter++;
+    }
+
+    function secondFunction() {
+        secondFunctionCallCounter++;
+    }
+
+    Component.onCompleted: {
+        test1_1 = !row.focus;
+        test2_1 = (firstFunctionCallCounter == 0);
+
+        Qt.callLater(secondFunction);
+        Qt.callLater(firstFunction);
+        Qt.callLater(secondFunction);
+    }
+
+    function test2() {
+        repeater.model = 2;
+    }
+
+    function test3() {
+        Qt.callLater(test3_recursive);
+    }
+
+    property int recursion: 0
+    property bool test3_1: (recursion == 1)
+    property bool test3_2: (recursion == 2)
+    property bool test3_3: (recursion == 3)
+    function test3_recursive() {
+        if (recursion < 3) {
+            Qt.callLater(test3_recursive);
+            Qt.callLater(test3_recursive);
+        }
+        recursion++;
+    }
+
+    function test4() {
+        Qt.callLater(functionThatDoesNotExist);
+    }
+
+    property bool test5_1: false
+    function test5() {
+        Qt.callLater(functionWithArguments, "THESE", "ARGS", "WILL", "BE", "OVERWRITTEN")
+        Qt.callLater(functionWithArguments, "firstArg", 2, "thirdArg")
+    }
+
+    function functionWithArguments(firstStr, secondInt, thirdString) {
+        test5_1 = (firstStr == "firstArg" && secondInt == 2 && thirdString == "thirdArg");
+    }
+
+
+    property bool test6_1: (callOrder_Later == "TWO THREE ") // not "THREE TWO "
+    function test6() {
+        Qt.callLater(test6Function1, "ONE");
+        Qt.callLater(test6Function2, "TWO");
+        Qt.callLater(test6Function1, "THREE");
+    }
+
+    property string callOrder_Later
+    function test6Function1(arg) { callOrder_Later += arg + " "; }
+    function test6Function2(arg) { callOrder_Later += arg + " "; }
+
+    property int test9_1: SingletonType.intProp;
+    function test9() {
+        SingletonType.resetIntProp();
+        Qt.callLater(SingletonType.testFunc)
+        Qt.callLater(SingletonType.testFunc)
+        Qt.callLater(SingletonType.testFunc)
+        Qt.callLater(SingletonType.testFunc)
+        // should only get called once.
+    }
+
+    property int test10_1: 0
+    function test10() {
+        var c = Qt.createComponent("LaterComponent.qml");
+        var obj = c.createObject(); // QML ownership.
+        Qt.callLater(obj.testFn);
+        // note: obj will be cleaned up during next gc().
+    }
+
+    property int test11_1: 0
+    function test11() {
+        var c = Qt.createComponent("LaterComponent2.qml");
+        var obj = c.createObject(); // QML ownership.
+        Qt.callLater(obj.testFn);
+        gc(); // this won't actually collect the obj, we need to trigger gc manually in the test.
+    }
+
+    function test14() {
+        Qt.callLater(console.log, "success")
+    }
+}
diff --git a/tests/auto/qml/qqmlqt/tst_qqmlqt.cpp b/tests/auto/qml/qqmlqt/tst_qqmlqt.cpp
index 01283dd587..413feb0eb4 100644
--- a/tests/auto/qml/qqmlqt/tst_qqmlqt.cpp
+++ b/tests/auto/qml/qqmlqt/tst_qqmlqt.cpp
@@ -53,6 +53,7 @@ public:
     tst_qqmlqt() {}
 
 private slots:
+    void initTestCase();
     void enums();
     void rgba();
     void hsla();
@@ -87,11 +88,68 @@ private slots:
     void fontFamilies();
     void quit();
     void resolvedUrl();
+    void later_data();
+    void later();
 
 private:
     QQmlEngine engine;
 };
 
+// for callLater()
+class TestElement : public QQuickItem
+{
+    Q_OBJECT
+public:
+    TestElement() : m_intptr(new int) {}
+    ~TestElement() { delete m_intptr; }
+
+    Q_INVOKABLE void dangerousFunction() {
+        delete m_intptr;
+        m_intptr = new int;
+        *m_intptr = 5;
+    }
+private:
+    int *m_intptr;
+};
+
+// for callLater()
+class TestModuleApi : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int intProp READ intProp WRITE setIntProp NOTIFY intPropChanged)
+
+public:
+    TestModuleApi() : m_int(0) {}
+    ~TestModuleApi() {}
+
+    int intProp() const { return m_int; }
+    void setIntProp(int v) { m_int = v; emit intPropChanged(); }
+
+    Q_INVOKABLE void testFunc() { ++m_int; emit intPropChanged(); }
+    Q_INVOKABLE void resetIntProp() { m_int = 0; emit intPropChanged(); }
+
+signals:
+    void intPropChanged();
+
+private:
+    int m_int;
+};
+
+static QObject *test_module_api_factory(QQmlEngine *engine, QJSEngine *scriptEngine)
+{
+   Q_UNUSED(engine)
+   Q_UNUSED(scriptEngine)
+   TestModuleApi *api = new TestModuleApi;
+   return api;
+}
+
+void tst_qqmlqt::initTestCase()
+{
+    QQmlDataTest::initTestCase();
+    qmlRegisterSingletonType<TestModuleApi>("LaterImports", 1, 0, "SingletonType", test_module_api_factory);
+    qmlRegisterType<TestElement>("LaterImports", 1, 0, "TestElement");
+}
+
 void tst_qqmlqt::enums()
 {
     QQmlComponent component(&engine, testFileUrl("enums.qml"));
@@ -934,6 +992,107 @@ void tst_qqmlqt::resolvedUrl()
     delete object;
 }
 
+void tst_qqmlqt::later_data()
+{
+    QTest::addColumn<QString>("function");
+    QTest::addColumn<QStringList>("expectedWarnings");
+    QTest::addColumn<QStringList>("propNames");
+    QTest::addColumn<QVariantList>("values");
+
+    QVariant vtrue = QVariant(true);
+
+    QTest::newRow("callLater from onCompleted")
+            << QString()
+            << QStringList()
+            << (QStringList() << "test1_1" << "test2_1" << "processEvents" << "test1_2" << "test2_2")
+            << (QVariantList() << vtrue << vtrue << QVariant() << vtrue << vtrue);
+
+    QTest::newRow("trigger Qt.callLater() via repeater")
+            << QString(QLatin1String("test2"))
+            << QStringList()
+            << (QStringList() << "processEvents" << "test2_2")
+            << (QVariantList() << QVariant() << vtrue);
+
+    QTest::newRow("recursive Qt.callLater()")
+            << QString(QLatin1String("test3"))
+            << QStringList()
+            << (QStringList() << "processEvents" << "test3_1" << "processEvents" << "test3_2" << "processEvents" << "test3_3")
+            << (QVariantList() << QVariant() << vtrue << QVariant() << vtrue << QVariant() << vtrue);
+
+    QTest::newRow("nonexistent function")
+            << QString(QLatin1String("test4"))
+            << (QStringList() << QString(testFileUrl("later.qml").toString() + QLatin1String(":70: ReferenceError: functionThatDoesNotExist is not defined")))
+            << QStringList()
+            << QVariantList();
+
+    QTest::newRow("callLater with different args")
+            << QString(QLatin1String("test5"))
+            << QStringList()
+            << (QStringList() << "processEvents" << "test5_1")
+            << (QVariantList() << QVariant() << vtrue);
+
+    QTest::newRow("delayed call ordering")
+            << QString(QLatin1String("test6"))
+            << QStringList()
+            << (QStringList() << "processEvents" << "test6_1")
+            << (QVariantList() << QVariant() << vtrue);
+
+    QTest::newRow("invoke module api invokable")
+            << QString(QLatin1String("test9"))
+            << QStringList()
+            << (QStringList() << "processEvents" << "test9_1" << "processEvents")
+            << (QVariantList() << QVariant() << QVariant(1) << QVariant());
+
+    QTest::newRow("invoke function of deleted QObject via callLater() causing deletion")
+            << QString(QLatin1String("test10"))
+            << (QStringList() << QString(testFileUrl("LaterComponent.qml").toString() + QLatin1String(":8: ReferenceError: dangerousFunction is not defined (exception occurred during delayed function evaluation)")))
+            << (QStringList() << "processEvents" << "test10_1" << "processEvents")
+            << (QVariantList() << QVariant() << QVariant(0) << QVariant());
+
+    QTest::newRow("invoke function of deleted QObject via callLater() after deletion")
+            << QString(QLatin1String("test11"))
+            << QStringList()
+            << (QStringList() << "collectGarbage" << "processEvents" << "test11_1" << "processEvents")
+            << (QVariantList() << QVariant() << QVariant() << QVariant(1) << QVariant());
+
+    QTest::newRow("invoke function which has no script origin")
+            << QString(QLatin1String("test14"))
+            << QStringList()
+            << (QStringList() << "collectGarbage")
+            << (QVariantList() << QVariant());
+}
+
+void tst_qqmlqt::later()
+{
+    QFETCH(QString, function);
+    QFETCH(QStringList, expectedWarnings);
+    QFETCH(QStringList, propNames);
+    QFETCH(QVariantList, values);
+
+    foreach (const QString &w, expectedWarnings)
+        QTest::ignoreMessage(QtWarningMsg, qPrintable(w));
+
+    QQmlComponent component(&engine, testFileUrl("later.qml"));
+    QObject *root = component.create();
+    QVERIFY(root != 0);
+
+    if (!function.isEmpty())
+        QMetaObject::invokeMethod(root, qPrintable(function));
+
+    for (int i = 0; i < propNames.size(); ++i) {
+        if (propNames.at(i) == QLatin1String("processEvents")) {
+            QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
+            QCoreApplication::processEvents();
+        } else if (propNames.at(i) == QLatin1String("collectGarbage")) {
+            engine.collectGarbage();
+        } else {
+            QCOMPARE(root->property(qPrintable(propNames.at(i))), values.at(i));
+        }
+    }
+
+    delete root;
+}
+
 QTEST_MAIN(tst_qqmlqt)
 
 #include "tst_qqmlqt.moc"