Merge remote-tracking branch 'origin/5.9' into 5.10

Conflicts:
	src/qml/memory/qv4mm.cpp
	src/qml/memory/qv4mmdefs_p.h
	src/quick/items/qquickwindow.cpp
	src/quick/items/qquickwindow_p.h
	tests/auto/qml/debugger/qqmlprofilerservice/qqmlprofilerservice.pro
	tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp

Change-Id: I7021fa1edf076627a67048f41f7b201220262b09

9 files changed, 201 insertions, 33 deletions

diff --git a/src/qml/qml/qqmldata_p.h b/src/qml/qml/qqmldata_p.h
index d692feb975..63994a392d 100644
--- a/src/qml/qml/qqmldata_p.h
+++ b/src/qml/qml/qqmldata_p.h
@@ -76,6 +76,7 @@ class QQmlNotifierEndpoint;
 namespace QV4 {
 namespace CompiledData {
 struct CompilationUnit;
+struct Binding;
 }
 }
 
@@ -216,12 +217,14 @@ public:
 
     struct DeferredData {
         unsigned int deferredIdx;
+        QMultiHash<int, const QV4::CompiledData::Binding *> bindings;
         QV4::CompiledData::CompilationUnit *compilationUnit;//Not always the same as the other compilation unit
         QQmlContextData *context;//Could be either context or outerContext
     };
     QV4::CompiledData::CompilationUnit *compilationUnit;
     QVector<DeferredData *> deferredData;
 
+    void deferData(int objectIndex, QV4::CompiledData::CompilationUnit *, QQmlContextData *);
     void releaseDeferredData();
 
     QV4::WeakValue jsWrapper;
diff --git a/src/qml/qml/qqmlengine.cpp b/src/qml/qml/qqmlengine.cpp
index f60f148495..20f9b6439d 100644
--- a/src/qml/qml/qqmlengine.cpp
+++ b/src/qml/qml/qqmlengine.cpp
@@ -720,8 +720,11 @@ void QQmlPrivate::qdeclarativeelement_destructor(QObject *o)
 {
     if (QQmlData *d = QQmlData::get(o)) {
         if (d->ownContext) {
-            for (QQmlContextData *lc = d->ownContext->linkedContext; lc; lc = lc->linkedContext)
+            for (QQmlContextData *lc = d->ownContext->linkedContext; lc; lc = lc->linkedContext) {
                 lc->invalidate();
+                if (lc->contextObject == o)
+                    lc->contextObject = nullptr;
+            }
             d->ownContext->invalidate();
             if (d->ownContext->contextObject == o)
                 d->ownContext->contextObject = nullptr;
@@ -1672,13 +1675,40 @@ void QQmlData::NotifyList::layout()
     todo = 0;
 }
 
+void QQmlData::deferData(int objectIndex, QV4::CompiledData::CompilationUnit *compilationUnit, QQmlContextData *context)
+{
+    QQmlData::DeferredData *deferData = new QQmlData::DeferredData;
+    deferData->deferredIdx = objectIndex;
+    deferData->compilationUnit = compilationUnit;
+    deferData->compilationUnit->addref();
+    deferData->context = context;
+
+    const QV4::CompiledData::Object *compiledObject = compilationUnit->objectAt(objectIndex);
+    const QV4::CompiledData::BindingPropertyData &propertyData = compilationUnit->bindingPropertyDataPerObject.at(objectIndex);
+
+    const QV4::CompiledData::Binding *binding = compiledObject->bindingTable();
+    for (quint32 i = 0; i < compiledObject->nBindings; ++i, ++binding) {
+        const QQmlPropertyData *property = propertyData.at(i);
+        if (property && binding->flags & QV4::CompiledData::Binding::IsDeferredBinding)
+            deferData->bindings.insert(property->coreIndex(), binding);
+    }
+
+    deferredData.append(deferData);
+}
+
 void QQmlData::releaseDeferredData()
 {
-    for (DeferredData *deferData : qAsConst(deferredData)) {
-        deferData->compilationUnit->release();
-        delete deferData;
+    auto it = deferredData.begin();
+    while (it != deferredData.end()) {
+        DeferredData *deferData = *it;
+        if (deferData->bindings.isEmpty()) {
+            deferData->compilationUnit->release();
+            delete deferData;
+            it = deferredData.erase(it);
+        } else {
+            ++it;
+        }
     }
-    deferredData.clear();
 }
 
 void QQmlData::addNotify(int index, QQmlNotifierEndpoint *endpoint)
diff --git a/src/qml/qml/qqmlimport.cpp b/src/qml/qml/qqmlimport.cpp
index a7cafa1a93..8b0bd9d6ec 100644
--- a/src/qml/qml/qqmlimport.cpp
+++ b/src/qml/qml/qqmlimport.cpp
@@ -1276,11 +1276,20 @@ bool QQmlImportsPrivate::locateQmldir(const QString &uri, int vmaj, int vmin, QQ
 
     QQmlTypeLoader &typeLoader = QQmlEnginePrivate::get(database->engine)->typeLoader;
 
-    QStringList localImportPaths = database->importPathList(QQmlImportDatabase::Local);
+    // Interceptor might redirect remote files to local ones.
+    QQmlAbstractUrlInterceptor *interceptor = typeLoader.engine()->urlInterceptor();
+    QStringList localImportPaths = database->importPathList(
+                interceptor ? QQmlImportDatabase::LocalOrRemote : QQmlImportDatabase::Local);
 
     // Search local import paths for a matching version
     const QStringList qmlDirPaths = QQmlImports::completeQmldirPaths(uri, localImportPaths, vmaj, vmin);
-    for (const QString &qmldirPath : qmlDirPaths) {
+    for (QString qmldirPath : qmlDirPaths) {
+        if (interceptor) {
+            qmldirPath = QQmlFile::urlToLocalFileOrQrc(
+                        interceptor->intercept(QQmlImports::urlFromLocalFileOrQrcOrUrl(qmldirPath),
+                                               QQmlAbstractUrlInterceptor::QmldirFile));
+        }
+
         QString absoluteFilePath = typeLoader.absoluteFilePath(qmldirPath);
         if (!absoluteFilePath.isEmpty()) {
             QString url;
@@ -1489,6 +1498,10 @@ bool QQmlImportsPrivate::addFileImport(const QString& uri, const QString &prefix
     QString qmldirUrl = resolveLocalUrl(base, importUri + (importUri.endsWith(Slash)
                                                            ? String_qmldir
                                                            : Slash_qmldir));
+    if (QQmlAbstractUrlInterceptor *interceptor = typeLoader->engine()->urlInterceptor()) {
+        qmldirUrl = interceptor->intercept(QUrl(qmldirUrl),
+                                           QQmlAbstractUrlInterceptor::QmldirFile).toString();
+    }
     QString qmldirIdentifier;
 
     if (QQmlFile::isLocalFile(qmldirUrl)) {
@@ -1588,8 +1601,8 @@ bool QQmlImportsPrivate::updateQmldirContent(const QString &uri, const QString &
 
             if (import->setQmldirContent(qmldirUrl, qmldir, nameSpace, errors)) {
                 if (import->qmlDirComponents.isEmpty() && import->qmlDirScripts.isEmpty()) {
-                    // The implicit import qmldir can be empty
-                    if (uri != QLatin1String(".")) {
+                    // The implicit import qmldir can be empty, and plugins have no extra versions
+                    if (uri != QLatin1String(".") && !QQmlMetaType::isModule(uri, vmaj, vmin)) {
                         QQmlError error;
                         if (QQmlMetaType::isAnyModule(uri))
                             error.setDescription(QQmlImportDatabase::tr("module \"%1\" version %2.%3 is not installed").arg(uri).arg(vmaj).arg(vmin));
@@ -1717,6 +1730,16 @@ bool QQmlImports::isLocal(const QUrl &url)
     return !QQmlFile::urlToLocalFileOrQrc(url).isEmpty();
 }
 
+QUrl QQmlImports::urlFromLocalFileOrQrcOrUrl(const QString &file)
+{
+    QUrl url(QLatin1String(file.at(0) == Colon ? "qrc" : "") + file);
+
+    // We don't support single character schemes as those conflict with windows drive letters.
+    if (url.scheme().length() < 2)
+        return QUrl::fromLocalFile(file);
+    return url;
+}
+
 void QQmlImports::setDesignerSupportRequired(bool b)
 {
     designerSupportRequired = b;
diff --git a/src/qml/qml/qqmlimport_p.h b/src/qml/qml/qqmlimport_p.h
index a7b65c1048..6298dd9c22 100644
--- a/src/qml/qml/qqmlimport_p.h
+++ b/src/qml/qml/qqmlimport_p.h
@@ -191,6 +191,7 @@ public:
 
     static bool isLocal(const QString &url);
     static bool isLocal(const QUrl &url);
+    static QUrl urlFromLocalFileOrQrcOrUrl(const QString &);
 
     static void setDesignerSupportRequired(bool b);
 
diff --git a/src/qml/qml/qqmlmetatype.cpp b/src/qml/qml/qqmlmetatype.cpp
index 0f388cf7b7..1e4855f422 100644
--- a/src/qml/qml/qqmlmetatype.cpp
+++ b/src/qml/qml/qqmlmetatype.cpp
@@ -2402,6 +2402,27 @@ QQmlPropertyCache *QQmlMetaType::propertyCache(const QQmlType &type, int minorVe
     return data->propertyCache(type, minorVersion);
 }
 
+void qmlUnregisterType(int typeIndex)
+{
+    QMutexLocker lock(metaTypeDataLock());
+    QQmlMetaTypeData *data = metaTypeData();
+    {
+        const QQmlTypePrivate *d = data->types.value(typeIndex).priv();
+        if (d) {
+            removeQQmlTypePrivate(data->idToType, d);
+            removeQQmlTypePrivate(data->nameToType, d);
+            removeQQmlTypePrivate(data->urlToType, d);
+            removeQQmlTypePrivate(data->urlToNonFileImportType, d);
+            removeQQmlTypePrivate(data->metaObjectToType, d);
+            for (QQmlMetaTypeData::TypeModules::Iterator module = data->uriToModule.begin(); module != data->uriToModule.end(); ++module) {
+                 QQmlTypeModulePrivate *modulePrivate = (*module)->priv();
+                 modulePrivate->remove(d);
+            }
+            data->types[typeIndex] = QQmlType();
+        }
+    }
+}
+
 void QQmlMetaType::freeUnusedTypesAndCaches()
 {
     QMutexLocker lock(metaTypeDataLock());
diff --git a/src/qml/qml/qqmlmetatype_p.h b/src/qml/qml/qqmlmetatype_p.h
index 85ee4d7b97..f381b4a010 100644
--- a/src/qml/qml/qqmlmetatype_p.h
+++ b/src/qml/qml/qqmlmetatype_p.h
@@ -75,6 +75,8 @@ class QQmlCompiledData;
 
 namespace QV4 { struct String; }
 
+void Q_QML_PRIVATE_EXPORT qmlUnregisterType(int type);
+
 class Q_QML_PRIVATE_EXPORT QQmlMetaType
 {
 public:
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index 11fc3ceb44..7761eb4677 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -233,6 +233,7 @@ QObject *QQmlObjectCreator::create(int subComponentIndex, QObject *parent, QQmlI
     return instance;
 }
 
+// ### unify or keep in sync with populateDeferredBinding()
 bool QQmlObjectCreator::populateDeferredProperties(QObject *instance, QQmlData::DeferredData *deferredData)
 {
     QQmlData *declarativeData = QQmlData::get(instance);
@@ -283,6 +284,80 @@ bool QQmlObjectCreator::populateDeferredProperties(QObject *instance, QQmlData::
     qSwap(_qmlContext, qmlContext);
     qSwap(_scopeObject, scopeObject);
 
+    deferredData->bindings.clear();
+    phase = ObjectsCreated;
+
+    return errors.isEmpty();
+}
+
+// ### unify or keep in sync with populateDeferredProperties()
+bool QQmlObjectCreator::populateDeferredBinding(const QQmlProperty &qmlProperty, QQmlData::DeferredData *deferredData, const QV4::CompiledData::Binding *binding)
+{
+    Q_ASSERT(binding->flags & QV4::CompiledData::Binding::IsDeferredBinding);
+
+    QObject *instance = qmlProperty.object();
+    QQmlData *declarativeData = QQmlData::get(instance);
+    context = deferredData->context;
+    sharedState->rootContext = context;
+
+    QObject *bindingTarget = instance;
+
+    QQmlRefPointer<QQmlPropertyCache> cache = declarativeData->propertyCache;
+    QQmlVMEMetaObject *vmeMetaObject = QQmlVMEMetaObject::get(instance);
+
+    QObject *scopeObject = instance;
+    qSwap(_scopeObject, scopeObject);
+
+    QV4::Scope valueScope(v4);
+
+    Q_ASSERT(topLevelCreator);
+    if (!sharedState->allJavaScriptObjects)
+        sharedState->allJavaScriptObjects = valueScope.alloc(compilationUnit->totalObjectCount);
+
+    QV4::QmlContext *qmlContext = static_cast<QV4::QmlContext *>(valueScope.alloc(1));
+
+    qSwap(_qmlContext, qmlContext);
+
+    qSwap(_propertyCache, cache);
+    qSwap(_qobject, instance);
+
+    int objectIndex = deferredData->deferredIdx;
+    qSwap(_compiledObjectIndex, objectIndex);
+
+    const QV4::CompiledData::Object *obj = qmlUnit->objectAt(_compiledObjectIndex);
+    qSwap(_compiledObject, obj);
+
+    qSwap(_ddata, declarativeData);
+    qSwap(_bindingTarget, bindingTarget);
+    qSwap(_vmeMetaObject, vmeMetaObject);
+
+    QQmlListProperty<void> savedList;
+    qSwap(_currentList, savedList);
+
+    const QQmlPropertyData &property = QQmlPropertyPrivate::get(qmlProperty)->core;
+
+    if (property.isQList()) {
+        void *argv[1] = { (void*)&_currentList };
+        QMetaObject::metacall(_qobject, QMetaObject::ReadProperty, property.coreIndex(), argv);
+    } else if (_currentList.object) {
+        _currentList = QQmlListProperty<void>();
+    }
+
+    setPropertyBinding(&property, binding);
+
+    qSwap(_currentList, savedList);
+
+    qSwap(_vmeMetaObject, vmeMetaObject);
+    qSwap(_bindingTarget, bindingTarget);
+    qSwap(_ddata, declarativeData);
+    qSwap(_compiledObject, obj);
+    qSwap(_compiledObjectIndex, objectIndex);
+    qSwap(_qobject, instance);
+    qSwap(_propertyCache, cache);
+
+    qSwap(_qmlContext, qmlContext);
+    qSwap(_scopeObject, scopeObject);
+
     phase = ObjectsCreated;
 
     return errors.isEmpty();
@@ -1342,14 +1417,8 @@ bool QQmlObjectCreator::populateInstance(int index, QObject *instance, QObject *
     qSwap(_propertyCache, cache);
     qSwap(_vmeMetaObject, vmeMetaObject);
 
-    if (_compiledObject->flags & QV4::CompiledData::Object::HasDeferredBindings) {
-        QQmlData::DeferredData *deferData = new QQmlData::DeferredData;
-        deferData->deferredIdx = _compiledObjectIndex;
-        deferData->compilationUnit = compilationUnit;
-        deferData->compilationUnit->addref();
-        deferData->context = context;
-        _ddata->deferredData.append(deferData);
-    }
+    if (_compiledObject->flags & QV4::CompiledData::Object::HasDeferredBindings)
+        _ddata->deferData(_compiledObjectIndex, compilationUnit, context);
 
     if (_compiledObject->nFunctions > 0)
         setupFunctions();
diff --git a/src/qml/qml/qqmlobjectcreator_p.h b/src/qml/qml/qqmlobjectcreator_p.h
index aa0165ec06..593d89e5d5 100644
--- a/src/qml/qml/qqmlobjectcreator_p.h
+++ b/src/qml/qml/qqmlobjectcreator_p.h
@@ -81,7 +81,7 @@ struct QQmlObjectCreatorSharedState : public QSharedData
     QRecursionNode recursionNode;
 };
 
-class QQmlObjectCreator
+class Q_QML_PRIVATE_EXPORT QQmlObjectCreator
 {
     Q_DECLARE_TR_FUNCTIONS(QQmlObjectCreator)
 public:
@@ -90,6 +90,7 @@ public:
 
     QObject *create(int subComponentIndex = -1, QObject *parent = 0, QQmlInstantiationInterrupt *interrupt = 0);
     bool populateDeferredProperties(QObject *instance, QQmlData::DeferredData *deferredData);
+    bool populateDeferredBinding(const QQmlProperty &qmlProperty, QQmlData::DeferredData *deferredData, const QV4::CompiledData::Binding *binding);
     QQmlContextData *finalize(QQmlInstantiationInterrupt &interrupt);
     void cancel(QObject *object);
     void clear();
diff --git a/src/qml/qml/qqmltypeloader.cpp b/src/qml/qml/qqmltypeloader.cpp
index 128e37d51b..a4db62eebf 100644
--- a/src/qml/qml/qqmltypeloader.cpp
+++ b/src/qml/qml/qqmltypeloader.cpp
@@ -1436,8 +1436,13 @@ bool QQmlTypeLoader::Blob::addImport(const QV4::CompiledData::Import *import, QL
                 // We haven't yet resolved this import
                 m_unresolvedImports.insert(import, 0);
 
-                // Query any network import paths for this library
-                QStringList remotePathList = importDatabase->importPathList(QQmlImportDatabase::Remote);
+                QQmlAbstractUrlInterceptor *interceptor = typeLoader()->engine()->urlInterceptor();
+
+                // Query any network import paths for this library.
+                // Interceptor might redirect local paths.
+                QStringList remotePathList = importDatabase->importPathList(
+                            interceptor ? QQmlImportDatabase::LocalOrRemote
+                                        : QQmlImportDatabase::Remote);
                 if (!remotePathList.isEmpty()) {
                     // Add this library and request the possible locations for it
                     if (!m_importCache.addLibraryImport(importDatabase, importUri, importQualifier, import->majorVersion,
@@ -1448,8 +1453,18 @@ bool QQmlTypeLoader::Blob::addImport(const QV4::CompiledData::Import *import, QL
                     int priority = 0;
                     const QStringList qmlDirPaths = QQmlImports::completeQmldirPaths(importUri, remotePathList, import->majorVersion, import->minorVersion);
                     for (const QString &qmldirPath : qmlDirPaths) {
-                        if (!fetchQmldir(QUrl(qmldirPath), import, ++priority, errors))
+                        if (interceptor) {
+                            QUrl url = interceptor->intercept(
+                                        QQmlImports::urlFromLocalFileOrQrcOrUrl(qmldirPath),
+                                        QQmlAbstractUrlInterceptor::QmldirFile);
+                            if (!QQmlFile::isLocalFile(url)
+                                    && !fetchQmldir(url, import, ++priority, errors)) {
+                                return false;
+                            }
+                        } else if (!fetchQmldir(QUrl(qmldirPath), import, ++priority, errors)) {
                             return false;
+                        }
+
                     }
                 }
             }
@@ -1872,19 +1887,22 @@ It can also be a remote path for a remote directory import, but it will have bee
 */
 const QQmlTypeLoaderQmldirContent *QQmlTypeLoader::qmldirContent(const QString &filePathIn)
 {
-    QUrl url(filePathIn); //May already contain http scheme
-    if (url.scheme() == QLatin1String("http") || url.scheme() == QLatin1String("https"))
-        return *(m_importQmlDirCache.value(filePathIn)); //Can't load the remote here, but should be cached
-    else
-        url = QUrl::fromLocalFile(filePathIn);
-    if (engine() && engine()->urlInterceptor())
-        url = engine()->urlInterceptor()->intercept(url, QQmlAbstractUrlInterceptor::QmldirFile);
-    Q_ASSERT(url.scheme() == QLatin1String("file"));
     QString filePath;
-    if (url.scheme() == QLatin1String("file"))
-        filePath = url.toLocalFile();
-    else
-        filePath = url.path();
+
+    // Try to guess if filePathIn is already a URL. This is necessarily fragile, because
+    // - paths can contain ':', which might make them appear as URLs with schemes.
+    // - windows drive letters appear as schemes (thus "< 2" below).
+    // - a "file:" URL is equivalent to the respective file, but will be treated differently.
+    // Yet, this heuristic is the best we can do until we pass more structured information here,
+    // for example a QUrl also for local files.
+    QUrl url(filePathIn);
+    if (url.scheme().length() < 2) {
+        filePath = filePathIn;
+    } else {
+        filePath = QQmlFile::urlToLocalFileOrQrc(url);
+        if (filePath.isEmpty()) // Can't load the remote here, but should be cached
+            return *(m_importQmlDirCache.value(filePathIn));
+    }
 
     QQmlTypeLoaderQmldirContent *qmldir;
     QQmlTypeLoaderQmldirContent **val = m_importQmlDirCache.value(filePath);