diff options
Diffstat (limited to 'src/corelib/kernel/qcoreapplication.cpp')
| -rw-r--r-- | src/corelib/kernel/qcoreapplication.cpp | 354 |
1 files changed, 201 insertions, 153 deletions
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp index 36892b6f6c..4262c14405 100644 --- a/src/corelib/kernel/qcoreapplication.cpp +++ b/src/corelib/kernel/qcoreapplication.cpp @@ -8,6 +8,7 @@ #ifndef QT_NO_QOBJECT #include "qabstracteventdispatcher.h" #include "qcoreevent.h" +#include "qcoreevent_p.h" #include "qeventloop.h" #endif #include "qmetaobject.h" @@ -34,8 +35,8 @@ #include <private/qthreadpool_p.h> #endif #endif -#include <qelapsedtimer.h> #include <qlibraryinfo.h> +#include <qpointer.h> #include <qvarlengtharray.h> #include <private/qfactoryloader_p.h> #include <private/qfunctions_p.h> @@ -56,7 +57,9 @@ # include "qeventdispatcher_glib_p.h" # endif # endif -# include "qeventdispatcher_unix_p.h" +# if !defined(Q_OS_WASM) +# include "qeventdispatcher_unix_p.h" +# endif #endif #ifdef Q_OS_WIN #include "qeventdispatcher_win_p.h" @@ -104,9 +107,14 @@ #include <algorithm> #include <memory> +#include <string> QT_BEGIN_NAMESPACE +#ifndef QT_NO_QOBJECT +Q_LOGGING_CATEGORY(lcDeleteLater, "qt.core.qobject.deletelater") +#endif + using namespace Qt::StringLiterals; Q_TRACE_PREFIX(qtcore, @@ -233,7 +241,11 @@ void QCoreApplicationPrivate::processCommandLineArguments() // Support for introspection -extern "C" void Q_DECL_EXPORT_OVERRIDABLE qt_startup_hook() +extern "C" void +#ifdef QT_SHARED +Q_DECL_EXPORT_OVERRIDABLE +#endif +qt_startup_hook() { } @@ -293,15 +305,15 @@ static void qt_call_pre_routines() if (!preRList.exists()) return; - QVFuncList list; - { + const QStartUpFuncList list = [] { const auto locker = qt_scoped_lock(globalRoutinesMutex); // Unlike qt_call_post_routines, we don't empty the list, because // Q_COREAPP_STARTUP_FUNCTION is a macro, so the user expects // the function to be executed every time QCoreApplication is created. - list = *preRList; - } - for (QtCleanUpFunction f : std::as_const(list)) + return *preRList; + }(); + + for (QtStartUpFunction f : list) f(); } @@ -513,6 +525,7 @@ void QCoreApplicationPrivate::eventDispatcherReady() } Q_CONSTINIT QBasicAtomicPointer<QThread> QCoreApplicationPrivate::theMainThread = Q_BASIC_ATOMIC_INITIALIZER(nullptr); +Q_CONSTINIT QBasicAtomicPointer<void> QCoreApplicationPrivate::theMainThreadId = Q_BASIC_ATOMIC_INITIALIZER(nullptr); QThread *QCoreApplicationPrivate::mainThread() { Q_ASSERT(theMainThread.loadRelaxed() != nullptr); @@ -576,7 +589,9 @@ void QCoreApplicationPrivate::initConsole() return; consoleAllocated = true; } else if (env.compare(u"attach"_s, Qt::CaseInsensitive) == 0) { - if (AttachConsole(ATTACH_PARENT_PROCESS) == FALSE) + // If the calling process is already attached to a console, + // the error code returned is ERROR_ACCESS_DENIED. + if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::GetLastError() != ERROR_ACCESS_DENIED) return; } else { // Unknown input, don't make any decision for the user. @@ -621,9 +636,13 @@ void QCoreApplicationPrivate::initLocale() # elif defined(Q_OS_ANDROID) && __ANDROID_API__ < __ANDROID_API_O__ // Android 6 still lacks nl_langinfo(), so we can't check. // FIXME: Shouldn't we still setlocale("UTF-8")? +# elif defined(Q_OS_VXWORKS) + // VxWorks has no nl_langinfo, so we can't check. # else - const char *charEncoding = nl_langinfo(CODESET); - if (Q_UNLIKELY(qstricmp(charEncoding, "UTF-8") != 0 && qstricmp(charEncoding, "utf8") != 0)) { + // std::string's SSO usually saves this the need to allocate: + const std::string oldEncoding = nl_langinfo(CODESET); + if (!Q_LIKELY(qstricmp(oldEncoding.data(), "UTF-8") == 0 + || qstricmp(oldEncoding.data(), "utf8") == 0)) { const QByteArray oldLocale = setlocale(LC_ALL, nullptr); QByteArray newLocale; bool warnOnOverride = true; @@ -658,14 +677,14 @@ void QCoreApplicationPrivate::initLocale() qWarning("Detected locale \"%s\" with character encoding \"%s\", which is not UTF-8.\n" "Qt depends on a UTF-8 locale, but has failed to switch to one.\n" "If this causes problems, reconfigure your locale. See the locale(1) manual\n" - "for more information.", oldLocale.constData(), nl_langinfo(CODESET)); + "for more information.", oldLocale.constData(), oldEncoding.data()); } else if (warnOnOverride) { // Let the user know we over-rode their configuration. qWarning("Detected locale \"%s\" with character encoding \"%s\", which is not UTF-8.\n" "Qt depends on a UTF-8 locale, and has switched to \"%s\" instead.\n" "If this causes problems, reconfigure your locale. See the locale(1) manual\n" "for more information.", - oldLocale.constData(), nl_langinfo(CODESET), newLocale.constData()); + oldLocale.constData(), oldEncoding.data(), newLocale.constData()); } } # endif // Platform choice @@ -745,7 +764,8 @@ void QCoreApplicationPrivate::initLocale() to reset the locale that is used for number formatting to "C"-locale. \sa QGuiApplication, QAbstractEventDispatcher, QEventLoop, - {Semaphores Example}, {Wait Conditions Example} + {Producer and Consumer using Semaphores}, + {Producer and Consumer using Wait Conditions} */ /*! @@ -984,7 +1004,10 @@ QCoreApplication::~QCoreApplication() and must be set before a QCoreApplication instance is created. \note It is strongly recommended not to enable this option since - it introduces security risks. + it introduces security risks. If this application does enable the flag and + starts child processes, it should drop the privileges as early as possible + by calling \c{setuid(2)} for itself, or at the latest by using the + QProcess::UnixProcessParameters::ResetIds flag. */ void QCoreApplication::setSetuidAllowed(bool allow) { @@ -1004,7 +1027,6 @@ bool QCoreApplication::isSetuidAllowed() return QCoreApplicationPrivate::setuidAllowed; } - /*! Sets the attribute \a attribute if \a on is true; otherwise clears the attribute. @@ -1017,6 +1039,10 @@ bool QCoreApplication::isSetuidAllowed() */ void QCoreApplication::setAttribute(Qt::ApplicationAttribute attribute, bool on) { + // Since we bit-shift these values, we can't go higher than 32 on 32 bit operating systems + // without changing the storage type of QCoreApplicationPrivate::attribs to quint64. + static_assert(Qt::AA_AttributeCount <= sizeof(QCoreApplicationPrivate::attribs) * CHAR_BIT); + if (on) QCoreApplicationPrivate::attribs |= 1 << attribute; else @@ -1065,6 +1091,14 @@ bool QCoreApplication::testAttribute(Qt::ApplicationAttribute attribute) \brief Whether the use of the QEventLoopLocker feature can cause the application to quit. + When this property is \c true the release of the last remaining + QEventLoopLocker operating on the application will attempt to + quit the application. + + Note that attempting a quit may not necessarily result in the + application quitting, for example if there still are open windows, + or the QEvent::Quit event is ignored. + The default is \c true. \sa QEventLoopLocker @@ -1092,7 +1126,7 @@ void QCoreApplication::setQuitLockEnabled(bool enabled) bool QCoreApplication::notifyInternal2(QObject *receiver, QEvent *event) { bool selfRequired = QCoreApplicationPrivate::threadRequiresCoreApplication(); - if (!self && selfRequired) + if (selfRequired && !self) return false; // Make it possible for Qt Script to hook into events even @@ -1112,6 +1146,11 @@ bool QCoreApplication::notifyInternal2(QObject *receiver, QEvent *event) QScopedScopeLevelCounter scopeLevelCounter(threadData); if (!selfRequired) return doNotify(receiver, event); + +#if QT_VERSION >= QT_VERSION_CHECK(7, 0, 0) + if (threadData->thread.loadRelaxed() != QCoreApplicationPrivate::mainThread()) + return false; +#endif return self->notify(receiver, event); } @@ -1170,7 +1209,7 @@ bool QCoreApplication::forwardEvent(QObject *receiver, QEvent *event, QEvent *or \endlist \b{Future direction:} This function will not be called for objects that live - outside the main thread in Qt 6. Applications that need that functionality + outside the main thread in Qt 7. Applications that need that functionality should find other solutions for their event inspection needs in the meantime. The change may be extended to the main thread, causing this function to be deprecated. @@ -1188,6 +1227,11 @@ bool QCoreApplication::notify(QObject *receiver, QEvent *event) Q_ASSERT(receiver); Q_ASSERT(event); +#if QT_VERSION >= QT_VERSION_CHECK(7, 0, 0) + Q_ASSERT(receiver->d_func()->threadData.loadAcquire()->thread.loadRelaxed() + == QCoreApplicationPrivate::mainThread()); +#endif + // no events are delivered after ~QCoreApplication() has started if (QCoreApplicationPrivate::is_app_closing) return true; @@ -1235,7 +1279,9 @@ bool QCoreApplicationPrivate::sendThroughApplicationEventFilters(QObject *receiv bool QCoreApplicationPrivate::sendThroughObjectEventFilters(QObject *receiver, QEvent *event) { - if (receiver != QCoreApplication::instance() && receiver->d_func()->extraData) { + if ((receiver->d_func()->threadData.loadRelaxed()->thread.loadAcquire() != mainThread() + || receiver != QCoreApplication::instance()) + && receiver->d_func()->extraData) { for (qsizetype i = 0; i < receiver->d_func()->extraData->eventFilters.size(); ++i) { QObject *obj = receiver->d_func()->extraData->eventFilters.at(i); if (!obj) @@ -1266,8 +1312,8 @@ bool QCoreApplicationPrivate::notify_helper(QObject *receiver, QEvent * event) Q_TRACE_EXIT(QCoreApplication_notify_exit, consumed, filtered); // send to all application event filters (only does anything in the main thread) - if (QCoreApplication::self - && receiver->d_func()->threadData.loadRelaxed()->thread.loadAcquire() == mainThread() + if (receiver->d_func()->threadData.loadRelaxed()->thread.loadAcquire() == mainThread() + && QCoreApplication::self && QCoreApplication::self->d_func()->sendThroughApplicationEventFilters(receiver, event)) { filtered = true; return filtered; @@ -1334,7 +1380,8 @@ bool QCoreApplication::closingDown() \threadsafe - \sa exec(), QTimer, QEventLoop::processEvents(), sendPostedEvents() + \sa exec(), QTimer, QChronoTimer, QEventLoop::processEvents(), + sendPostedEvents() */ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags) { @@ -1345,12 +1392,29 @@ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags) } /*! - \overload processEvents() + \overload Processes pending events for the calling thread for \a ms milliseconds or until there are no more events to process, whichever is shorter. + This is equivalent to calling: + \code + QCoreApplication::processEvents(flags, QDeadlineTimer(ms)); + \endcode +*/ +void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int ms) +{ + QCoreApplication::processEvents(flags, QDeadlineTimer(ms)); +} + +/*! + \since 6.7 + \overload + + Processes pending events for the calling thread untile \a deadline has expired, + or until there are no more events to process, whichever happens first. + Use of this function is discouraged. Instead, prefer to move long operations out of the GUI thread into an auxiliary one and to completely avoid nested event loop processing. If event processing is really @@ -1366,9 +1430,9 @@ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags) \threadsafe - \sa exec(), QTimer, QEventLoop::processEvents() + \sa exec(), QTimer, QChronoTimer, QEventLoop::processEvents() */ -void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int ms) +void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, QDeadlineTimer deadline) { // ### TODO: consider splitting this method into a public and a private // one, so that a user-invoked processEvents can be detected @@ -1376,10 +1440,9 @@ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int m QThreadData *data = QThreadData::current(); if (!data->hasEventDispatcher()) return; - QElapsedTimer start; - start.start(); + while (data->eventDispatcher.loadRelaxed()->processEvents(flags & ~QEventLoop::WaitForMoreEvents)) { - if (start.elapsed() > ms) + if (deadline.hasExpired()) break; } } @@ -1397,10 +1460,10 @@ void QCoreApplication::processEvents(QEventLoop::ProcessEventsFlags flags, int m main event loop receives events from the window system and dispatches these to the application widgets. - To make your application perform idle processing (by executing a - special function whenever there are no pending events), use a - QTimer with 0 timeout. More advanced idle processing schemes can - be achieved using processEvents(). + To make your application perform idle processing (by executing a special + function whenever there are no pending events), use a QChronoTimer + with 0ns timeout. More advanced idle processing schemes can be achieved + using processEvents(). We recommend that you connect clean-up code to the \l{QCoreApplication::}{aboutToQuit()} signal, instead of putting it in @@ -1452,6 +1515,8 @@ void QCoreApplicationPrivate::execCleanup() { threadData.loadRelaxed()->quitNow = false; in_exec = false; + + qCDebug(lcDeleteLater) << "Sending deferred delete events as part of exec cleanup"; QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete); } @@ -1635,31 +1700,6 @@ void QCoreApplication::postEvent(QObject *receiver, QEvent *event, int priority) return; } - if (event->type() == QEvent::DeferredDelete) - receiver->d_ptr->deleteLaterCalled = true; - - if (event->type() == QEvent::DeferredDelete && data == QThreadData::current()) { - // remember the current running eventloop for DeferredDelete - // events posted in the receiver's thread. - - // Events sent by non-Qt event handlers (such as glib) may not - // have the scopeLevel set correctly. The scope level makes sure that - // code like this: - // foo->deleteLater(); - // qApp->processEvents(); // without passing QEvent::DeferredDelete - // will not cause "foo" to be deleted before returning to the event loop. - - // If the scope level is 0 while loopLevel != 0, we are called from a - // non-conformant code path, and our best guess is that the scope level - // should be 1. (Loop level 0 is special: it means that no event loops - // are running.) - int loopLevel = data->loopLevel; - int scopeLevel = data->scopeLevel; - if (scopeLevel == 0 && loopLevel != 0) - scopeLevel = 1; - static_cast<QDeferredDeleteEvent *>(event)->level = loopLevel + scopeLevel; - } - // delete the event on exceptions to protect against memory leaks till the event is // properly owned in the postEventList std::unique_ptr<QEvent> eventDeleter(event); @@ -1686,33 +1726,26 @@ bool QCoreApplication::compressEvent(QEvent *event, QObject *receiver, QPostEven Q_ASSERT(receiver); Q_ASSERT(postedEvents); -#ifdef Q_OS_WIN + int receiverPostedEvents = receiver->d_func()->postedEvents.loadRelaxed(); // compress posted timers to this object. - if (event->type() == QEvent::Timer && receiver->d_func()->postedEvents > 0) { - int timerId = ((QTimerEvent *) event)->timerId(); - for (const QPostEvent &e : std::as_const(*postedEvents)) { - if (e.receiver == receiver && e.event && e.event->type() == QEvent::Timer - && ((QTimerEvent *) e.event)->timerId() == timerId) { + if (event->type() == QEvent::Timer && receiverPostedEvents > 0) { + int timerId = static_cast<QTimerEvent *>(event)->timerId(); + auto sameReceiver = [receiver](const QPostEvent &e) { return e.receiver == receiver; }; + auto it = std::find_if(postedEvents->cbegin(), postedEvents->cend(), sameReceiver); + while (receiverPostedEvents > 0 && it != postedEvents->cend()) { + if (it->event && it->event->type() == QEvent::Timer + && static_cast<QTimerEvent *>(it->event)->timerId() == timerId) { delete event; return true; } - } - return false; - } -#endif - if (event->type() == QEvent::DeferredDelete) { - if (receiver->d_ptr->deleteLaterCalled) { - // there was a previous DeferredDelete event, so we can drop the new one - delete event; - return true; + if (--receiverPostedEvents) + it = std::find_if(it + 1, postedEvents->cend(), sameReceiver); } - // deleteLaterCalled is set to true in postedEvents when queueing the very first - // deferred deletion event. return false; } - if (event->type() == QEvent::Quit && receiver->d_func()->postedEvents > 0) { + if (event->type() == QEvent::Quit && receiverPostedEvents > 0) { for (const QPostEvent &cur : std::as_const(*postedEvents)) { if (cur.receiver != receiver || cur.event == nullptr @@ -1792,6 +1825,8 @@ void QCoreApplicationPrivate::sendPostedEvents(QObject *receiver, int event_type // Exception-safe cleaning up without the need for a try/catch block struct CleanUp { + Q_DISABLE_COPY_MOVE(CleanUp) + QObject *receiver; int event_type; QThreadData *data; @@ -1846,14 +1881,37 @@ void QCoreApplicationPrivate::sendPostedEvents(QObject *receiver, int event_type // events posted by the current event loop; or // 3) if the event was posted before the outermost event loop. - int eventLevel = static_cast<QDeferredDeleteEvent *>(pe.event)->loopLevel(); - int loopLevel = data->loopLevel + data->scopeLevel; - const bool allowDeferredDelete = - (eventLevel > loopLevel - || (!eventLevel && loopLevel > 0) - || (event_type == QEvent::DeferredDelete - && eventLevel == loopLevel)); + const auto *event = static_cast<QDeferredDeleteEvent *>(pe.event); + qCDebug(lcDeleteLater) << "Processing deferred delete event for" << pe.receiver + << "with loop level" << event->loopLevel() << "and scope level" << event->scopeLevel(); + + qCDebug(lcDeleteLater) << "Checking" << data->thread << "with loop level" + << data->loopLevel << "and scope level" << data->scopeLevel; + + bool allowDeferredDelete = false; + if (event->loopLevel() == 0 && data->loopLevel > 0) { + qCDebug(lcDeleteLater) << "Event was posted outside outermost event loop" + << "and current thread has an event loop running."; + allowDeferredDelete = true; + } else { + const int totalEventLevel = event->loopLevel() + event->scopeLevel(); + const int totalThreadLevel = data->loopLevel + data->scopeLevel; + + if (totalEventLevel > totalThreadLevel) { + qCDebug(lcDeleteLater) << "Combined levels of event" << totalEventLevel + << "is higher than thread" << totalThreadLevel; + allowDeferredDelete = true; + } else if (event_type == QEvent::DeferredDelete && totalEventLevel == totalThreadLevel) { + qCDebug(lcDeleteLater) << "Explicit send of DeferredDelete and" + << "levels of event" << totalEventLevel + << "is same as thread" << totalThreadLevel; + allowDeferredDelete = true; + } + } + if (!allowDeferredDelete) { + qCDebug(lcDeleteLater) << "Failed conditions for deferred delete. Deferring again"; + // cannot send deferred delete if (!event_type && !receiver) { // we must copy it first; we want to re-post the event @@ -1870,6 +1928,8 @@ void QCoreApplicationPrivate::sendPostedEvents(QObject *receiver, int event_type data->postEventList.addEvent(pe_copy); } continue; + } else { + qCDebug(lcDeleteLater) << "Sending deferred delete to" << pe.receiver; } } @@ -2044,7 +2104,13 @@ bool QCoreApplicationPrivate::canQuitAutomatically() if (!in_exec) return false; - if (quitLockEnabled && quitLockRef.loadRelaxed()) + // The automatic quit functionality is triggered by + // both QEventLoopLocker and maybeLastWindowClosed. + // In either case, we don't want to quit if there + // are active QEventLoopLockers, even if quitLockEnabled + // is not enabled, as the property signals whether to + // trigger the automatic quit, not whether to block it. + if (quitLockRef.loadRelaxed()) return false; return true; @@ -2132,6 +2198,12 @@ void QCoreApplicationPrivate::quit() last-second cleanup. Note that no user interaction is possible in this state. + \note At this point the main event loop is still running, but will + not process further events on return except QEvent::DeferredDelete + events for objects deleted via deleteLater(). If event processing is + needed, use a nested event loop or call QCoreApplication::processEvents() + manually. + \sa quit() */ @@ -2155,7 +2227,7 @@ void QCoreApplicationPrivate::quit() to all toplevel widgets, where a reimplementation of changeEvent can re-translate the user interface by passing user-visible strings via the tr() function to the respective property setters. User-interface classes - generated by Qt Designer provide a \c retranslateUi() function that can be + generated by \QD provide a \c retranslateUi() function that can be called. The function returns \c true on success and false on failure. @@ -2440,10 +2512,10 @@ QString QCoreApplication::applicationFilePath() if (d->argc) { static QByteArray procName = QByteArray(d->argv[0]); - if (procName != d->argv[0]) { + if (procName != QByteArrayView(d->argv[0])) { // clear the cache if the procname changes, so we reprocess it. QCoreApplicationPrivate::clearApplicationFilePath(); - procName = QByteArray(d->argv[0]); + procName.assign(d->argv[0]); } } @@ -2587,7 +2659,7 @@ QStringList QCoreApplication::arguments() \brief the name of the organization that wrote this application The value is used by the QSettings class when it is constructed - using the empty constructor. This saves having to repeat this + using the default constructor. This saves having to repeat this information each time a QSettings object is created. On Mac, QSettings uses \l {QCoreApplication::}{organizationDomain()} as the organization @@ -2627,7 +2699,7 @@ QString QCoreApplication::organizationName() \brief the Internet domain of the organization that wrote this application The value is used by the QSettings class when it is constructed - using the empty constructor. This saves having to repeat this + using the default constructor. This saves having to repeat this information each time a QSettings object is created. On Mac, QSettings uses organizationDomain() as the organization @@ -2663,11 +2735,15 @@ QString QCoreApplication::organizationDomain() \property QCoreApplication::applicationName \brief the name of this application - The value is used by the QSettings class when it is constructed - using the empty constructor. This saves having to repeat this - information each time a QSettings object is created. + The application name is used in various Qt classes and modules, + most prominently in \l{QSettings} when it is constructed using the default constructor. + Other uses are in formatted logging output (see \l{qSetMessagePattern()}), + in output by \l{QCommandLineParser}, in \l{QTemporaryDir} and \l{QTemporaryFile} + default paths, and in some file locations of \l{QStandardPaths}. + \l{Qt D-Bus}, \l{Accessibility}, and the XCB platform integration make use + of the application name, too. - If not set, the application name defaults to the executable name (since 5.0). + If not set, the application name defaults to the executable name. \sa organizationName, organizationDomain, applicationVersion, applicationFilePath() */ @@ -2767,7 +2843,7 @@ Qt::PermissionStatus QCoreApplication::checkPermission(const QPermission &permis } /*! - \fn template<typename Functor> void QCoreApplication::requestPermission( + \fn template <typename Functor> void QCoreApplication::requestPermission( const QPermission &permission, Functor &&functor) Requests the given \a permission. @@ -2837,86 +2913,63 @@ Qt::PermissionStatus QCoreApplication::checkPermission(const QPermission &permis Called by the various requestPermission overloads to perform the request. - Calls the functor encapsulated in the \a slotObj in the given \a context + Calls the functor encapsulated in the \a slotObjRaw in the given \a context (which may be \c nullptr). */ void QCoreApplication::requestPermission(const QPermission &requestedPermission, - QtPrivate::QSlotObjectBase *slotObj, const QObject *context) + QtPrivate::QSlotObjectBase *slotObjRaw, const QObject *context) { + QtPrivate::SlotObjUniquePtr slotObj{slotObjRaw}; // adopts + Q_ASSERT(slotObj); + if (QThread::currentThread() != QCoreApplicationPrivate::mainThread()) { qWarning(lcPermissions, "Permissions can only be requested from the GUI (main) thread"); return; } - Q_ASSERT(slotObj); - - // Used as the signalID in the metacall event and only used to - // verify that we are not processing an unrelated event, not to - // emit the right signal. So using a value that can never clash - // with any signal index. Clang doesn't like this to be a static - // member of the PermissionReceiver. - static constexpr ushort PermissionReceivedID = 0xffff; - - // If we have a context object, then we dispatch the permission response - // asynchronously through a received object that lives in the same thread - // as the context object. Otherwise we call the functor synchronously when - // we get a response (which might still be asynchronous for the caller). class PermissionReceiver : public QObject { public: - PermissionReceiver(QtPrivate::QSlotObjectBase *slotObject, const QObject *context) - : slotObject(slotObject), context(context) - {} + explicit PermissionReceiver(QtPrivate::SlotObjUniquePtr &&slotObject, const QObject *context) + : slotObject(std::move(slotObject)), context(context ? context : this) + { + Q_ASSERT(this->context); + moveToThread(this->context->thread()); + } - protected: - bool event(QEvent *event) override { - if (event->type() == QEvent::MetaCall) { - auto metaCallEvent = static_cast<QMetaCallEvent *>(event); - if (metaCallEvent->id() == PermissionReceivedID) { - Q_ASSERT(slotObject); - // only execute if context object is still alive - if (context) - slotObject->call(const_cast<QObject*>(context.data()), metaCallEvent->args()); - slotObject->destroyIfLastRef(); - deleteLater(); - - return true; - } + void finalizePermissionRequest(const QPermission &permission) + { + Q_ASSERT(slotObject); + // only execute if context object is still alive + if (context) { + void *args[] = { nullptr, const_cast<QPermission *>(&permission) }; + slotObject->call(const_cast<QObject *>(context.data()), args); } - return QObject::event(event); + deleteLater(); } + private: - QtPrivate::QSlotObjectBase *slotObject; + QtPrivate::SlotObjSharedPtr slotObject; QPointer<const QObject> context; }; - PermissionReceiver *receiver = nullptr; - if (context) { - receiver = new PermissionReceiver(slotObj, context); - receiver->moveToThread(context->thread()); - } + + PermissionReceiver *receiver = new PermissionReceiver(std::move(slotObj), context); QPermissions::Private::requestPermission(requestedPermission, [=](Qt::PermissionStatus status) { - Q_ASSERT_X(status != Qt::PermissionStatus::Undetermined, "QPermission", - "QCoreApplication::requestPermission() should never return Undetermined"); - if (status == Qt::PermissionStatus::Undetermined) + if (status == Qt::PermissionStatus::Undetermined) { + Q_ASSERT_X(false, "QPermission", + "Internal error: requestPermission() should never return Undetermined"); status = Qt::PermissionStatus::Denied; + } if (QCoreApplication::self) { QPermission permission = requestedPermission; permission.m_status = status; - - if (receiver) { - auto metaCallEvent = QMetaCallEvent::create(slotObj, qApp, - PermissionReceivedID, permission); - qApp->postEvent(receiver, metaCallEvent); - } else { - void *argv[] = { nullptr, &permission }; - slotObj->call(const_cast<QObject*>(context), argv); - } + QMetaObject::invokeMethod(receiver, + &PermissionReceiver::finalizePermissionRequest, + Qt::QueuedConnection, + permission); } - - if (!receiver) - slotObj->destroyIfLastRef(); }); } @@ -2952,11 +3005,6 @@ Q_GLOBAL_STATIC(QRecursiveMutex, libraryPathMutex) directory (and its existence) may change when the directory of the application executable becomes known. - If you want to iterate over the list, you can use the \l foreach - pseudo-keyword: - - \snippet code/src_corelib_kernel_qcoreapplication.cpp 2 - \sa setLibraryPaths(), addLibraryPath(), removeLibraryPath(), QLibrary, {How to Create Qt Plugins} */ @@ -3205,7 +3253,7 @@ void QCoreApplication::installNativeEventFilter(QAbstractNativeEventFilter *filt */ void QCoreApplication::removeNativeEventFilter(QAbstractNativeEventFilter *filterObject) { - QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance(); + QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance(QCoreApplicationPrivate::theMainThread.loadAcquire()); if (!filterObject || !eventDispatcher) return; eventDispatcher->removeNativeEventFilter(filterObject); |