Move registration functions from qqmlimport.cpp to qqmlmetatype.cpp

These functions require the metatype data in multiple interdependent
places. If they are executed concurrently data races are almost
guaranteed.

Move the functions to qqmlmetatype.cpp and keep the metatype mutex
locked for their duration. Access to the internals of the metatype
system also allows us to significantly simplify the logic.

Additionally we can remove methods only used by those functions from the
public interface of QQmlMetaType now.

Task-number: QTBUG-73271
Change-Id: I1279259cca5cb5be63026d5b74f5d013e7a1ac5c
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

1 files changed, 183 insertions, 20 deletions

diff --git a/src/qml/qml/qqmlmetatype.cpp b/src/qml/qml/qqmlmetatype.cpp
index 8c3717844c..f7b5ee8bf0 100644
--- a/src/qml/qml/qqmlmetatype.cpp
+++ b/src/qml/qml/qqmlmetatype.cpp
@@ -43,6 +43,7 @@
 #include <private/qqmltypemodule_p_p.h>
 #include <private/qqmltype_p_p.h>
 #include <private/qqmltypeloader_p.h>
+#include <private/qqmlextensionplugin_p.h>
 
 #include <QtCore/qcoreapplication.h>
 #include <QtCore/qmutex.h>
@@ -483,29 +484,203 @@ void QQmlMetaType::registerUndeletableType(const QQmlType &dtype)
     data->undeletableTypes.insert(dtype);
 }
 
-bool QQmlMetaType::namespaceContainsRegistrations(const QString &uri, int majorVersion)
+static bool namespaceContainsRegistrations(const QQmlMetaTypeData *data, const QString &uri,
+                                           int majorVersion)
 {
-    const QQmlMetaTypeDataPtr data;
-
     // Has any type previously been installed to this namespace?
     QHashedString nameSpace(uri);
-    for (const QQmlType &type : data->types)
+    for (const QQmlType &type : data->types) {
         if (type.module() == nameSpace && type.majorVersion() == majorVersion)
             return true;
+    }
 
     return false;
 }
 
-void QQmlMetaType::protectNamespace(const QString &uri)
+class QQmlMetaTypeRegistrationFailureRecorder
 {
+    Q_DISABLE_COPY_MOVE(QQmlMetaTypeRegistrationFailureRecorder)
+public:
+    QQmlMetaTypeRegistrationFailureRecorder(QQmlMetaTypeData *data, QStringList *failures)
+        : data(data)
+    {
+        data->setTypeRegistrationFailures(failures);
+    }
+
+    ~QQmlMetaTypeRegistrationFailureRecorder()
+    {
+        data->setTypeRegistrationFailures(nullptr);
+    }
+
+    QQmlMetaTypeData *data = nullptr;
+};
+
+
+bool QQmlMetaType::registerPluginTypes(QObject *instance, const QString &basePath,
+                                       const QString &uri, const QString &typeNamespace, int vmaj,
+                                       QList<QQmlError> *errors)
+{
+    QQmlTypesExtensionInterface *iface = qobject_cast<QQmlTypesExtensionInterface *>(instance);
+    if (!iface) {
+        if (errors) {
+            QQmlError error;
+            error.setDescription(QStringLiteral("Module loaded for URI '%1' does not implement "
+                                                "QQmlTypesExtensionInterface").arg(typeNamespace));
+            errors->prepend(error);
+        }
+        return false;
+    }
+
+    if (!typeNamespace.isEmpty() && typeNamespace != uri) {
+        // This is an 'identified' module
+        // The namespace for type registrations must match the URI for locating the module
+        if (errors) {
+            QQmlError error;
+            error.setDescription(
+                    QStringLiteral("Module namespace '%1' does not match import URI '%2'")
+                            .arg(typeNamespace).arg(uri));
+            errors->prepend(error);
+        }
+        return false;
+    }
+
+    QStringList failures;
     QQmlMetaTypeDataPtr data;
-    data->protectedNamespaces.insert(uri);
+    {
+        QQmlMetaTypeRegistrationFailureRecorder failureRecorder(data, &failures);
+        if (!typeNamespace.isEmpty()) {
+            // This is an 'identified' module
+            if (namespaceContainsRegistrations(data, typeNamespace, vmaj)) {
+                // Other modules have already installed to this namespace
+                if (errors) {
+                    QQmlError error;
+                    error.setDescription(QStringLiteral("Namespace '%1' has already been used "
+                                                        "for type registration")
+                                                 .arg(typeNamespace));
+                    errors->prepend(error);
+                }
+                return false;
+            }
+
+            data->protectedNamespaces.insert(uri);
+        } else {
+            // This is not an identified module - provide a warning
+            qWarning().nospace() << qPrintable(
+                    QStringLiteral("Module '%1' does not contain a module identifier directive - "
+                                   "it cannot be protected from external registrations.").arg(uri));
+        }
+
+        if (auto *plugin = qobject_cast<QQmlExtensionPlugin *>(instance)) {
+        // basepath should point to the directory of the module, not the plugin file itself:
+        QQmlExtensionPluginPrivate::get(plugin)->baseUrl
+                = QQmlImports::urlFromLocalFileOrQrcOrUrl(basePath);
+        }
+
+        data->typeRegistrationNamespace = typeNamespace;
+        const QByteArray bytes = uri.toUtf8();
+        const char *moduleId = bytes.constData();
+        iface->registerTypes(moduleId);
+        data->typeRegistrationNamespace.clear();
+    }
+
+    if (!failures.isEmpty()) {
+        if (errors) {
+            for (const QString &failure : qAsConst(failures)) {
+                QQmlError error;
+                error.setDescription(failure);
+                errors->prepend(error);
+            }
+        }
+        return false;
+    }
+
+    return true;
 }
 
-void QQmlMetaType::setTypeRegistrationNamespace(const QString &uri)
+/*
+    \internal
+
+    Fetches the QQmlType instance registered for \a urlString, creating a
+    registration for it if it is not already registered, using the associated
+    \a typeName, \a isCompositeSingleton, \a majorVersion and \a minorVersion
+    details.
+
+    Errors (if there are any) are placed into \a errors, if it is nonzero.
+    Otherwise errors are printed as warnings.
+*/
+QQmlType QQmlMetaType::typeForUrl(const QString &urlString,
+                                  const QHashedStringRef &qualifiedType,
+                                  bool isCompositeSingleton, QList<QQmlError> *errors,
+                                  int majorVersion, int minorVersion)
 {
+    // ### unfortunate (costly) conversion
+    const QUrl url = QQmlTypeLoader::normalize(QUrl(urlString));
+
     QQmlMetaTypeDataPtr data;
-    data->typeRegistrationNamespace = uri;
+    QQmlType ret(data->urlToType.value(url));
+    if (ret.isValid() && ret.sourceUrl() == url)
+        return ret;
+
+    const int dot = qualifiedType.indexOf(QLatin1Char('.'));
+    const QString typeName = dot < 0
+            ? qualifiedType.toString()
+            : QString(qualifiedType.constData() + dot + 1, qualifiedType.length() - dot - 1);
+
+    QStringList failures;
+    QQmlMetaTypeRegistrationFailureRecorder failureRecorder(data, &failures);
+
+    // Register the type. Note that the URI parameters here are empty; for
+    // file type imports, we do not place them in a URI as we don't
+    // necessarily have a good and unique one (picture a library import,
+    // which may be found in multiple plugin locations on disk), but there
+    // are other reasons for this too.
+    //
+    // By not putting them in a URI, we prevent the types from being
+    // registered on a QQmlTypeModule; this is important, as once types are
+    // placed on there, they cannot be easily removed, meaning if the
+    // developer subsequently loads a different import (meaning different
+    // types) with the same URI (using, say, a different plugin path), it is
+    // very undesirable that we continue to associate the types from the
+    // "old" URI with that new module.
+    //
+    // Not having URIs also means that the types cannot be found by name
+    // etc, the only way to look them up is through QQmlImports -- for
+    // better or worse.
+    const QQmlType::RegistrationType registrationType = isCompositeSingleton
+            ? QQmlType::CompositeSingletonType
+            : QQmlType::CompositeType;
+    if (checkRegistration(registrationType, data, nullptr, typeName, majorVersion)) {
+        auto *priv = new QQmlTypePrivate(registrationType);
+        priv->elementName = typeName;
+        priv->version_maj = majorVersion;
+        priv->version_min = minorVersion;
+
+        if (isCompositeSingleton) {
+            priv->extraData.sd->singletonInstanceInfo = new QQmlType::SingletonInstanceInfo;
+            priv->extraData.sd->singletonInstanceInfo->url = url;
+            priv->extraData.sd->singletonInstanceInfo->typeName = typeName;
+        } else {
+            priv->extraData.fd->url = url;
+        }
+
+        data->registerType(priv);
+        priv->refCount.deref();
+        addTypeToData(priv, data);
+        data->urlToType.insertMulti(url, priv);
+        return QQmlType(priv);
+    }
+
+    // This means that the type couldn't be found by URL, but could not be
+    // registered either, meaning we most likely were passed some kind of bad
+    // data.
+    if (errors) {
+        QQmlError error;
+        error.setDescription(failures.join('\n'));
+        errors->prepend(error);
+    } else {
+        qWarning("%s", failures.join('\n').toLatin1().constData());
+    }
+    return QQmlType();
 }
 
 QMutex *QQmlMetaType::typeRegistrationLock()
@@ -1094,18 +1269,6 @@ QString QQmlMetaType::prettyTypeName(const QObject *object)
     return typeName;
 }
 
-void QQmlMetaType::startRecordingTypeRegFailures(QStringList *failures)
-{
-    QQmlMetaTypeDataPtr data;
-    data->startRecordingTypeRegFailures(failures);
-}
-
-void QQmlMetaType::stopRecordingTypeRegFailures()
-{
-    QQmlMetaTypeDataPtr data;
-    data->stopRecordingTypeRegFailures();
-}
-
 QList<QQmlProxyMetaObject::ProxyData> QQmlMetaType::proxyData(const QMetaObject *mo,
                                                               const QMetaObject *baseMetaObject,
                                                               QMetaObject *lastMetaObject)