Support Threading on all (even imported) QObjects

[LeonMatthesKDAB]

In a recent discussion with @milianw , he come up with an interesting idea to extend support for cxx_qt::Threading to all QObjects, even imported ones.

Current Implementation

Currently we use CxxQtGuardedPointer as a thread-safe version of QPointer, which however requires the QObject to be aware of the GuardedPointer, so it only works with our own QObjects.

New Idea

We could get around this requirement by creating a "context" object, which is manually memory-managed and is basically only responsible for keeping a handle to the thread on which the original QObject lives.

Example by @milianw :

    // no parent! manual lifetime management - make sure to delete once QtThread goes out of scope!
    auto context = new QObject;
    // only safely accessible from the mainthread
    auto safeObject = QPointer(object);

    QThread::create([safeObject, context]() {
        /// Use invokeMethod on the context instead of on the object
        QMetaObject::invokeMethod(context, [safeObject, context]() {
            if (safeObject) {
                // actually "invoke" the slot here, directly
                safeObject->dataReady(...);
            }
            context->deleteLater();
        });
    });

Note: The memory-management of context will look different in our case, as we either need to create a context object per CxxQtThread, or per queue call.
Note that if we delete the context object in the destructor of CxxQtThread this would potentially delete it too early, as the invokeMethod may not yet have finished.

Implications

Note however, that this expects the context and the original QObject to remain on the same thread!
Which means either the threading itself, or moveToThread must be unsafe.

Currently QObjects don't implement Send, which is a bit at odds with moveToThread, which does indeed allow moving QObjects between threads.
So it's likely that moveToThread would have to be unsafe either way, which would be one way to remedy this conundrum.
If it's unsafe to call moveToThread, we can ask callers to guarantee that no QtThread instance for this QObject currently exists.

moveToThread also emits a QEvent::ThreadChange, which we could catch via an event filter.
https://doc.qt.io/qt-6/qobject.html#moveToThread
So another option would be to change the contexts thread at the same time.
However, the thread safety implications of this are also questionable.