Who owns object returned by QQmlIncubator?

Question

In the following C++ code, a QML component is created using a QQmlIncubator. The Qt documentation has this snippet from here http://doc.qt.io/qt-5/qqmlincubator.html:

QQmlIncubator incubator;
component->create(incubator);

while (!incubator.isReady()) {
    QCoreApplication::processEvents(QEventLoop::AllEvents, 50);
}

// Who owns 'object'? When is it deleted?
QObject *object = incubator.object();

It's my understanding that this snippet isn't totally complete, because you'd need to call delete on component. According to http://doc.qt.io/qt-5/qqmlcomponent.html#create, the QQmlComponent::create() function transfers ownership of the returned object instance to the caller. Good so far.

Now comes my question--who owns object in the snippet above? In my case, I've place the above snippet in a member function of a class, so the QQmlIncubator incubator goes out of scope, and I only hold on to component and object, which are both instance variables of their containing class, and I call delete component in the destructor. Am I cleaning up properly?

So does object belong to component? When does object get destroyed?

Update 1

See my follow-up question: Safely deleting QML component being used in StackView transition.

Answer 1

Short answer

You should destruct the incubated object (if the incubator finished successfully), otherwise a memory leakage occur.

How to manage ownership?

A good approach may be to transfer the ownership to an object parent using QObject::setParent, for example to the visual parent. This is also done by Qt when you construct QML objects in the traditional way:

Any object assigned to an item's data property becomes a child of the item within its QObject hierarchy, for memory management purposes.

For convenience, the Item data property is its default property.

Reasoning

As mentioned in the QQmlComponent::create(QQmlContext *) documentation, the object ownership is transfered to the user:

The ownership of the returned object instance is transferred to the caller.

So, it is unlikely that the overloaded function QQmlComponent::create(QQmlIncubator &incubator, QQmlContext *context, QQmlContext *forContext) will keep the ownership, although it is not mentioned explicitly in the documentation. One could argue that the ownership is transferred to the QQmlIncubator object. This is indeed the case as long as the component is Loading, once it is ready the ownership is released as (implicitly) documented in QQmlIncubator::clear:

Any in-progress incubation is aborted. If the incubator is in the Ready state, the created object is not deleted.

Note that QQmlIncubator::clear is called inside the destructor of QQmlIncubator.

Answer 2

As currently written in your example, object destruction is currently your responsibility. Most likely you will want to take care of that by calling setParent() on object and thus passing on the responsibility to the parent item.

As you point out about component->create():

The ownership of the returned object instance is transferred to the caller.

and the incubator gives all appearance of preserving that intention.

An experimental way to verify this would be to check the parent of object as returned from the incubator.

Another way to verify this is to look directly at the relevant source code in Qt. Here are the files for QQmlIncubator:

https://github.com/qt/qtdeclarative/blob/dev/src/qml/qml/qqmlincubator.cpp https://github.com/qt/qtdeclarative/blob/dev/src/qml/qml/qqmlincubator_p.h https://github.com/qt/qtdeclarative/blob/dev/src/qml/qml/qqmlincubator.h

Examining those files, the only place that result is deleted is in the ::clear method:

if (s == Loading) {
    Q_ASSERT(d->compilationUnit);
    if (d->result) d->result->deleteLater();
    d->result = 0;
}