Defer loading of local qmldir files when intercepted to remote ones

The qqmltypeloader test checks this case. As long as the types are
actually loaded by the plugin it worked as we didn't register the
module before. When the types are loaded by static type registrations
in QtQuick we need to detect whether we still need to wait for a
remote qmldir file to appear in order to load color providers etc.

Change-Id: I7aa10903c6c23d1c9be01ee7ddafbdc696975407
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

3 files changed, 49 insertions, 32 deletions

diff --git a/src/qml/qml/qqmlimport.cpp b/src/qml/qml/qqmlimport.cpp
index 21ca24d38b..3176200629 100644
--- a/src/qml/qml/qqmlimport.cpp
+++ b/src/qml/qml/qqmlimport.cpp
@@ -245,9 +245,9 @@ public:
 
     QQmlTypeLoader *typeLoader;
 
-    static bool locateQmldir(const QString &uri, int vmaj, int vmin,
-                             QQmlImportDatabase *database,
-                             QString *outQmldirFilePath, QString *outUrl);
+    static QQmlImports::LocalQmldirResult locateLocalQmldir(
+            const QString &uri, int vmaj, int vmin, QQmlImportDatabase *database,
+            QString *outQmldirFilePath, QString *outUrl);
 
     static bool validateQmldirVersion(const QQmlTypeLoaderQmldirContent &qmldir, const QString &uri, int vmaj, int vmin,
                                       QList<QQmlError> *errors);
@@ -1237,8 +1237,9 @@ Locates the qmldir file for \a uri version \a vmaj.vmin.  Returns true if found,
 and fills in outQmldirFilePath and outQmldirUrl appropriately.  Otherwise returns
 false.
 */
-bool QQmlImportsPrivate::locateQmldir(const QString &uri, int vmaj, int vmin, QQmlImportDatabase *database,
-                                      QString *outQmldirFilePath, QString *outQmldirPathUrl)
+QQmlImports::LocalQmldirResult QQmlImportsPrivate::locateLocalQmldir(
+        const QString &uri, int vmaj, int vmin, QQmlImportDatabase *database,
+        QString *outQmldirFilePath, QString *outQmldirPathUrl)
 {
     Q_ASSERT(vmaj >= 0 && vmin >= 0); // Versions are always specified for libraries
 
@@ -1246,20 +1247,21 @@ bool QQmlImportsPrivate::locateQmldir(const QString &uri, int vmaj, int vmin, QQ
 
     QQmlImportDatabase::QmldirCache *cacheHead = nullptr;
     {
-    QQmlImportDatabase::QmldirCache **cachePtr = database->qmldirCache.value(uri);
-    if (cachePtr) {
-        cacheHead = *cachePtr;
-        QQmlImportDatabase::QmldirCache *cache = cacheHead;
-        while (cache) {
-            if (cache->versionMajor == vmaj && cache->versionMinor == vmin) {
-                *outQmldirFilePath = cache->qmldirFilePath;
-                *outQmldirPathUrl = cache->qmldirPathUrl;
-                return !cache->qmldirFilePath.isEmpty();
+        QQmlImportDatabase::QmldirCache **cachePtr = database->qmldirCache.value(uri);
+        if (cachePtr) {
+            cacheHead = *cachePtr;
+            QQmlImportDatabase::QmldirCache *cache = cacheHead;
+            while (cache) {
+                if (cache->versionMajor == vmaj && cache->versionMinor == vmin) {
+                    *outQmldirFilePath = cache->qmldirFilePath;
+                    *outQmldirPathUrl = cache->qmldirPathUrl;
+                    return cache->qmldirFilePath.isEmpty() ? QQmlImports::QmldirNotFound
+                                                           : QQmlImports::QmldirFound;
+                }
+                cache = cache->next;
             }
-            cache = cache->next;
         }
     }
-    }
 
     QQmlTypeLoader &typeLoader = QQmlEnginePrivate::get(database->engine)->typeLoader;
 
@@ -1269,12 +1271,17 @@ bool QQmlImportsPrivate::locateQmldir(const QString &uri, int vmaj, int vmin, QQ
                 interceptor ? QQmlImportDatabase::LocalOrRemote : QQmlImportDatabase::Local);
 
     // Search local import paths for a matching version
-    const QStringList qmlDirPaths = QQmlImports::completeQmldirPaths(uri, localImportPaths, vmaj, vmin);
+    const QStringList qmlDirPaths = QQmlImports::completeQmldirPaths(
+                uri, localImportPaths, vmaj, vmin);
+    bool pathTurnedRemote = false;
     for (QString qmldirPath : qmlDirPaths) {
         if (interceptor) {
-            qmldirPath = QQmlFile::urlToLocalFileOrQrc(
-                        interceptor->intercept(QQmlImports::urlFromLocalFileOrQrcOrUrl(qmldirPath),
-                                               QQmlAbstractUrlInterceptor::QmldirFile));
+            const QUrl intercepted = interceptor->intercept(
+                        QQmlImports::urlFromLocalFileOrQrcOrUrl(qmldirPath),
+                        QQmlAbstractUrlInterceptor::QmldirFile);
+            qmldirPath = QQmlFile::urlToLocalFileOrQrc(intercepted);
+            if (!pathTurnedRemote && qmldirPath.isEmpty() && !QQmlFile::isLocalFile(intercepted))
+                pathTurnedRemote = true;
         }
 
         QString absoluteFilePath = typeLoader.absoluteFilePath(qmldirPath);
@@ -1297,7 +1304,7 @@ bool QQmlImportsPrivate::locateQmldir(const QString &uri, int vmaj, int vmin, QQ
             *outQmldirFilePath = absoluteFilePath;
             *outQmldirPathUrl = url;
 
-            return true;
+            return QQmlImports::QmldirFound;
         }
     }
 
@@ -1307,7 +1314,7 @@ bool QQmlImportsPrivate::locateQmldir(const QString &uri, int vmaj, int vmin, QQ
     cache->next = cacheHead;
     database->qmldirCache.insert(uri, cache);
 
-    return false;
+    return pathTurnedRemote ? QQmlImports::QmldirInterceptedToRemote : QQmlImports::QmldirNotFound;
 }
 
 bool QQmlImportsPrivate::validateQmldirVersion(const QQmlTypeLoaderQmldirContent &qmldir, const QString &uri, int vmaj, int vmin,
@@ -1701,11 +1708,11 @@ bool QQmlImports::updateQmldirContent(QQmlImportDatabase *importDb,
     return d->updateQmldirContent(uri, prefix, qmldirIdentifier, qmldirUrl, importDb, errors);
 }
 
-bool QQmlImports::locateQmldir(QQmlImportDatabase *importDb,
-                               const QString& uri, int vmaj, int vmin,
-                               QString *qmldirFilePath, QString *url)
+QQmlImports::LocalQmldirResult QQmlImports::locateLocalQmldir(
+        QQmlImportDatabase *importDb, const QString &uri, int vmaj,  int vmin,
+        QString *qmldirFilePath, QString *url)
 {
-    return d->locateQmldir(uri, vmaj, vmin, importDb, qmldirFilePath, url);
+    return d->locateLocalQmldir(uri, vmaj, vmin, importDb, qmldirFilePath, url);
 }
 
 bool QQmlImports::isLocal(const QString &url)
diff --git a/src/qml/qml/qqmlimport_p.h b/src/qml/qml/qqmlimport_p.h
index 7cf1ae61b9..1f44b22deb 100644
--- a/src/qml/qml/qqmlimport_p.h
+++ b/src/qml/qml/qqmlimport_p.h
@@ -163,9 +163,15 @@ public:
                              const QString &uri, const QString &prefix,
                              const QString &qmldirIdentifier, const QString &qmldirUrl, QList<QQmlError> *errors);
 
-    bool locateQmldir(QQmlImportDatabase *,
-                      const QString &uri, int vmaj, int vmin,
-                      QString *qmldirFilePath, QString *url);
+    enum LocalQmldirResult {
+        QmldirFound,
+        QmldirNotFound,
+        QmldirInterceptedToRemote
+    };
+
+    LocalQmldirResult locateLocalQmldir(
+            QQmlImportDatabase *, const QString &uri, int vmaj, int vmin,
+            QString *qmldirFilePath, QString *url);
 
     void populateCache(QQmlTypeNameCache *cache) const;
 
diff --git a/src/qml/qml/qqmltypeloader.cpp b/src/qml/qml/qqmltypeloader.cpp
index 989c3fe4b0..2de158884b 100644
--- a/src/qml/qml/qqmltypeloader.cpp
+++ b/src/qml/qml/qqmltypeloader.cpp
@@ -577,8 +577,10 @@ bool QQmlTypeLoader::Blob::addImport(QQmlTypeLoader::Blob::PendingImportPtr impo
         QString qmldirFilePath;
         QString qmldirUrl;
 
-        if (m_importCache.locateQmldir(importDatabase, import->uri, import->majorVersion, import->minorVersion,
-                                 &qmldirFilePath, &qmldirUrl)) {
+        const QQmlImports::LocalQmldirResult qmldirResult = m_importCache.locateLocalQmldir(
+                    importDatabase, import->uri, import->majorVersion, import->minorVersion,
+                    &qmldirFilePath, &qmldirUrl);
+        if (qmldirResult == QQmlImports::QmldirFound) {
             // This is a local library import
             if (!m_importCache.addLibraryImport(importDatabase, import->uri, import->qualifier, import->majorVersion,
                                           import->minorVersion, qmldirFilePath, qmldirUrl, false, errors))
@@ -603,7 +605,9 @@ bool QQmlTypeLoader::Blob::addImport(QQmlTypeLoader::Blob::PendingImportPtr impo
         } else {
             // Is this a module?
             if (QQmlMetaType::isAnyModule(import->uri)
-                    || QQmlMetaType::qmlRegisterModuleTypes(import->uri, import->majorVersion)) {
+                    || (qmldirResult != QQmlImports::QmldirInterceptedToRemote
+                        && QQmlMetaType::qmlRegisterModuleTypes(import->uri,
+                                                                import->majorVersion))) {
                 if (!m_importCache.addLibraryImport(importDatabase, import->uri, import->qualifier, import->majorVersion,
                                               import->minorVersion, QString(), QString(), false, errors))
                     return false;