qqmldatablob.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <private/qqmldatablob_p.h>
#include <private/qqmlglobal_p.h>
#include <private/qqmlprofiler_p.h>
#include <private/qqmltypeloader_p.h>
#include <private/qqmltypeloaderthread_p.h>
#include <private/qqmlsourcecoordinate_p.h>
 
#include <QtQml/qqmlengine.h>
 
#include <qtqml_tracepoints_p.h>
 
#ifdef DATABLOB_DEBUG
#define ASSERT_CALLBACK() do { if (!m_typeLoader || !m_typeLoader->m_thread->isThisThread()) qFatal("QQmlDataBlob: An API call was made outside a callback"); } while (false)
#else
#define ASSERT_CALLBACK()
#endif
 
DEFINE_BOOL_CONFIG_OPTION(dumpErrors, QML_DUMP_ERRORS);
 
Q_DECLARE_LOGGING_CATEGORY(lcCycle)
 
QT_BEGIN_NAMESPACE
 
QQmlDataBlob::QQmlDataBlob(const QUrl &url, Type type, QQmlTypeLoader *manager)
: m_typeLoader(manager), m_type(type), m_url(url), m_finalUrl(url), m_redirectCount(0),
  m_inCallback(false), m_isDone(false)
{
    //Set here because we need to get the engine from the manager
    if (const QQmlEngine *qmlEngine = m_typeLoader->engine())
        m_url = qmlEngine->interceptUrl(m_url, (QQmlAbstractUrlInterceptor::DataType)m_type);
}
 
QQmlDataBlob::~QQmlDataBlob()
{
    Q_ASSERT(m_waitingOnMe.isEmpty());
 
    cancelAllWaitingFor();
}
 
void QQmlDataBlob::startLoading()
{
    Q_ASSERT(status() == QQmlDataBlob::Null);
    m_data.setStatus(QQmlDataBlob::Loading);
}
 
QQmlDataBlob::Type QQmlDataBlob::type() const
{
    return m_type;
}
 
QQmlDataBlob::Status QQmlDataBlob::status() const
{
    return m_data.status();
}
 
bool QQmlDataBlob::isNull() const
{
    return status() == Null;
}
 
bool QQmlDataBlob::isLoading() const
{
    return status() == Loading;
}
 
bool QQmlDataBlob::isWaiting() const
{
    return status() == WaitingForDependencies ||
            status() == ResolvingDependencies;
}
 
bool QQmlDataBlob::isComplete() const
{
    return status() == Complete;
}
 
bool QQmlDataBlob::isError() const
{
    return status() == Error;
}
 
bool QQmlDataBlob::isCompleteOrError() const
{
    Status s = status();
    return s == Error || s == Complete;
}
 
qreal QQmlDataBlob::progress() const
{
    quint8 p = m_data.progress();
    if (p == 0xFF) return 1.;
    else return qreal(p) / qreal(0xFF);
}
 
QUrl QQmlDataBlob::url() const
{
    return m_url;
}
 
QString QQmlDataBlob::urlString() const
{
    if (m_urlString.isEmpty())
        m_urlString = m_url.toString();
 
    return m_urlString;
}
 
QUrl QQmlDataBlob::finalUrl() const
{
    return m_finalUrl;
}
 
QString QQmlDataBlob::finalUrlString() const
{
    if (m_finalUrlString.isEmpty())
        m_finalUrlString = m_finalUrl.toString();
 
    return m_finalUrlString;
}
 
QList<QQmlError> QQmlDataBlob::errors() const
{
    Q_ASSERT(isCompleteOrError() || (m_typeLoader && m_typeLoader->m_thread->isThisThread()));
    return m_errors;
}
 
void QQmlDataBlob::setError(const QQmlError &errors)
{
    ASSERT_CALLBACK();
 
    QList<QQmlError> l;
    l << errors;
    setError(l);
}
 
void QQmlDataBlob::setError(const QList<QQmlError> &errors)
{
    ASSERT_CALLBACK();
 
    Q_ASSERT(status() != Error);
    Q_ASSERT(m_errors.isEmpty());
 
    // m_errors must be set before the m_data fence
    m_errors.reserve(errors.size());
    for (const QQmlError &error : errors) {
        if (error.url().isEmpty()) {
            QQmlError mutableError = error;
            mutableError.setUrl(url());
            m_errors.append(mutableError);
        } else {
            m_errors.append(error);
        }
    }
 
    m_data.setStatus(Error);
 
    if (dumpErrors()) {
        qWarning().nospace() << "Errors for " << urlString();
        for (int ii = 0; ii < errors.size(); ++ii)
            qWarning().nospace() << "    " << qPrintable(errors.at(ii).toString());
    }
    cancelAllWaitingFor();
 
    if (!m_inCallback)
        tryDone();
}
 
void QQmlDataBlob::setError(const QQmlJS::DiagnosticMessage &error)
{
    QQmlError e;
    e.setColumn(qmlConvertSourceCoordinate<quint32, int>(error.loc.startColumn));
    e.setLine(qmlConvertSourceCoordinate<quint32, int>(error.loc.startLine));
    e.setDescription(error.message);
    e.setUrl(url());
    setError(e);
}
 
void QQmlDataBlob::setError(const QString &description)
{
    QQmlError e;
    e.setDescription(description);
    e.setUrl(url());
    setError(e);
}
 
void QQmlDataBlob::addDependency(QQmlDataBlob *blob)
{
    ASSERT_CALLBACK();
 
    Q_ASSERT(status() != Null);
 
    if (!blob ||
        blob->status() == Error || blob->status() == Complete ||
        status() == Error || status() == Complete || m_isDone)
        return;
 
    for (const auto &existingDep: std::as_const(m_waitingFor))
        if (existingDep.data() == blob)
            return;
 
    m_data.setStatus(WaitingForDependencies);
 
    m_waitingFor.append(blob);
    blob->m_waitingOnMe.append(this);
 
    // Check circular dependency
    if (m_waitingOnMe.indexOf(blob) >= 0) {
        qCWarning(lcCycle) << "Cyclic dependency detected between" << this->url().toString()
                           << "and" << blob->url().toString();
        m_data.setStatus(Error);
    }
}
 
void QQmlDataBlob::done()
{
}
 
#if QT_CONFIG(qml_network)
void QQmlDataBlob::networkError(QNetworkReply::NetworkError networkError)
{
    Q_UNUSED(networkError);
 
    QQmlError error;
    error.setUrl(m_url);
 
    const char *errorString = nullptr;
    switch (networkError) {
        default:
            errorString = "Network error";
            break;
        case QNetworkReply::ConnectionRefusedError:
            errorString = "Connection refused";
            break;
        case QNetworkReply::RemoteHostClosedError:
            errorString = "Remote host closed the connection";
            break;
        case QNetworkReply::HostNotFoundError:
            errorString = "Host not found";
            break;
        case QNetworkReply::TimeoutError:
            errorString = "Timeout";
            break;
        case QNetworkReply::ProxyConnectionRefusedError:
        case QNetworkReply::ProxyConnectionClosedError:
        case QNetworkReply::ProxyNotFoundError:
        case QNetworkReply::ProxyTimeoutError:
        case QNetworkReply::ProxyAuthenticationRequiredError:
        case QNetworkReply::UnknownProxyError:
            errorString = "Proxy error";
            break;
        case QNetworkReply::ContentAccessDenied:
            errorString = "Access denied";
            break;
        case QNetworkReply::ContentNotFoundError:
            errorString = "File not found";
            break;
        case QNetworkReply::AuthenticationRequiredError:
            errorString = "Authentication required";
            break;
    };
 
    error.setDescription(QLatin1String(errorString));
 
    setError(error);
}
#endif // qml_network
 
void QQmlDataBlob::dependencyError(QQmlDataBlob *blob)
{
    Q_UNUSED(blob);
}
 
void QQmlDataBlob::dependencyComplete(QQmlDataBlob *blob)
{
    Q_UNUSED(blob);
}
 
void QQmlDataBlob::allDependenciesDone()
{
    m_data.setStatus(QQmlDataBlob::ResolvingDependencies);
}
 
void QQmlDataBlob::downloadProgressChanged(qreal progress)
{
    Q_UNUSED(progress);
}
 
void QQmlDataBlob::completed()
{
}
 
 
void QQmlDataBlob::tryDone()
{
    if (status() != Loading && m_waitingFor.isEmpty() && !m_isDone) {
        m_isDone = true;
        addref();
 
#ifdef DATABLOB_DEBUG
        qWarning("QQmlDataBlob::done() %s", qPrintable(urlString()));
#endif
        done();
 
        if (status() != Error)
            m_data.setStatus(Complete);
 
        notifyAllWaitingOnMe();
 
        // Locking is not required here, as anyone expecting callbacks must
        // already be protected against the blob being completed (as set above);
#ifdef DATABLOB_DEBUG
        qWarning("QQmlDataBlob: Dispatching completed");
#endif
        m_typeLoader->m_thread->callCompleted(this);
 
        release();
    }
}
 
void QQmlDataBlob::cancelAllWaitingFor()
{
    while (m_waitingFor.size()) {
        QQmlRefPointer<QQmlDataBlob> blob = m_waitingFor.takeLast();
 
        Q_ASSERT(blob->m_waitingOnMe.contains(this));
 
        blob->m_waitingOnMe.removeOne(this);
    }
}
 
void QQmlDataBlob::notifyAllWaitingOnMe()
{
    while (m_waitingOnMe.size()) {
        QQmlDataBlob *blob = m_waitingOnMe.takeLast();
 
        Q_ASSERT(std::any_of(blob->m_waitingFor.constBegin(), blob->m_waitingFor.constEnd(),
                             [this](const QQmlRefPointer<QQmlDataBlob> &waiting) { return waiting.data() == this; }));
 
        blob->notifyComplete(this);
    }
}
 
void QQmlDataBlob::notifyComplete(QQmlDataBlob *blob)
{
    Q_ASSERT(blob->status() == Error || blob->status() == Complete);
    Q_TRACE_SCOPE(QQmlCompiling, blob->url());
    QQmlCompilingProfiler prof(typeLoader()->profiler(), blob);
 
    m_inCallback = true;
 
    QQmlRefPointer<QQmlDataBlob> blobRef;
    for (int i = 0; i < m_waitingFor.size(); ++i) {
        if (m_waitingFor.at(i).data() == blob) {
            blobRef = m_waitingFor.takeAt(i);
            break;
        }
    }
    Q_ASSERT(blobRef);
 
    if (blob->status() == Error) {
        dependencyError(blob);
    } else if (blob->status() == Complete) {
        dependencyComplete(blob);
    }
 
    if (!isError() && m_waitingFor.isEmpty())
        allDependenciesDone();
 
    m_inCallback = false;
 
    tryDone();
}
 
QString QQmlDataBlob::SourceCodeData::readAll(QString *error) const
{
    error->clear();
    if (hasInlineSourceCode)
        return inlineSourceCode;
 
    QFile f(fileInfo.absoluteFilePath());
    if (!f.open(QIODevice::ReadOnly)) {
        *error = f.errorString();
        return QString();
    }
 
    const qint64 fileSize = fileInfo.size();
 
    if (uchar *mappedData = f.map(0, fileSize)) {
        QString source = QString::fromUtf8(reinterpret_cast<const char *>(mappedData), fileSize);
        f.unmap(mappedData);
        return source;
    }
 
    QByteArray data(fileSize, Qt::Uninitialized);
    if (f.read(data.data(), data.size()) != data.size()) {
        *error = f.errorString();
        return QString();
    }
    return QString::fromUtf8(data);
}
 
QDateTime QQmlDataBlob::SourceCodeData::sourceTimeStamp() const
{
    if (hasInlineSourceCode)
        return QDateTime();
 
    return fileInfo.lastModified();
}
 
bool QQmlDataBlob::SourceCodeData::exists() const
{
    if (hasInlineSourceCode)
        return true;
    return fileInfo.exists();
}
 
bool QQmlDataBlob::SourceCodeData::isEmpty() const
{
    if (hasInlineSourceCode)
        return inlineSourceCode.isEmpty();
    return fileInfo.size() == 0;
}
 
QT_END_NAMESPACE