QML - Lesson 023. The hunt for bugs in the transmission pointer to QObject in QML

bug, Qt, pointer, JavaScriptOwnership, QML, указатель

One of the most vile and little predictable bugs are those that arise in an uncertain time. Among these include a bug that appears when the pointer is transmitted to the QObject in QML layer. The problem is that if there is no parent QObject, the transmission layer occurs in QML object change of ownership, that is, it is set JavaScriptOwnership. As a result, when the QML layer lost all references to this object, it will be removed garbage collector QML. Accordingly, all references in C++ layer will be non-valid. And the app when trying to appeal to these links will collapse in silence, without saying anything about the cause of the collapse.

Speaking of response uncertainty bug, it should be noted that this uncertainty stems from the time of garbage collection. In a typical embodiment, the time may come when the program a couple of gigabytes of memory dine or when the memory is not enough, and it will be available by performing garbage collection. That is, the application can run without problems for a long time without causing a bug, and it is even possible to go through several versions before the bug will manifest itself at any user who decides to report it to the developers.

It is worth noting that this rule will not be applied to the objects declared as Q_PROPERTY .

But we can use QML function gc() to show the problem, which will accelerate the garbage collection.

Hunting for bugs

Now let's see how it is implemented in the code.

Project structure

In this project, we are interested in the following files:

• main.cpp - do not get to pass the test object in QML layer without editing;
• MyClass.h - header file for class production problems;
• MyClass.cpp - file source code for class production problems;
• main.qml - QML layer file that will destroy the object pointer.

MyClass.h

In the test class will be created using the object method createObject() , and used via useObject() method, respectively. Once in QML layer will be zeroed pointer and garbage collection will be made, then useObject() method puts the program.

#ifndef MYCLASS_H
#define MYCLASS_H

#include <QObject>

class MyClass : public QObject
{
    Q_OBJECT

public:
    Q_INVOKABLE QObject* createObject();    // Create an object to test
    Q_INVOKABLE void useObject();           // Using the test object

private:
    QObject* m_object;     
};

#endif // MYCLASS_H

MyClass.cpp

In the method createObject() there are two version of the initialization m_object object. The first option is to not comment out a bug, the second will work stably. And useObject() method will receive the name of the object, of course, that in this case we get an empty string.

#include "MyClass.h"
#include <QObject>
#include <QDebug>
#include <QString>

QObject *MyClass::createObject()
{
    m_object = new QObject;         // Create an object with no parent
//    m_object = new QObject(this);   // Create an object with the parent
    return m_object;                // return the object
}

void MyClass::useObject()
{
    qDebug() << m_object->objectName(); // Display name of the object
}

main.cpp

Standard object registration for access to the QML context.

#include <QApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include "MyClass.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    MyClass mClass;

    QQmlApplicationEngine engine;
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));

    // Register a test class in QML layer showing the problem
    engine.rootContext()->setContextProperty("myClass", &mClass);

    return app.exec();
}

main.qml

The project created three buttons:

1. It will create the object and pass it a pointer to the property objectFromCppWorld ;
2. Reset the index by creating a bug;
3. Try to use a C++ object layer. And the method will work until the garbage collection will occur.

import QtQuick 2.5
import QtQuick.Controls 1.3

ApplicationWindow {
    width: 640
    height: 480
    visible: true

    property QtObject objectFromCppWorld: null

    /* To demonstrate the problem with the change of the parent object make 
     * three buttons that will activate in sequence. 
     * First create an object in C ++ layer and pass a pointer to it in QML layer. 
     * A second pointer will reset and run garbage collection. 
     * Third try to use an object
     */
    Column {
        anchors.centerIn: parent
        Button {
            text: "create object in C++, save the pointer to it in C++ world and pass it to QML"
            onClicked: objectFromCppWorld = myClass.createObject()
        }
        Button {
            text: "null the reference in QML"
            onClicked: {
                objectFromCppWorld = null
                gc()
            }
        }
        Button {
            // When garbage collection occurs, without the use of the parent object will not work
            text: "use created object in C++"
            onClicked: myClass.useObject()
        }
    }
}

Co-author of the article: Vladimir Kurman

Video