Expand QSL and QBL

So they don't leak into the public API

35 files changed, 1094 insertions, 1097 deletions

diff --git a/src/base/QXmppArchiveIq.cpp b/src/base/QXmppArchiveIq.cpp
index 38fdde2b..f3f73597 100644
--- a/src/base/QXmppArchiveIq.cpp
+++ b/src/base/QXmppArchiveIq.cpp
@@ -88,22 +88,22 @@ QXmppArchiveChat::QXmppArchiveChat()
 /// \cond
 void QXmppArchiveChat::parse(const QDomElement &element)
 {
-    m_with = element.attribute(QSL("with"));
-    m_start = QXmppUtils::datetimeFromString(element.attribute(QSL("start")));
-    m_subject = element.attribute(QSL("subject"));
-    m_thread = element.attribute(QSL("thread"));
-    m_version = element.attribute(QSL("version")).toInt();
+    m_with = element.attribute(QStringLiteral("with"));
+    m_start = QXmppUtils::datetimeFromString(element.attribute(QStringLiteral("start")));
+    m_subject = element.attribute(QStringLiteral("subject"));
+    m_thread = element.attribute(QStringLiteral("thread"));
+    m_version = element.attribute(QStringLiteral("version")).toInt();
 
     QDateTime timeAccu = m_start;
 
     QDomElement child = element.firstChildElement();
     while (!child.isNull()) {
-        if ((child.tagName() == QSL("from")) || (child.tagName() == QSL("to"))) {
+        if ((child.tagName() == QStringLiteral("from")) || (child.tagName() == QStringLiteral("to"))) {
             QXmppArchiveMessage message;
-            message.setBody(child.firstChildElement(QSL("body")).text());
-            timeAccu = timeAccu.addSecs(child.attribute(QSL("secs")).toInt());
+            message.setBody(child.firstChildElement(QStringLiteral("body")).text());
+            timeAccu = timeAccu.addSecs(child.attribute(QStringLiteral("secs")).toInt());
             message.setDate(timeAccu);
-            message.setReceived(child.tagName() == QSL("from"));
+            message.setReceived(child.tagName() == QStringLiteral("from"));
             m_messages << message;
         }
         child = child.nextSiblingElement();
@@ -112,22 +112,22 @@ void QXmppArchiveChat::parse(const QDomElement &element)
 
 void QXmppArchiveChat::toXml(QXmlStreamWriter *writer, const QXmppResultSetReply &rsm) const
 {
-    writer->writeStartElement(QSL("chat"));
+    writer->writeStartElement(QStringLiteral("chat"));
     writer->writeDefaultNamespace(ns_archive);
-    helperToXmlAddAttribute(writer, QSL("with"), m_with);
+    helperToXmlAddAttribute(writer, QStringLiteral("with"), m_with);
     if (m_start.isValid())
-        helperToXmlAddAttribute(writer, QSL("start"), QXmppUtils::datetimeToString(m_start));
-    helperToXmlAddAttribute(writer, QSL("subject"), m_subject);
-    helperToXmlAddAttribute(writer, QSL("thread"), m_thread);
+        helperToXmlAddAttribute(writer, QStringLiteral("start"), QXmppUtils::datetimeToString(m_start));
+    helperToXmlAddAttribute(writer, QStringLiteral("subject"), m_subject);
+    helperToXmlAddAttribute(writer, QStringLiteral("thread"), m_thread);
     if (m_version)
-        helperToXmlAddAttribute(writer, QSL("version"), QString::number(m_version));
+        helperToXmlAddAttribute(writer, QStringLiteral("version"), QString::number(m_version));
 
     QDateTime prevTime = m_start;
 
     for (const QXmppArchiveMessage &message : m_messages) {
-        writer->writeStartElement(message.isReceived() ? QSL("from") : QSL("to"));
-        helperToXmlAddAttribute(writer, QSL("secs"), QString::number(prevTime.secsTo(message.date())));
-        writer->writeTextElement(QSL("body"), message.body());
+        writer->writeStartElement(message.isReceived() ? QStringLiteral("from") : QStringLiteral("to"));
+        helperToXmlAddAttribute(writer, QStringLiteral("secs"), QString::number(prevTime.secsTo(message.date())));
+        writer->writeTextElement(QStringLiteral("body"), message.body());
         writer->writeEndElement();
         prevTime = message.date();
     }
@@ -256,14 +256,14 @@ void QXmppArchiveChatIq::setResultSetReply(const QXmppResultSetReply &rsm)
 /// \cond
 bool QXmppArchiveChatIq::isArchiveChatIq(const QDomElement &element)
 {
-    QDomElement chatElement = element.firstChildElement(QSL("chat"));
-    return !chatElement.attribute(QSL("with")).isEmpty();
+    QDomElement chatElement = element.firstChildElement(QStringLiteral("chat"));
+    return !chatElement.attribute(QStringLiteral("with")).isEmpty();
     //return (chatElement.namespaceURI() == ns_archive);
 }
 
 void QXmppArchiveChatIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement chatElement = element.firstChildElement(QSL("chat"));
+    QDomElement chatElement = element.firstChildElement(QStringLiteral("chat"));
     m_chat.parse(chatElement);
     m_rsmReply.parse(chatElement);
 }
@@ -385,23 +385,23 @@ void QXmppArchiveListIq::setResultSetReply(const QXmppResultSetReply &rsm)
 /// \cond
 bool QXmppArchiveListIq::isArchiveListIq(const QDomElement &element)
 {
-    QDomElement listElement = element.firstChildElement(QSL("list"));
+    QDomElement listElement = element.firstChildElement(QStringLiteral("list"));
     return (listElement.namespaceURI() == ns_archive);
 }
 
 void QXmppArchiveListIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement listElement = element.firstChildElement(QSL("list"));
-    m_with = listElement.attribute(QSL("with"));
-    m_start = QXmppUtils::datetimeFromString(listElement.attribute(QSL("start")));
-    m_end = QXmppUtils::datetimeFromString(listElement.attribute(QSL("end")));
+    QDomElement listElement = element.firstChildElement(QStringLiteral("list"));
+    m_with = listElement.attribute(QStringLiteral("with"));
+    m_start = QXmppUtils::datetimeFromString(listElement.attribute(QStringLiteral("start")));
+    m_end = QXmppUtils::datetimeFromString(listElement.attribute(QStringLiteral("end")));
 
     m_rsmQuery.parse(listElement);
     m_rsmReply.parse(listElement);
 
     QDomElement child = listElement.firstChildElement();
     while (!child.isNull()) {
-        if (child.tagName() == QSL("chat")) {
+        if (child.tagName() == QStringLiteral("chat")) {
             QXmppArchiveChat chat;
             chat.parse(child);
             m_chats << chat;
@@ -412,14 +412,14 @@ void QXmppArchiveListIq::parseElementFromChild(const QDomElement &element)
 
 void QXmppArchiveListIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("list"));
+    writer->writeStartElement(QStringLiteral("list"));
     writer->writeDefaultNamespace(ns_archive);
     if (!m_with.isEmpty())
-        helperToXmlAddAttribute(writer, QSL("with"), m_with);
+        helperToXmlAddAttribute(writer, QStringLiteral("with"), m_with);
     if (m_start.isValid())
-        helperToXmlAddAttribute(writer, QSL("start"), QXmppUtils::datetimeToString(m_start));
+        helperToXmlAddAttribute(writer, QStringLiteral("start"), QXmppUtils::datetimeToString(m_start));
     if (m_end.isValid())
-        helperToXmlAddAttribute(writer, QSL("end"), QXmppUtils::datetimeToString(m_end));
+        helperToXmlAddAttribute(writer, QStringLiteral("end"), QXmppUtils::datetimeToString(m_end));
     if (!m_rsmQuery.isNull())
         m_rsmQuery.toXml(writer);
     else if (!m_rsmReply.isNull())
@@ -431,19 +431,19 @@ void QXmppArchiveListIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 
 bool QXmppArchivePrefIq::isArchivePrefIq(const QDomElement &element)
 {
-    QDomElement prefElement = element.firstChildElement(QSL("pref"));
+    QDomElement prefElement = element.firstChildElement(QStringLiteral("pref"));
     return (prefElement.namespaceURI() == ns_archive);
 }
 
 void QXmppArchivePrefIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("pref"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("pref"));
     Q_UNUSED(queryElement);
 }
 
 void QXmppArchivePrefIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("pref"));
+    writer->writeStartElement(QStringLiteral("pref"));
     writer->writeDefaultNamespace(ns_archive);
     writer->writeEndElement();
 }
@@ -503,28 +503,28 @@ void QXmppArchiveRemoveIq::setEnd(const QDateTime &end)
 /// \cond
 bool QXmppArchiveRemoveIq::isArchiveRemoveIq(const QDomElement &element)
 {
-    QDomElement retrieveElement = element.firstChildElement(QSL("remove"));
+    QDomElement retrieveElement = element.firstChildElement(QStringLiteral("remove"));
     return (retrieveElement.namespaceURI() == ns_archive);
 }
 
 void QXmppArchiveRemoveIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement listElement = element.firstChildElement(QSL("remove"));
-    m_with = listElement.attribute(QSL("with"));
-    m_start = QXmppUtils::datetimeFromString(listElement.attribute(QSL("start")));
-    m_end = QXmppUtils::datetimeFromString(listElement.attribute(QSL("end")));
+    QDomElement listElement = element.firstChildElement(QStringLiteral("remove"));
+    m_with = listElement.attribute(QStringLiteral("with"));
+    m_start = QXmppUtils::datetimeFromString(listElement.attribute(QStringLiteral("start")));
+    m_end = QXmppUtils::datetimeFromString(listElement.attribute(QStringLiteral("end")));
 }
 
 void QXmppArchiveRemoveIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("remove"));
+    writer->writeStartElement(QStringLiteral("remove"));
     writer->writeDefaultNamespace(ns_archive);
     if (!m_with.isEmpty())
-        helperToXmlAddAttribute(writer, QSL("with"), m_with);
+        helperToXmlAddAttribute(writer, QStringLiteral("with"), m_with);
     if (m_start.isValid())
-        helperToXmlAddAttribute(writer, QSL("start"), QXmppUtils::datetimeToString(m_start));
+        helperToXmlAddAttribute(writer, QStringLiteral("start"), QXmppUtils::datetimeToString(m_start));
     if (m_end.isValid())
-        helperToXmlAddAttribute(writer, QSL("end"), QXmppUtils::datetimeToString(m_end));
+        helperToXmlAddAttribute(writer, QStringLiteral("end"), QXmppUtils::datetimeToString(m_end));
     writer->writeEndElement();
 }
 /// \endcond
@@ -589,25 +589,25 @@ void QXmppArchiveRetrieveIq::setResultSetQuery(const QXmppResultSetQuery &rsm)
 /// \cond
 bool QXmppArchiveRetrieveIq::isArchiveRetrieveIq(const QDomElement &element)
 {
-    QDomElement retrieveElement = element.firstChildElement(QSL("retrieve"));
+    QDomElement retrieveElement = element.firstChildElement(QStringLiteral("retrieve"));
     return (retrieveElement.namespaceURI() == ns_archive);
 }
 
 void QXmppArchiveRetrieveIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement retrieveElement = element.firstChildElement(QSL("retrieve"));
-    m_with = retrieveElement.attribute(QSL("with"));
-    m_start = QXmppUtils::datetimeFromString(retrieveElement.attribute(QSL("start")));
+    QDomElement retrieveElement = element.firstChildElement(QStringLiteral("retrieve"));
+    m_with = retrieveElement.attribute(QStringLiteral("with"));
+    m_start = QXmppUtils::datetimeFromString(retrieveElement.attribute(QStringLiteral("start")));
 
     m_rsmQuery.parse(retrieveElement);
 }
 
 void QXmppArchiveRetrieveIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("retrieve"));
+    writer->writeStartElement(QStringLiteral("retrieve"));
     writer->writeDefaultNamespace(ns_archive);
-    helperToXmlAddAttribute(writer, QSL("with"), m_with);
-    helperToXmlAddAttribute(writer, QSL("start"), QXmppUtils::datetimeToString(m_start));
+    helperToXmlAddAttribute(writer, QStringLiteral("with"), m_with);
+    helperToXmlAddAttribute(writer, QStringLiteral("start"), QXmppUtils::datetimeToString(m_start));
     if (!m_rsmQuery.isNull())
         m_rsmQuery.toXml(writer);
     writer->writeEndElement();
diff --git a/src/base/QXmppBindIq.cpp b/src/base/QXmppBindIq.cpp
index 20d89074..6d86e719 100644
--- a/src/base/QXmppBindIq.cpp
+++ b/src/base/QXmppBindIq.cpp
@@ -68,25 +68,25 @@ void QXmppBindIq::setResource(const QString &resource)
 /// \cond
 bool QXmppBindIq::isBindIq(const QDomElement &element)
 {
-    QDomElement bindElement = element.firstChildElement(QSL("bind"));
+    QDomElement bindElement = element.firstChildElement(QStringLiteral("bind"));
     return (bindElement.namespaceURI() == ns_bind);
 }
 
 void QXmppBindIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement bindElement = element.firstChildElement(QSL("bind"));
-    m_jid = bindElement.firstChildElement(QSL("jid")).text();
-    m_resource = bindElement.firstChildElement(QSL("resource")).text();
+    QDomElement bindElement = element.firstChildElement(QStringLiteral("bind"));
+    m_jid = bindElement.firstChildElement(QStringLiteral("jid")).text();
+    m_resource = bindElement.firstChildElement(QStringLiteral("resource")).text();
 }
 
 void QXmppBindIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("bind"));
+    writer->writeStartElement(QStringLiteral("bind"));
     writer->writeDefaultNamespace(ns_bind);
     if (!m_jid.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("jid"), m_jid);
+        helperToXmlAddTextElement(writer, QStringLiteral("jid"), m_jid);
     if (!m_resource.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("resource"), m_resource);
+        helperToXmlAddTextElement(writer, QStringLiteral("resource"), m_resource);
     writer->writeEndElement();
 }
 /// \endcond
diff --git a/src/base/QXmppBitsOfBinaryContentId.cpp b/src/base/QXmppBitsOfBinaryContentId.cpp
index f55f3439..630e59a7 100644
--- a/src/base/QXmppBitsOfBinaryContentId.cpp
+++ b/src/base/QXmppBitsOfBinaryContentId.cpp
@@ -27,25 +27,25 @@
 #include <QSharedData>
 #include <QString>
 
-#define CONTENTID_URL QSL("cid:")
+#define CONTENTID_URL QStringLiteral("cid:")
 #define CONTENTID_URL_LENGTH 4
-#define CONTENTID_POSTFIX QSL("@bob.xmpp.org")
+#define CONTENTID_POSTFIX QStringLiteral("@bob.xmpp.org")
 #define CONTENTID_POSTFIX_LENGTH 13
-#define CONTENTID_HASH_SEPARATOR QSL("+")
+#define CONTENTID_HASH_SEPARATOR QStringLiteral("+")
 
 static const QMap<QCryptographicHash::Algorithm, QString> HASH_ALGORITHMS = {
-    { QCryptographicHash::Sha1, QSL("sha1") },
+    { QCryptographicHash::Sha1, QStringLiteral("sha1") },
 #ifndef QT_CRYPTOGRAPHICHASH_ONLY_SHA1
-    { QCryptographicHash::Md4, QSL("md4") },
-    { QCryptographicHash::Md5, QSL("md5") },
-    { QCryptographicHash::Sha224, QSL("sha224") },
-    { QCryptographicHash::Sha256, QSL("sha256") },
-    { QCryptographicHash::Sha384, QSL("sha384") },
-    { QCryptographicHash::Sha512, QSL("sha512") },
-    { QCryptographicHash::Sha3_224, QSL("sha3-224") },
-    { QCryptographicHash::Sha3_256, QSL("sha3-256") },
-    { QCryptographicHash::Sha3_384, QSL("sha3-384") },
-    { QCryptographicHash::Sha3_512, QSL("sha3-512") },
+    { QCryptographicHash::Md4, QStringLiteral("md4") },
+    { QCryptographicHash::Md5, QStringLiteral("md5") },
+    { QCryptographicHash::Sha224, QStringLiteral("sha224") },
+    { QCryptographicHash::Sha256, QStringLiteral("sha256") },
+    { QCryptographicHash::Sha384, QStringLiteral("sha384") },
+    { QCryptographicHash::Sha512, QStringLiteral("sha512") },
+    { QCryptographicHash::Sha3_224, QStringLiteral("sha3-224") },
+    { QCryptographicHash::Sha3_256, QStringLiteral("sha3-256") },
+    { QCryptographicHash::Sha3_384, QStringLiteral("sha3-384") },
+    { QCryptographicHash::Sha3_512, QStringLiteral("sha3-512") },
 #endif
 };
 
diff --git a/src/base/QXmppBitsOfBinaryData.cpp b/src/base/QXmppBitsOfBinaryData.cpp
index f6b0f303..2ffdb7cd 100644
--- a/src/base/QXmppBitsOfBinaryData.cpp
+++ b/src/base/QXmppBitsOfBinaryData.cpp
@@ -133,26 +133,26 @@ void QXmppBitsOfBinaryData::setData(const QByteArray &data)
 
 bool QXmppBitsOfBinaryData::isBitsOfBinaryData(const QDomElement &element)
 {
-    return element.tagName() == QSL("data") && element.namespaceURI() == ns_bob;
+    return element.tagName() == QStringLiteral("data") && element.namespaceURI() == ns_bob;
 }
 
 /// \cond
 void QXmppBitsOfBinaryData::parseElementFromChild(const QDomElement &dataElement)
 {
-    d->cid = QXmppBitsOfBinaryContentId::fromContentId(dataElement.attribute(QSL("cid")));
-    d->maxAge = dataElement.attribute(QSL("max-age"), QSL("-1")).toInt();
-    d->contentType = QMimeDatabase().mimeTypeForName(dataElement.attribute(QSL("type")));
+    d->cid = QXmppBitsOfBinaryContentId::fromContentId(dataElement.attribute(QStringLiteral("cid")));
+    d->maxAge = dataElement.attribute(QStringLiteral("max-age"), QStringLiteral("-1")).toInt();
+    d->contentType = QMimeDatabase().mimeTypeForName(dataElement.attribute(QStringLiteral("type")));
     d->data = QByteArray::fromBase64(dataElement.text().toUtf8());
 }
 
 void QXmppBitsOfBinaryData::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("data"));
+    writer->writeStartElement(QStringLiteral("data"));
     writer->writeDefaultNamespace(ns_bob);
-    helperToXmlAddAttribute(writer, QSL("cid"), d->cid.toContentId());
+    helperToXmlAddAttribute(writer, QStringLiteral("cid"), d->cid.toContentId());
     if (d->maxAge > -1)
-        helperToXmlAddAttribute(writer, QSL("max-age"), QString::number(d->maxAge));
-    helperToXmlAddAttribute(writer, QSL("type"), d->contentType.name());
+        helperToXmlAddAttribute(writer, QStringLiteral("max-age"), QString::number(d->maxAge));
+    helperToXmlAddAttribute(writer, QStringLiteral("type"), d->contentType.name());
     writer->writeCharacters(d->data.toBase64());
     writer->writeEndElement();
 }
diff --git a/src/base/QXmppBookmarkSet.cpp b/src/base/QXmppBookmarkSet.cpp
index 43b7739b..f72dcf00 100644
--- a/src/base/QXmppBookmarkSet.cpp
+++ b/src/base/QXmppBookmarkSet.cpp
@@ -178,7 +178,7 @@ void QXmppBookmarkSet::setUrls(const QList<QXmppBookmarkUrl> &urls)
 /// \cond
 bool QXmppBookmarkSet::isBookmarkSet(const QDomElement &element)
 {
-    return element.tagName() == QSL("storage") &&
+    return element.tagName() == QStringLiteral("storage") &&
         element.namespaceURI() == ns_bookmarks;
 }
 
@@ -186,17 +186,17 @@ void QXmppBookmarkSet::parse(const QDomElement &element)
 {
     QDomElement childElement = element.firstChildElement();
     while (!childElement.isNull()) {
-        if (childElement.tagName() == QSL("conference")) {
+        if (childElement.tagName() == QStringLiteral("conference")) {
             QXmppBookmarkConference conference;
-            conference.setAutoJoin(childElement.attribute(QSL("autojoin")) == QSL("true") || childElement.attribute("autojoin") == "1");
-            conference.setJid(childElement.attribute(QSL("jid")));
-            conference.setName(childElement.attribute(QSL("name")));
-            conference.setNickName(childElement.firstChildElement(QSL("nick")).text());
+            conference.setAutoJoin(childElement.attribute(QStringLiteral("autojoin")) == QStringLiteral("true") || childElement.attribute("autojoin") == "1");
+            conference.setJid(childElement.attribute(QStringLiteral("jid")));
+            conference.setName(childElement.attribute(QStringLiteral("name")));
+            conference.setNickName(childElement.firstChildElement(QStringLiteral("nick")).text());
             m_conferences << conference;
-        } else if (childElement.tagName() == QSL("url")) {
+        } else if (childElement.tagName() == QStringLiteral("url")) {
             QXmppBookmarkUrl url;
-            url.setName(childElement.attribute(QSL("name")));
-            url.setUrl(childElement.attribute(QSL("url")));
+            url.setName(childElement.attribute(QStringLiteral("name")));
+            url.setUrl(childElement.attribute(QStringLiteral("url")));
             m_urls << url;
         }
         childElement = childElement.nextSiblingElement();
@@ -205,22 +205,22 @@ void QXmppBookmarkSet::parse(const QDomElement &element)
 
 void QXmppBookmarkSet::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("storage"));
+    writer->writeStartElement(QStringLiteral("storage"));
     writer->writeDefaultNamespace(ns_bookmarks);
     for (const auto &conference : m_conferences) {
-        writer->writeStartElement(QSL("conference"));
+        writer->writeStartElement(QStringLiteral("conference"));
         if (conference.autoJoin())
-            helperToXmlAddAttribute(writer, QSL("autojoin"), QSL("true"));
-        helperToXmlAddAttribute(writer, QSL("jid"), conference.jid());
-        helperToXmlAddAttribute(writer, QSL("name"), conference.name());
+            helperToXmlAddAttribute(writer, QStringLiteral("autojoin"), QStringLiteral("true"));
+        helperToXmlAddAttribute(writer, QStringLiteral("jid"), conference.jid());
+        helperToXmlAddAttribute(writer, QStringLiteral("name"), conference.name());
         if (!conference.nickName().isEmpty())
-            helperToXmlAddTextElement(writer, QSL("nick"), conference.nickName());
+            helperToXmlAddTextElement(writer, QStringLiteral("nick"), conference.nickName());
         writer->writeEndElement();
     }
     for (const auto &url : m_urls) {
-        writer->writeStartElement(QSL("url"));
-        helperToXmlAddAttribute(writer, QSL("name"), url.name());
-        helperToXmlAddAttribute(writer, QSL("url"), url.url().toString());
+        writer->writeStartElement(QStringLiteral("url"));
+        helperToXmlAddAttribute(writer, QStringLiteral("name"), url.name());
+        helperToXmlAddAttribute(writer, QStringLiteral("url"), url.url().toString());
         writer->writeEndElement();
     }
     writer->writeEndElement();
diff --git a/src/base/QXmppByteStreamIq.cpp b/src/base/QXmppByteStreamIq.cpp
index a79f1624..d5f3f26d 100644
--- a/src/base/QXmppByteStreamIq.cpp
+++ b/src/base/QXmppByteStreamIq.cpp
@@ -121,60 +121,60 @@ void QXmppByteStreamIq::setStreamHostUsed(const QString &jid)
 /// \cond
 bool QXmppByteStreamIq::isByteStreamIq(const QDomElement &element)
 {
-    return element.firstChildElement(QSL("query")).namespaceURI() == ns_bytestreams;
+    return element.firstChildElement(QStringLiteral("query")).namespaceURI() == ns_bytestreams;
 }
 
 void QXmppByteStreamIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    m_sid = queryElement.attribute(QSL("sid"));
-    const QString modeStr = queryElement.attribute(QSL("mode"));
-    if (modeStr == QSL("tcp"))
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    m_sid = queryElement.attribute(QStringLiteral("sid"));
+    const QString modeStr = queryElement.attribute(QStringLiteral("mode"));
+    if (modeStr == QStringLiteral("tcp"))
         m_mode = Tcp;
-    else if (modeStr == QSL("udp"))
+    else if (modeStr == QStringLiteral("udp"))
         m_mode = Udp;
     else
         m_mode = None;
 
-    QDomElement hostElement = queryElement.firstChildElement(QSL("streamhost"));
+    QDomElement hostElement = queryElement.firstChildElement(QStringLiteral("streamhost"));
     while (!hostElement.isNull()) {
         StreamHost streamHost;
-        streamHost.setHost(hostElement.attribute(QSL("host")));
-        streamHost.setJid(hostElement.attribute(QSL("jid")));
-        streamHost.setPort(hostElement.attribute(QSL("port")).toInt());
-        streamHost.setZeroconf(hostElement.attribute(QSL("zeroconf")));
+        streamHost.setHost(hostElement.attribute(QStringLiteral("host")));
+        streamHost.setJid(hostElement.attribute(QStringLiteral("jid")));
+        streamHost.setPort(hostElement.attribute(QStringLiteral("port")).toInt());
+        streamHost.setZeroconf(hostElement.attribute(QStringLiteral("zeroconf")));
         m_streamHosts.append(streamHost);
 
-        hostElement = hostElement.nextSiblingElement(QSL("streamhost"));
+        hostElement = hostElement.nextSiblingElement(QStringLiteral("streamhost"));
     }
-    m_activate = queryElement.firstChildElement(QSL("activate")).text();
-    m_streamHostUsed = queryElement.firstChildElement(QSL("streamhost-used")).attribute(QSL("jid"));
+    m_activate = queryElement.firstChildElement(QStringLiteral("activate")).text();
+    m_streamHostUsed = queryElement.firstChildElement(QStringLiteral("streamhost-used")).attribute(QStringLiteral("jid"));
 }
 
 void QXmppByteStreamIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_bytestreams);
-    helperToXmlAddAttribute(writer, QSL("sid"), m_sid);
+    helperToXmlAddAttribute(writer, QStringLiteral("sid"), m_sid);
     QString modeStr;
     if (m_mode == Tcp)
-        modeStr = QSL("tcp");
+        modeStr = QStringLiteral("tcp");
     else if (m_mode == Udp)
-        modeStr = QSL("udp");
-    helperToXmlAddAttribute(writer, QSL("mode"), modeStr);
+        modeStr = QStringLiteral("udp");
+    helperToXmlAddAttribute(writer, QStringLiteral("mode"), modeStr);
     for (const auto &streamHost : m_streamHosts) {
-        writer->writeStartElement(QSL("streamhost"));
-        helperToXmlAddAttribute(writer, QSL("host"), streamHost.host());
-        helperToXmlAddAttribute(writer, QSL("jid"), streamHost.jid());
-        helperToXmlAddAttribute(writer, QSL("port"), QString::number(streamHost.port()));
-        helperToXmlAddAttribute(writer, QSL("zeroconf"), streamHost.zeroconf());
+        writer->writeStartElement(QStringLiteral("streamhost"));
+        helperToXmlAddAttribute(writer, QStringLiteral("host"), streamHost.host());
+        helperToXmlAddAttribute(writer, QStringLiteral("jid"), streamHost.jid());
+        helperToXmlAddAttribute(writer, QStringLiteral("port"), QString::number(streamHost.port()));
+        helperToXmlAddAttribute(writer, QStringLiteral("zeroconf"), streamHost.zeroconf());
         writer->writeEndElement();
     }
     if (!m_activate.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("activate"), m_activate);
+        helperToXmlAddTextElement(writer, QStringLiteral("activate"), m_activate);
     if (!m_streamHostUsed.isEmpty()) {
-        writer->writeStartElement(QSL("streamhost-used"));
-        helperToXmlAddAttribute(writer, QSL("jid"), m_streamHostUsed);
+        writer->writeStartElement(QStringLiteral("streamhost-used"));
+        helperToXmlAddAttribute(writer, QStringLiteral("jid"), m_streamHostUsed);
         writer->writeEndElement();
     }
 
diff --git a/src/base/QXmppDataForm.cpp b/src/base/QXmppDataForm.cpp
index 93ceaf90..8239b86a 100644
--- a/src/base/QXmppDataForm.cpp
+++ b/src/base/QXmppDataForm.cpp
@@ -694,14 +694,14 @@ void QXmppDataForm::parse(const QDomElement &element)
             field.mediaSize().setHeight(mediaElement.attribute("height", "-1").toInt());
             field.mediaSize().setWidth(mediaElement.attribute("width", "-1").toInt());
 
-            QDomElement uriElement = mediaElement.firstChildElement(QSL("uri"));
+            QDomElement uriElement = mediaElement.firstChildElement(QStringLiteral("uri"));
 
             while (!uriElement.isNull()) {
                 field.mediaSources() << MediaSource(
                     QUrl(uriElement.text()),
                     QMimeDatabase().mimeTypeForName(
-                        uriElement.attribute(QSL("type"))));
-                uriElement = uriElement.nextSiblingElement(QSL("uri"));
+                        uriElement.attribute(QStringLiteral("type"))));
+                uriElement = uriElement.nextSiblingElement(QStringLiteral("uri"));
             }
         }
 
@@ -794,18 +794,18 @@ void QXmppDataForm::toXml(QXmlStreamWriter *writer) const
             if (field.mediaSize().width() > 0)
                 helperToXmlAddAttribute(
                     writer,
-                    QSL("width"),
+                    QStringLiteral("width"),
                     QString::number(field.mediaSize().width()));
             if (field.mediaSize().height() > 0)
                 helperToXmlAddAttribute(
                     writer,
-                    QSL("height"),
+                    QStringLiteral("height"),
                     QString::number(field.mediaSize().height()));
 
             const QVector<MediaSource> &sources = field.mediaSources();
             for (const auto &source : sources) {
-                writer->writeStartElement(QSL("uri"));
-                helperToXmlAddAttribute(writer, QSL("type"), source.contentType().name());
+                writer->writeStartElement(QStringLiteral("uri"));
+                helperToXmlAddAttribute(writer, QStringLiteral("type"), source.contentType().name());
                 writer->writeCharacters(source.uri().toString());
                 writer->writeEndElement();
             }
diff --git a/src/base/QXmppGlobal.h.in b/src/base/QXmppGlobal.h.in
index 83948bb8..fa4736f4 100644
--- a/src/base/QXmppGlobal.h.in
+++ b/src/base/QXmppGlobal.h.in
@@ -62,8 +62,5 @@ inline QLatin1String QXmppVersion()
 // This works exactly like QT_DEPRECATED_SINCE, but checks QXMPP_DISABLE_DEPRECATED_BEFORE instead.
 #define QXMPP_DEPRECATED_SINCE(major, minor) (QT_VERSION_CHECK(major, minor, 0) > QXMPP_DISABLE_DEPRECATED_BEFORE)
 
-#define QSL QStringLiteral
-#define QBL QByteArrayLiteral
-
 #endif //QXMPPGLOBAL_H
 
diff --git a/src/base/QXmppJingleIq.cpp b/src/base/QXmppJingleIq.cpp
index b37c75cd..d89fbf06 100644
--- a/src/base/QXmppJingleIq.cpp
+++ b/src/base/QXmppJingleIq.cpp
@@ -96,12 +96,12 @@ static QByteArray parseFingerprint(const QString &fingerprint)
 
 static QString addressToSdp(const QHostAddress &host)
 {
-    return QSL("IN %1 %2").arg(host.protocol() == QAbstractSocket::IPv6Protocol ? QSL("IP6") : QSL("IP4"), host.toString());
+    return QStringLiteral("IN %1 %2").arg(host.protocol() == QAbstractSocket::IPv6Protocol ? QStringLiteral("IP6") : QStringLiteral("IP4"), host.toString());
 }
 
 static bool candidateParseSdp(QXmppJingleCandidate *candidate, const QString &sdp)
 {
-    if (!sdp.startsWith(QSL("candidate:")))
+    if (!sdp.startsWith(QStringLiteral("candidate:")))
         return false;
 
     const QStringList bits = sdp.mid(10).split(" ");
@@ -115,12 +115,12 @@ static bool candidateParseSdp(QXmppJingleCandidate *candidate, const QString &sd
     candidate->setHost(QHostAddress(bits[4]));
     candidate->setPort(bits[5].toInt());
     for (int i = 6; i < bits.size() - 1; i += 2) {
-        if (bits[i] == QSL("typ")) {
+        if (bits[i] == QStringLiteral("typ")) {
             bool ok;
             candidate->setType(QXmppJingleCandidate::typeFromString(bits[i + 1], &ok));
             if (!ok)
                 return false;
-        } else if (bits[i] == QSL("generation")) {
+        } else if (bits[i] == QStringLiteral("generation")) {
             candidate->setGeneration(bits[i + 1].toInt());
         } else {
             qWarning() << "Candidate SDP contains unknown attribute" << bits[i];
@@ -132,7 +132,7 @@ static bool candidateParseSdp(QXmppJingleCandidate *candidate, const QString &sd
 
 static QString candidateToSdp(const QXmppJingleCandidate &candidate)
 {
-    return QSL("candidate:%1 %2 %3 %4 %5 %6 typ %7 generation %8").arg(candidate.foundation(), QString::number(candidate.component()), candidate.protocol(), QString::number(candidate.priority()), candidate.host().toString(), QString::number(candidate.port()), QXmppJingleCandidate::typeToString(candidate.type()), QString::number(candidate.generation()));
+    return QStringLiteral("candidate:%1 %2 %3 %4 %5 %6 typ %7 generation %8").arg(candidate.foundation(), QString::number(candidate.component()), candidate.protocol(), QString::number(candidate.priority()), candidate.host().toString(), QString::number(candidate.port()), QXmppJingleCandidate::typeToString(candidate.type()), QString::number(candidate.generation()));
 }
 
 class QXmppJingleIqContentPrivate : public QSharedData
@@ -356,43 +356,43 @@ void QXmppJingleIq::Content::setTransportFingerprintSetup(const QString &setup)
 /// \cond
 void QXmppJingleIq::Content::parse(const QDomElement &element)
 {
-    d->creator = element.attribute(QSL("creator"));
-    d->disposition = element.attribute(QSL("disposition"));
-    d->name = element.attribute(QSL("name"));
-    d->senders = element.attribute(QSL("senders"));
+    d->creator = element.attribute(QStringLiteral("creator"));
+    d->disposition = element.attribute(QStringLiteral("disposition"));
+    d->name = element.attribute(QStringLiteral("name"));
+    d->senders = element.attribute(QStringLiteral("senders"));
 
     // description
-    QDomElement descriptionElement = element.firstChildElement(QSL("description"));
+    QDomElement descriptionElement = element.firstChildElement(QStringLiteral("description"));
     d->descriptionType = descriptionElement.namespaceURI();
-    d->descriptionMedia = descriptionElement.attribute(QSL("media"));
-    d->descriptionSsrc = descriptionElement.attribute(QSL("ssrc")).toULong();
-    QDomElement child = descriptionElement.firstChildElement(QSL("payload-type"));
+    d->descriptionMedia = descriptionElement.attribute(QStringLiteral("media"));
+    d->descriptionSsrc = descriptionElement.attribute(QStringLiteral("ssrc")).toULong();
+    QDomElement child = descriptionElement.firstChildElement(QStringLiteral("payload-type"));
     while (!child.isNull()) {
         QXmppJinglePayloadType payload;
         payload.parse(child);
         d->payloadTypes << payload;
-        child = child.nextSiblingElement(QSL("payload-type"));
+        child = child.nextSiblingElement(QStringLiteral("payload-type"));
     }
 
     // transport
-    QDomElement transportElement = element.firstChildElement(QSL("transport"));
+    QDomElement transportElement = element.firstChildElement(QStringLiteral("transport"));
     d->transportType = transportElement.namespaceURI();
-    d->transportUser = transportElement.attribute(QSL("ufrag"));
-    d->transportPassword = transportElement.attribute(QSL("pwd"));
-    child = transportElement.firstChildElement(QSL("candidate"));
+    d->transportUser = transportElement.attribute(QStringLiteral("ufrag"));
+    d->transportPassword = transportElement.attribute(QStringLiteral("pwd"));
+    child = transportElement.firstChildElement(QStringLiteral("candidate"));
     while (!child.isNull()) {
         QXmppJingleCandidate candidate;
         candidate.parse(child);
         d->transportCandidates << candidate;
-        child = child.nextSiblingElement(QSL("candidate"));
+        child = child.nextSiblingElement(QStringLiteral("candidate"));
     }
-    child = transportElement.firstChildElement(QSL("fingerprint"));
+    child = transportElement.firstChildElement(QStringLiteral("fingerprint"));
 
     /// XEP-0320
     if (!child.isNull()) {
         d->transportFingerprint = parseFingerprint(child.text());
-        d->transportFingerprintHash = child.attribute(QSL("hash"));
-        d->transportFingerprintSetup = child.attribute(QSL("setup"));
+        d->transportFingerprintHash = child.attribute(QStringLiteral("hash"));
+        d->transportFingerprintSetup = child.attribute(QStringLiteral("setup"));
     }
 }
 
@@ -401,19 +401,19 @@ void QXmppJingleIq::Content::toXml(QXmlStreamWriter *writer) const
     if (d->creator.isEmpty() || d->name.isEmpty())
         return;
 
-    writer->writeStartElement(QSL("content"));
-    helperToXmlAddAttribute(writer, QSL("creator"), d->creator);
-    helperToXmlAddAttribute(writer, QSL("disposition"), d->disposition);
-    helperToXmlAddAttribute(writer, QSL("name"), d->name);
-    helperToXmlAddAttribute(writer, QSL("senders"), d->senders);
+    writer->writeStartElement(QStringLiteral("content"));
+    helperToXmlAddAttribute(writer, QStringLiteral("creator"), d->creator);
+    helperToXmlAddAttribute(writer, QStringLiteral("disposition"), d->disposition);
+    helperToXmlAddAttribute(writer, QStringLiteral("name"), d->name);
+    helperToXmlAddAttribute(writer, QStringLiteral("senders"), d->senders);
 
     // description
     if (!d->descriptionType.isEmpty() || !d->payloadTypes.isEmpty()) {
-        writer->writeStartElement(QSL("description"));
+        writer->writeStartElement(QStringLiteral("description"));
         writer->writeDefaultNamespace(d->descriptionType);
-        helperToXmlAddAttribute(writer, QSL("media"), d->descriptionMedia);
+        helperToXmlAddAttribute(writer, QStringLiteral("media"), d->descriptionMedia);
         if (d->descriptionSsrc)
-            writer->writeAttribute(QSL("ssrc"), QString::number(d->descriptionSsrc));
+            writer->writeAttribute(QStringLiteral("ssrc"), QString::number(d->descriptionSsrc));
         for (const auto &payload : d->payloadTypes)
             payload.toXml(writer);
         writer->writeEndElement();
@@ -421,19 +421,19 @@ void QXmppJingleIq::Content::toXml(QXmlStreamWriter *writer) const
 
     // transport
     if (!d->transportType.isEmpty() || !d->transportCandidates.isEmpty()) {
-        writer->writeStartElement(QSL("transport"));
+        writer->writeStartElement(QStringLiteral("transport"));
         writer->writeDefaultNamespace(d->transportType);
-        helperToXmlAddAttribute(writer, QSL("ufrag"), d->transportUser);
-        helperToXmlAddAttribute(writer, QSL("pwd"), d->transportPassword);
+        helperToXmlAddAttribute(writer, QStringLiteral("ufrag"), d->transportUser);
+        helperToXmlAddAttribute(writer, QStringLiteral("pwd"), d->transportPassword);
         for (const auto &candidate : d->transportCandidates)
             candidate.toXml(writer);
 
         // XEP-0320
         if (!d->transportFingerprint.isEmpty() && !d->transportFingerprintHash.isEmpty()) {
-            writer->writeStartElement(QSL("fingerprint"));
+            writer->writeStartElement(QStringLiteral("fingerprint"));
             writer->writeDefaultNamespace(ns_jingle_dtls);
-            writer->writeAttribute(QSL("hash"), d->transportFingerprintHash);
-            writer->writeAttribute(QSL("setup"), d->transportFingerprintSetup);
+            writer->writeAttribute(QStringLiteral("hash"), d->transportFingerprintHash);
+            writer->writeAttribute(QStringLiteral("setup"), d->transportFingerprintSetup);
             writer->writeCharacters(formatFingerprint(d->transportFingerprint));
             writer->writeEndElement();
         }
@@ -449,25 +449,25 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
     for (auto &line : sdp.split('\n')) {
         if (line.endsWith('\r'))
             line.resize(line.size() - 1);
-        if (line.startsWith(QSL("a="))) {
+        if (line.startsWith(QStringLiteral("a="))) {
             int idx = line.indexOf(':');
             const QString attrName = idx != -1 ? line.mid(2, idx - 2) : line.mid(2);
             const QString attrValue = idx != -1 ? line.mid(idx + 1) : "";
 
-            if (attrName == QSL("candidate")) {
+            if (attrName == QStringLiteral("candidate")) {
                 QXmppJingleCandidate candidate;
                 if (!candidateParseSdp(&candidate, line.mid(2))) {
                     qWarning() << "Could not parse candidate" << line;
                     return false;
                 }
                 addTransportCandidate(candidate);
-            } else if (attrName == QSL("fingerprint")) {
+            } else if (attrName == QStringLiteral("fingerprint")) {
                 const QStringList bits = attrValue.split(' ');
                 if (bits.size() > 1) {
                     d->transportFingerprintHash = bits[0];
                     d->transportFingerprint = parseFingerprint(bits[1]);
                 }
-            } else if (attrName == QSL("fmtp")) {
+            } else if (attrName == QStringLiteral("fmtp")) {
                 int spIdx = attrValue.indexOf(' ');
                 if (spIdx == -1) {
                     qWarning() << "Could not parse payload parameters" << line;
@@ -478,8 +478,8 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
                 for (auto &payload : payloads) {
                     if (payload.id() == id) {
                         QMap<QString, QString> params;
-                        if (payload.name() == QSL("telephone-event")) {
-                            params.insert(QSL("events"), paramStr);
+                        if (payload.name() == QStringLiteral("telephone-event")) {
+                            params.insert(QStringLiteral("events"), paramStr);
                         } else {
                             for (const auto &p : paramStr.split(QRegExp(";\\s*"))) {
                                 QStringList bits = p.split('=');
@@ -490,7 +490,7 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
                         payload.setParameters(params);
                     }
                 }
-            } else if (attrName == QSL("rtpmap")) {
+            } else if (attrName == QStringLiteral("rtpmap")) {
                 // payload type map
                 const QStringList bits = attrValue.split(' ');
                 if (bits.size() != 2)
@@ -510,13 +510,13 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
                             payload.setChannels(args[2].toInt());
                     }
                 }
-            } else if (attrName == QSL("ice-ufrag")) {
+            } else if (attrName == QStringLiteral("ice-ufrag")) {
                 d->transportUser = attrValue;
-            } else if (attrName == QSL("ice-pwd")) {
+            } else if (attrName == QStringLiteral("ice-pwd")) {
                 d->transportPassword = attrValue;
-            } else if (attrName == QSL("setup")) {
+            } else if (attrName == QStringLiteral("setup")) {
                 d->transportFingerprintSetup = attrValue;
-            } else if (attrName == QSL("ssrc")) {
+            } else if (attrName == QStringLiteral("ssrc")) {
                 const QStringList bits = attrValue.split(' ');
                 if (bits.isEmpty()) {
                     qWarning() << "Could not parse ssrc" << line;
@@ -524,7 +524,7 @@ bool QXmppJingleIq::Content::parseSdp(const QString &sdp)
                 }
                 d->descriptionSsrc = bits[0].toULong();
             }
-        } else if (line.startsWith(QSL("m="))) {
+        } else if (line.startsWith(QStringLiteral("m="))) {
             // FIXME: what do we do with the profile (bits[2]) ?
             QStringList bits = line.mid(2).split(' ');
             if (bits.size() < 3) {
@@ -587,32 +587,32 @@ QString QXmppJingleIq::Content::toSdp() const
         // payload parameters
         QStringList paramList;
         const QMap<QString, QString> params = payload.parameters();
-        if (payload.name() == QSL("telephone-event")) {
-            if (params.contains(QSL("events")))
-                paramList << params.value(QSL("events"));
+        if (payload.name() == QStringLiteral("telephone-event")) {
+            if (params.contains(QStringLiteral("events")))
+                paramList << params.value(QStringLiteral("events"));
         } else {
             QMap<QString, QString>::const_iterator i;
             for (i = params.begin(); i != params.end(); ++i)
-                paramList << i.key() + QSL("=") + i.value();
+                paramList << i.key() + QStringLiteral("=") + i.value();
         }
         if (!paramList.isEmpty())
-            attrs << QSL("a=fmtp:") + QByteArray::number(payload.id()) + QSL(" ") + paramList.join("; ");
+            attrs << QStringLiteral("a=fmtp:") + QByteArray::number(payload.id()) + QStringLiteral(" ") + paramList.join("; ");
     }
-    sdp << QSL("m=%1 %2 RTP/AVP%3").arg(d->descriptionMedia, QString::number(localRtpPort), payloads);
-    sdp << QSL("c=%1").arg(addressToSdp(localRtpAddress));
+    sdp << QStringLiteral("m=%1 %2 RTP/AVP%3").arg(d->descriptionMedia, QString::number(localRtpPort), payloads);
+    sdp << QStringLiteral("c=%1").arg(addressToSdp(localRtpAddress));
     sdp += attrs;
 
     // transport
     for (const auto &candidate : d->transportCandidates)
-        sdp << QSL("a=%1").arg(candidateToSdp(candidate));
+        sdp << QStringLiteral("a=%1").arg(candidateToSdp(candidate));
     if (!d->transportUser.isEmpty())
-        sdp << QSL("a=ice-ufrag:%1").arg(d->transportUser);
+        sdp << QStringLiteral("a=ice-ufrag:%1").arg(d->transportUser);
     if (!d->transportPassword.isEmpty())
-        sdp << QSL("a=ice-pwd:%1").arg(d->transportPassword);
+        sdp << QStringLiteral("a=ice-pwd:%1").arg(d->transportPassword);
     if (!d->transportFingerprint.isEmpty() && !d->transportFingerprintHash.isEmpty())
-        sdp << QSL("a=fingerprint:%1 %2").arg(d->transportFingerprintHash, formatFingerprint(d->transportFingerprint));
+        sdp << QStringLiteral("a=fingerprint:%1 %2").arg(d->transportFingerprintHash, formatFingerprint(d->transportFingerprint));
     if (!d->transportFingerprintSetup.isEmpty())
-        sdp << QSL("a=setup:%1").arg(d->transportFingerprintSetup);
+        sdp << QStringLiteral("a=setup:%1").arg(d->transportFingerprintSetup);
 
     return sdp.join("\r\n") + "\r\n";
 }
@@ -655,7 +655,7 @@ void QXmppJingleIq::Reason::setType(QXmppJingleIq::Reason::Type type)
 /// \cond
 void QXmppJingleIq::Reason::parse(const QDomElement &element)
 {
-    m_text = element.firstChildElement(QSL("text")).text();
+    m_text = element.firstChildElement(QStringLiteral("text")).text();
     for (int i = AlternativeSession; i <= UnsupportedTransports; i++) {
         if (!element.firstChildElement(jingle_reasons[i]).isNull()) {
             m_type = static_cast<Type>(i);
@@ -669,9 +669,9 @@ void QXmppJingleIq::Reason::toXml(QXmlStreamWriter *writer) const
     if (m_type < AlternativeSession || m_type > UnsupportedTransports)
         return;
 
-    writer->writeStartElement(QSL("reason"));
+    writer->writeStartElement(QStringLiteral("reason"));
     if (!m_text.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("text"), m_text);
+        helperToXmlAddTextElement(writer, QStringLiteral("text"), m_text);
     writer->writeEmptyElement(jingle_reasons[m_type]);
     writer->writeEndElement();
 }
@@ -845,56 +845,56 @@ void QXmppJingleIq::setSid(const QString &sid)
 /// \cond
 bool QXmppJingleIq::isJingleIq(const QDomElement &element)
 {
-    QDomElement jingleElement = element.firstChildElement(QSL("jingle"));
+    QDomElement jingleElement = element.firstChildElement(QStringLiteral("jingle"));
     return (jingleElement.namespaceURI() == ns_jingle);
 }
 
 void QXmppJingleIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement jingleElement = element.firstChildElement(QSL("jingle"));
-    const QString action = jingleElement.attribute(QSL("action"));
+    QDomElement jingleElement = element.firstChildElement(QStringLiteral("jingle"));
+    const QString action = jingleElement.attribute(QStringLiteral("action"));
     for (int i = ContentAccept; i <= TransportReplace; i++) {
         if (action == jingle_actions[i]) {
             d->action = static_cast<Action>(i);
             break;
         }
     }
-    d->initiator = jingleElement.attribute(QSL("initiator"));
-    d->responder = jingleElement.attribute(QSL("responder"));
-    d->sid = jingleElement.attribute(QSL("sid"));
+    d->initiator = jingleElement.attribute(QStringLiteral("initiator"));
+    d->responder = jingleElement.attribute(QStringLiteral("responder"));
+    d->sid = jingleElement.attribute(QStringLiteral("sid"));
 
     // content
     d->contents.clear();
-    QDomElement contentElement = jingleElement.firstChildElement(QSL("content"));
+    QDomElement contentElement = jingleElement.firstChildElement(QStringLiteral("content"));
     while (!contentElement.isNull()) {
         QXmppJingleIq::Content content;
         content.parse(contentElement);
         addContent(content);
-        contentElement = contentElement.nextSiblingElement(QSL("content"));
+        contentElement = contentElement.nextSiblingElement(QStringLiteral("content"));
     }
-    QDomElement reasonElement = jingleElement.firstChildElement(QSL("reason"));
+    QDomElement reasonElement = jingleElement.firstChildElement(QStringLiteral("reason"));
     d->reason.parse(reasonElement);
 
     // ringing
-    QDomElement ringingElement = jingleElement.firstChildElement(QSL("ringing"));
+    QDomElement ringingElement = jingleElement.firstChildElement(QStringLiteral("ringing"));
     d->ringing = (ringingElement.namespaceURI() == ns_jingle_rtp_info);
 }
 
 void QXmppJingleIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("jingle"));
+    writer->writeStartElement(QStringLiteral("jingle"));
     writer->writeDefaultNamespace(ns_jingle);
-    helperToXmlAddAttribute(writer, QSL("action"), jingle_actions[d->action]);
-    helperToXmlAddAttribute(writer, QSL("initiator"), d->initiator);
-    helperToXmlAddAttribute(writer, QSL("responder"), d->responder);
-    helperToXmlAddAttribute(writer, QSL("sid"), d->sid);
+    helperToXmlAddAttribute(writer, QStringLiteral("action"), jingle_actions[d->action]);
+    helperToXmlAddAttribute(writer, QStringLiteral("initiator"), d->initiator);
+    helperToXmlAddAttribute(writer, QStringLiteral("responder"), d->responder);
+    helperToXmlAddAttribute(writer, QStringLiteral("sid"), d->sid);
     for (const auto &content : d->contents)
         content.toXml(writer);
     d->reason.toXml(writer);
 
     // ringing
     if (d->ringing) {
-        writer->writeStartElement(QSL("ringing"));
+        writer->writeStartElement(QStringLiteral("ringing"));
         writer->writeDefaultNamespace(ns_jingle_rtp_info);
         writer->writeEndElement();
     }
@@ -1133,44 +1133,44 @@ bool QXmppJingleCandidate::isNull() const
 /// \cond
 void QXmppJingleCandidate::parse(const QDomElement &element)
 {
-    d->component = element.attribute(QSL("component")).toInt();
-    d->foundation = element.attribute(QSL("foundation"));
-    d->generation = element.attribute(QSL("generation")).toInt();
-    d->host = QHostAddress(element.attribute(QSL("ip")));
-    d->id = element.attribute(QSL("id"));
-    d->network = element.attribute(QSL("network")).toInt();
-    d->port = element.attribute(QSL("port")).toInt();
-    d->priority = element.attribute(QSL("priority")).toInt();
-    d->protocol = element.attribute(QSL("protocol"));
-    d->type = typeFromString(element.attribute(QSL("type")));
+    d->component = element.attribute(QStringLiteral("component")).toInt();
+    d->foundation = element.attribute(QStringLiteral("foundation"));
+    d->generation = element.attribute(QStringLiteral("generation")).toInt();
+    d->host = QHostAddress(element.attribute(QStringLiteral("ip")));
+    d->id = element.attribute(QStringLiteral("id"));
+    d->network = element.attribute(QStringLiteral("network")).toInt();
+    d->port = element.attribute(QStringLiteral("port")).toInt();
+    d->priority = element.attribute(QStringLiteral("priority")).toInt();
+    d->protocol = element.attribute(QStringLiteral("protocol"));
+    d->type = typeFromString(element.attribute(QStringLiteral("type")));
 }
 
 void QXmppJingleCandidate::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("candidate"));
-    helperToXmlAddAttribute(writer, QSL("component"), QString::number(d->component));
-    helperToXmlAddAttribute(writer, QSL("foundation"), d->foundation);
-    helperToXmlAddAttribute(writer, QSL("generation"), QString::number(d->generation));
-    helperToXmlAddAttribute(writer, QSL("id"), d->id);
-    helperToXmlAddAttribute(writer, QSL("ip"), d->host.toString());
-    helperToXmlAddAttribute(writer, QSL("network"), QString::number(d->network));
-    helperToXmlAddAttribute(writer, QSL("port"), QString::number(d->port));
-    helperToXmlAddAttribute(writer, QSL("priority"), QString::number(d->priority));
-    helperToXmlAddAttribute(writer, QSL("protocol"), d->protocol);
-    helperToXmlAddAttribute(writer, QSL("type"), typeToString(d->type));
+    writer->writeStartElement(QStringLiteral("candidate"));
+    helperToXmlAddAttribute(writer, QStringLiteral("component"), QString::number(d->component));
+    helperToXmlAddAttribute(writer, QStringLiteral("foundation"), d->foundation);
+    helperToXmlAddAttribute(writer, QStringLiteral("generation"), QString::number(d->generation));
+    helperToXmlAddAttribute(writer, QStringLiteral("id"), d->id);
+    helperToXmlAddAttribute(writer, QStringLiteral("ip"), d->host.toString());
+    helperToXmlAddAttribute(writer, QStringLiteral("network"), QString::number(d->network));
+    helperToXmlAddAttribute(writer, QStringLiteral("port"), QString::number(d->port));
+    helperToXmlAddAttribute(writer, QStringLiteral("priority"), QString::number(d->priority));
+    helperToXmlAddAttribute(writer, QStringLiteral("protocol"), d->protocol);
+    helperToXmlAddAttribute(writer, QStringLiteral("type"), typeToString(d->type));
     writer->writeEndElement();
 }
 
 QXmppJingleCandidate::Type QXmppJingleCandidate::typeFromString(const QString &typeStr, bool *ok)
 {
     QXmppJingleCandidate::Type type;
-    if (typeStr == QSL("host"))
+    if (typeStr == QStringLiteral("host"))
         type = HostType;
-    else if (typeStr == QSL("prflx"))
+    else if (typeStr == QStringLiteral("prflx"))
         type = PeerReflexiveType;
-    else if (typeStr == QSL("srflx"))
+    else if (typeStr == QStringLiteral("srflx"))
         type = ServerReflexiveType;
-    else if (typeStr == QSL("relay"))
+    else if (typeStr == QStringLiteral("relay"))
         type = RelayedType;
     else {
         qWarning() << "Unknown candidate type" << typeStr;
@@ -1188,16 +1188,16 @@ QString QXmppJingleCandidate::typeToString(QXmppJingleCandidate::Type type)
     QString typeStr;
     switch (type) {
     case HostType:
-        typeStr = QSL("host");
+        typeStr = QStringLiteral("host");
         break;
     case PeerReflexiveType:
-        typeStr = QSL("prflx");
+        typeStr = QStringLiteral("prflx");
         break;
     case ServerReflexiveType:
-        typeStr = QSL("srflx");
+        typeStr = QStringLiteral("srflx");
         break;
     case RelayedType:
-        typeStr = QSL("relay");
+        typeStr = QStringLiteral("relay");
         break;
     }
     return typeStr;
@@ -1360,40 +1360,40 @@ void QXmppJinglePayloadType::setPtime(unsigned int ptime)
 /// \cond
 void QXmppJinglePayloadType::parse(const QDomElement &element)
 {
-    d->id = element.attribute(QSL("id")).toInt();
-    d->name = element.attribute(QSL("name"));
-    d->channels = element.attribute(QSL("channels")).toInt();
+    d->id = element.attribute(QStringLiteral("id")).toInt();
+    d->name = element.attribute(QStringLiteral("name"));
+    d->channels = element.attribute(QStringLiteral("channels")).toInt();
     if (!d->channels)
         d->channels = 1;
-    d->clockrate = element.attribute(QSL("clockrate")).toInt();
-    d->maxptime = element.attribute(QSL("maxptime")).toInt();
-    d->ptime = element.attribute(QSL("ptime")).toInt();
+    d->clockrate = element.attribute(QStringLiteral("clockrate")).toInt();
+    d->maxptime = element.attribute(QStringLiteral("maxptime")).toInt();
+    d->ptime = element.attribute(QStringLiteral("ptime")).toInt();
 
-    QDomElement child = element.firstChildElement(QSL("parameter"));
+    QDomElement child = element.firstChildElement(QStringLiteral("parameter"));
     while (!child.isNull()) {
-        d->parameters.insert(child.attribute(QSL("name")), child.attribute(QSL("value")));
-        child = child.nextSiblingElement(QSL("parameter"));
+        d->parameters.insert(child.attribute(QStringLiteral("name")), child.attribute(QStringLiteral("value")));
+        child = child.nextSiblingElement(QStringLiteral("parameter"));
     }
 }
 
 void QXmppJinglePayloadType::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("payload-type"));
-    helperToXmlAddAttribute(writer, QSL("id"), QString::number(d->id));
-    helperToXmlAddAttribute(writer, QSL("name"), d->name);
+    writer->writeStartElement(QStringLiteral("payload-type"));
+    helperToXmlAddAttribute(writer, QStringLiteral("id"), QString::number(d->id));
+    helperToXmlAddAttribute(writer, QStringLiteral("name"), d->name);
     if (d->channels > 1)
-        helperToXmlAddAttribute(writer, QSL("channels"), QString::number(d->channels));
+        helperToXmlAddAttribute(writer, QStringLiteral("channels"), QString::number(d->channels));
     if (d->clockrate > 0)
-        helperToXmlAddAttribute(writer, QSL("clockrate"), QString::number(d->clockrate));
+        helperToXmlAddAttribute(writer, QStringLiteral("clockrate"), QString::number(d->clockrate));
     if (d->maxptime > 0)
-        helperToXmlAddAttribute(writer, QSL("maxptime"), QString::number(d->maxptime));
+        helperToXmlAddAttribute(writer, QStringLiteral("maxptime"), QString::number(d->maxptime));
     if (d->ptime > 0)
-        helperToXmlAddAttribute(writer, QSL("ptime"), QString::number(d->ptime));
+        helperToXmlAddAttribute(writer, QStringLiteral("ptime"), QString::number(d->ptime));
 
     for (const auto &key : d->parameters.keys()) {
-        writer->writeStartElement(QSL("parameter"));
-        writer->writeAttribute(QSL("name"), key);
-        writer->writeAttribute(QSL("value"), d->parameters.value(key));
+        writer->writeStartElement(QStringLiteral("parameter"));
+        writer->writeAttribute(QStringLiteral("name"), key);
+        writer->writeAttribute(QStringLiteral("value"), d->parameters.value(key));
         writer->writeEndElement();
     }
     writer->writeEndElement();
diff --git a/src/base/QXmppMamIq.cpp b/src/base/QXmppMamIq.cpp
index 411dfd8f..4c610d8d 100644
--- a/src/base/QXmppMamIq.cpp
+++ b/src/base/QXmppMamIq.cpp
@@ -107,8 +107,8 @@ void QXmppMamQueryIq::setQueryId(const QString &id)
 /// \cond
 bool QXmppMamQueryIq::isMamQueryIq(const QDomElement &element)
 {
-    if (element.tagName() == QSL("iq")) {
-        QDomElement queryElement = element.firstChildElement(QSL("query"));
+    if (element.tagName() == QStringLiteral("iq")) {
+        QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
         if (!queryElement.isNull() && queryElement.namespaceURI() == ns_mam) {
             return true;
         }
@@ -118,14 +118,14 @@ bool QXmppMamQueryIq::isMamQueryIq(const QDomElement &element)
 
 void QXmppMamQueryIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    d->node = queryElement.attribute(QSL("node"));
-    d->queryId = queryElement.attribute(QSL("queryId"));
-    QDomElement resultSetElement = queryElement.firstChildElement(QSL("set"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    d->node = queryElement.attribute(QStringLiteral("node"));
+    d->queryId = queryElement.attribute(QStringLiteral("queryId"));
+    QDomElement resultSetElement = queryElement.firstChildElement(QStringLiteral("set"));
     if (!resultSetElement.isNull()) {
         d->resultSetQuery.parse(resultSetElement);
     }
-    QDomElement formElement = queryElement.firstChildElement(QSL("x"));
+    QDomElement formElement = queryElement.firstChildElement(QStringLiteral("x"));
     if (!formElement.isNull()) {
         d->form.parse(formElement);
     }
@@ -133,13 +133,13 @@ void QXmppMamQueryIq::parseElementFromChild(const QDomElement &element)
 
 void QXmppMamQueryIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_mam);
     if (!d->node.isEmpty()) {
-        writer->writeAttribute(QSL("node"), d->node);
+        writer->writeAttribute(QStringLiteral("node"), d->node);
     }
     if (!d->queryId.isEmpty()) {
-        writer->writeAttribute(QSL("queryid"), d->queryId);
+        writer->writeAttribute(QStringLiteral("queryid"), d->queryId);
     }
     d->form.toXml(writer);
     d->resultSetQuery.toXml(writer);
@@ -195,8 +195,8 @@ void QXmppMamResultIq::setComplete(bool complete)
 /// \cond
 bool QXmppMamResultIq::isMamResultIq(const QDomElement &element)
 {
-    if (element.tagName() == QSL("iq")) {
-        QDomElement finElement = element.firstChildElement(QSL("fin"));
+    if (element.tagName() == QStringLiteral("iq")) {
+        QDomElement finElement = element.firstChildElement(QStringLiteral("fin"));
         if (!finElement.isNull() && finElement.namespaceURI() == ns_mam) {
             return true;
         }
@@ -206,9 +206,9 @@ bool QXmppMamResultIq::isMamResultIq(const QDomElement &element)
 
 void QXmppMamResultIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement finElement = element.firstChildElement(QSL("fin"));
-    d->complete = finElement.attribute(QSL("complete")) == QSL("true");
-    QDomElement resultSetElement = finElement.firstChildElement(QSL("set"));
+    QDomElement finElement = element.firstChildElement(QStringLiteral("fin"));
+    d->complete = finElement.attribute(QStringLiteral("complete")) == QStringLiteral("true");
+    QDomElement resultSetElement = finElement.firstChildElement(QStringLiteral("set"));
     if (!resultSetElement.isNull()) {
         d->resultSetReply.parse(resultSetElement);
     }
@@ -216,10 +216,10 @@ void QXmppMamResultIq::parseElementFromChild(const QDomElement &element)
 
 void QXmppMamResultIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("fin"));
+    writer->writeStartElement(QStringLiteral("fin"));
     writer->writeDefaultNamespace(ns_mam);
     if (d->complete) {
-        writer->writeAttribute(QSL("complete"), QSL("true"));
+        writer->writeAttribute(QStringLiteral("complete"), QStringLiteral("true"));
     }
     d->resultSetReply.toXml(writer);
     writer->writeEndElement();
diff --git a/src/base/QXmppMessage.cpp b/src/base/QXmppMessage.cpp
index 3a9b67f8..df45d17b 100644
--- a/src/base/QXmppMessage.cpp
+++ b/src/base/QXmppMessage.cpp
@@ -36,26 +36,26 @@
 
 static const QStringList CHAT_STATES = {
     QString(),
-    QSL("active"),
-    QSL("inactive"),
-    QSL("gone"),
-    QSL("composing"),
-    QSL("paused")
+    QStringLiteral("active"),
+    QStringLiteral("inactive"),
+    QStringLiteral("gone"),
+    QStringLiteral("composing"),
+    QStringLiteral("paused")
 };
 
 static const QStringList MESSAGE_TYPES = {
-    QSL("error"),
-    QSL("normal"),
-    QSL("chat"),
-    QSL("groupchat"),
-    QSL("headline")
+    QStringLiteral("error"),
+    QStringLiteral("normal"),
+    QStringLiteral("chat"),
+    QStringLiteral("groupchat"),
+    QStringLiteral("headline")
 };
 
 static const QStringList MARKER_TYPES = {
     QString(),
-    QSL("received"),
-    QSL("displayed"),
-    QSL("acknowledged")
+    QStringLiteral("received"),
+    QStringLiteral("displayed"),
+    QStringLiteral("acknowledged")
 };
 
 static const QStringList ENCRYPTION_NAMESPACES = {
@@ -68,19 +68,19 @@ static const QStringList ENCRYPTION_NAMESPACES = {
 };
 
 static const QStringList HINT_TYPES = {
-    QSL("no-permanent-store"),
-    QSL("no-store"),
-    QSL("no-copy"),
-    QSL("store")
+    QStringLiteral("no-permanent-store"),
+    QStringLiteral("no-store"),
+    QStringLiteral("no-copy"),
+    QStringLiteral("store")
 };
 
 static const QStringList ENCRYPTION_NAMES = {
     QString(),
     QString(),
-    QSL("OTR"),
-    QSL("Legacy OpenPGP"),
-    QSL("OpenPGP for XMPP (OX)"),
-    QSL("OMEMO")
+    QStringLiteral("OTR"),
+    QStringLiteral("Legacy OpenPGP"),
+    QStringLiteral("OpenPGP for XMPP (OX)"),
+    QStringLiteral("OMEMO")
 };
 
 static bool checkElement(const QDomElement &element, const QString &tagName, const QString &xmlns)
@@ -905,7 +905,7 @@ void QXmppMessage::parse(const QDomElement &element)
     QXmppStanza::parse(element);
 
     // message type
-    int messageType = MESSAGE_TYPES.indexOf(element.attribute(QSL("type")));
+    int messageType = MESSAGE_TYPES.indexOf(element.attribute(QStringLiteral("type")));
     if (messageType != -1)
         d->type = static_cast<Type>(messageType);
     else
@@ -914,16 +914,16 @@ void QXmppMessage::parse(const QDomElement &element)
     QXmppElementList extensions;
     QDomElement childElement = element.firstChildElement();
     while (!childElement.isNull()) {
-        if (childElement.tagName() == QSL("body")) {
+        if (childElement.tagName() == QStringLiteral("body")) {
             d->body = childElement.text();
-        } else if (childElement.tagName() == QSL("subject")) {
+        } else if (childElement.tagName() == QStringLiteral("subject")) {
             d->subject = childElement.text();
-        } else if (childElement.tagName() == QSL("thread")) {
+        } else if (childElement.tagName() == QStringLiteral("thread")) {
             d->thread = childElement.text();
             // parse message extensions
             // XEP-0033: Extended Stanza Addressing and errors are parsed by QXmppStanza
-        } else if (!checkElement(childElement, QSL("addresses"), ns_extended_addressing) &&
-                   childElement.tagName() != QSL("error")) {
+        } else if (!checkElement(childElement, QStringLiteral("addresses"), ns_extended_addressing) &&
+                   childElement.tagName() != QStringLiteral("error")) {
             parseExtension(childElement, extensions);
         }
         childElement = childElement.nextSiblingElement();
@@ -933,18 +933,18 @@ void QXmppMessage::parse(const QDomElement &element)
 
 void QXmppMessage::toXml(QXmlStreamWriter *xmlWriter) const
 {
-    xmlWriter->writeStartElement(QSL("message"));
-    helperToXmlAddAttribute(xmlWriter, QSL("xml:lang"), lang());
-    helperToXmlAddAttribute(xmlWriter, QSL("id"), id());
-    helperToXmlAddAttribute(xmlWriter, QSL("to"), to());
-    helperToXmlAddAttribute(xmlWriter, QSL("from"), from());
-    helperToXmlAddAttribute(xmlWriter, QSL("type"), MESSAGE_TYPES.at(d->type));
+    xmlWriter->writeStartElement(QStringLiteral("message"));
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("xml:lang"), lang());
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("id"), id());
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("to"), to());
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("from"), from());
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("type"), MESSAGE_TYPES.at(d->type));
     if (!d->subject.isEmpty())
-        helperToXmlAddTextElement(xmlWriter, QSL("subject"), d->subject);
+        helperToXmlAddTextElement(xmlWriter, QStringLiteral("subject"), d->subject);
     if (!d->body.isEmpty())
-        helperToXmlAddTextElement(xmlWriter, QSL("body"), d->body);
+        helperToXmlAddTextElement(xmlWriter, QStringLiteral("body"), d->body);
     if (!d->thread.isEmpty())
-        helperToXmlAddTextElement(xmlWriter, QSL("thread"), d->thread);
+        helperToXmlAddTextElement(xmlWriter, QStringLiteral("thread"), d->thread);
     error().toXml(xmlWriter);
 
     // chat states
@@ -956,11 +956,11 @@ void QXmppMessage::toXml(QXmlStreamWriter *xmlWriter) const
 
     // XEP-0071: XHTML-IM
     if (!d->xhtml.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("html"));
+        xmlWriter->writeStartElement(QStringLiteral("html"));
         xmlWriter->writeDefaultNamespace(ns_xhtml_im);
-        xmlWriter->writeStartElement(QSL("body"));
+        xmlWriter->writeStartElement(QStringLiteral("body"));
         xmlWriter->writeDefaultNamespace(ns_xhtml);
-        xmlWriter->writeCharacters(QSL(""));
+        xmlWriter->writeCharacters(QStringLiteral(""));
         xmlWriter->device()->write(d->xhtml.toUtf8());
         xmlWriter->writeEndElement();
         xmlWriter->writeEndElement();
@@ -971,63 +971,63 @@ void QXmppMessage::toXml(QXmlStreamWriter *xmlWriter) const
         QDateTime utcStamp = d->stamp.toUTC();
         if (d->stampType == DelayedDelivery) {
             // XEP-0203: Delayed Delivery
-            xmlWriter->writeStartElement(QSL("delay"));
+            xmlWriter->writeStartElement(QStringLiteral("delay"));
             xmlWriter->writeDefaultNamespace(ns_delayed_delivery);
-            helperToXmlAddAttribute(xmlWriter, QSL("stamp"), QXmppUtils::datetimeToString(utcStamp));
+            helperToXmlAddAttribute(xmlWriter, QStringLiteral("stamp"), QXmppUtils::datetimeToString(utcStamp));
             xmlWriter->writeEndElement();
         } else {
             // XEP-0091: Legacy Delayed Delivery
-            xmlWriter->writeStartElement(QSL("x"));
+            xmlWriter->writeStartElement(QStringLiteral("x"));
             xmlWriter->writeDefaultNamespace(ns_legacy_delayed_delivery);
-            helperToXmlAddAttribute(xmlWriter, QSL("stamp"), utcStamp.toString(QSL("yyyyMMddThh:mm:ss")));
+            helperToXmlAddAttribute(xmlWriter, QStringLiteral("stamp"), utcStamp.toString(QStringLiteral("yyyyMMddThh:mm:ss")));
             xmlWriter->writeEndElement();
         }
     }
 
     // XEP-0184: Message Delivery Receipts
     if (!d->receiptId.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("received"));
+        xmlWriter->writeStartElement(QStringLiteral("received"));
         xmlWriter->writeDefaultNamespace(ns_message_receipts);
-        xmlWriter->writeAttribute(QSL("id"), d->receiptId);
+        xmlWriter->writeAttribute(QStringLiteral("id"), d->receiptId);
         xmlWriter->writeEndElement();
     }
     if (d->receiptRequested) {
-        xmlWriter->writeStartElement(QSL("request"));
+        xmlWriter->writeStartElement(QStringLiteral("request"));
         xmlWriter->writeDefaultNamespace(ns_message_receipts);
         xmlWriter->writeEndElement();
     }
 
     // \xep{0224}: Attention
     if (d->attentionRequested) {
-        xmlWriter->writeStartElement(QSL("attention"));
+        xmlWriter->writeStartElement(QStringLiteral("attention"));
         xmlWriter->writeDefaultNamespace(ns_attention);
         xmlWriter->writeEndElement();
     }
 
     // XEP-0249: Direct MUC Invitations
     if (!d->mucInvitationJid.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("x"));
+        xmlWriter->writeStartElement(QStringLiteral("x"));
         xmlWriter->writeDefaultNamespace(ns_conference);
-        xmlWriter->writeAttribute(QSL("jid"), d->mucInvitationJid);
+        xmlWriter->writeAttribute(QStringLiteral("jid"), d->mucInvitationJid);
         if (!d->mucInvitationPassword.isEmpty())
-            xmlWriter->writeAttribute(QSL("password"), d->mucInvitationPassword);
+            xmlWriter->writeAttribute(QStringLiteral("password"), d->mucInvitationPassword);
         if (!d->mucInvitationReason.isEmpty())
-            xmlWriter->writeAttribute(QSL("reason"), d->mucInvitationReason);
+            xmlWriter->writeAttribute(QStringLiteral("reason"), d->mucInvitationReason);
         xmlWriter->writeEndElement();
     }
 
     // XEP-0333: Chat Markers
     if (d->markable) {
-        xmlWriter->writeStartElement(QSL("markable"));
+        xmlWriter->writeStartElement(QStringLiteral("markable"));
         xmlWriter->writeDefaultNamespace(ns_chat_markers);
         xmlWriter->writeEndElement();
     }
     if (d->marker != NoMarker) {
         xmlWriter->writeStartElement(MARKER_TYPES.at(d->marker));
         xmlWriter->writeDefaultNamespace(ns_chat_markers);
-        xmlWriter->writeAttribute(QSL("id"), d->markedId);
+        xmlWriter->writeAttribute(QStringLiteral("id"), d->markedId);
         if (!d->markedThread.isNull() && !d->markedThread.isEmpty()) {
-            xmlWriter->writeAttribute(QSL("thread"), d->markedThread);
+            xmlWriter->writeAttribute(QStringLiteral("thread"), d->markedThread);
         }
         xmlWriter->writeEndElement();
     }
@@ -1038,24 +1038,24 @@ void QXmppMessage::toXml(QXmlStreamWriter *xmlWriter) const
 
     // XEP-0280: Message Carbons
     if (d->privatemsg) {
-        xmlWriter->writeStartElement(QSL("private"));
+        xmlWriter->writeStartElement(QStringLiteral("private"));
         xmlWriter->writeDefaultNamespace(ns_carbons);
         xmlWriter->writeEndElement();
     }
 
     // XEP-0066: Out of Band Data
     if (!d->outOfBandUrl.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("x"));
+        xmlWriter->writeStartElement(QStringLiteral("x"));
         xmlWriter->writeDefaultNamespace(ns_oob);
-        xmlWriter->writeTextElement(QSL("url"), d->outOfBandUrl);
+        xmlWriter->writeTextElement(QStringLiteral("url"), d->outOfBandUrl);
         xmlWriter->writeEndElement();
     }
 
     // XEP-0308: Last Message Correction
     if (!d->replaceId.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("replace"));
+        xmlWriter->writeStartElement(QStringLiteral("replace"));
         xmlWriter->writeDefaultNamespace(ns_message_correct);
-        xmlWriter->writeAttribute(QSL("id"), d->replaceId);
+        xmlWriter->writeAttribute(QStringLiteral("id"), d->replaceId);
         xmlWriter->writeEndElement();
     }
 
@@ -1070,50 +1070,50 @@ void QXmppMessage::toXml(QXmlStreamWriter *xmlWriter) const
 
     // XEP-0359: Unique and Stable Stanza IDs
     if (!d->stanzaId.isNull()) {
-        xmlWriter->writeStartElement(QSL("stanza-id"));
+        xmlWriter->writeStartElement(QStringLiteral("stanza-id"));
         xmlWriter->writeDefaultNamespace(ns_sid);
-        xmlWriter->writeAttribute(QSL("id"), d->stanzaId);
+        xmlWriter->writeAttribute(QStringLiteral("id"), d->stanzaId);
         if (!d->stanzaIdBy.isNull())
-            xmlWriter->writeAttribute(QSL("by"), d->stanzaIdBy);
+            xmlWriter->writeAttribute(QStringLiteral("by"), d->stanzaIdBy);
         xmlWriter->writeEndElement();
     }
 
     if (!d->originId.isNull()) {
-        xmlWriter->writeStartElement(QSL("origin-id"));
+        xmlWriter->writeStartElement(QStringLiteral("origin-id"));
         xmlWriter->writeDefaultNamespace(ns_sid);
-        xmlWriter->writeAttribute(QSL("id"), d->originId);
+        xmlWriter->writeAttribute(QStringLiteral("id"), d->originId);
         xmlWriter->writeEndElement();
     }
 
     // XEP-0367: Message Attaching
     if (!d->attachId.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("attach-to"));
+        xmlWriter->writeStartElement(QStringLiteral("attach-to"));
         xmlWriter->writeDefaultNamespace(ns_message_attaching);
-        xmlWriter->writeAttribute(QSL("id"), d->attachId);
+        xmlWriter->writeAttribute(QStringLiteral("id"), d->attachId);
         xmlWriter->writeEndElement();
     }
 
     // XEP-0369: Mediated Information eXchange (MIX)
     if (!d->mixUserJid.isEmpty() || !d->mixUserNick.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("mix"));
+        xmlWriter->writeStartElement(QStringLiteral("mix"));
         xmlWriter->writeDefaultNamespace(ns_mix);
-        helperToXmlAddTextElement(xmlWriter, QSL("jid"), d->mixUserJid);
-        helperToXmlAddTextElement(xmlWriter, QSL("nick"), d->mixUserNick);
+        helperToXmlAddTextElement(xmlWriter, QStringLiteral("jid"), d->mixUserJid);
+        helperToXmlAddTextElement(xmlWriter, QStringLiteral("nick"), d->mixUserNick);
         xmlWriter->writeEndElement();
     }
 
     // XEP-0380: Explicit Message Encryption
     if (!d->encryptionMethod.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("encryption"));
+        xmlWriter->writeStartElement(QStringLiteral("encryption"));
         xmlWriter->writeDefaultNamespace(ns_eme);
-        xmlWriter->writeAttribute(QSL("namespace"), d->encryptionMethod);
-        helperToXmlAddAttribute(xmlWriter, QSL("name"), d->encryptionName);
+        xmlWriter->writeAttribute(QStringLiteral("namespace"), d->encryptionMethod);
+        helperToXmlAddAttribute(xmlWriter, QStringLiteral("name"), d->encryptionName);
         xmlWriter->writeEndElement();
     }
 
     // XEP-0382: Spoiler messages
     if (d->isSpoiler) {
-        xmlWriter->writeStartElement(QSL("spoiler"));
+        xmlWriter->writeStartElement(QStringLiteral("spoiler"));
         xmlWriter->writeDefaultNamespace(ns_spoiler);
         xmlWriter->writeCharacters(d->spoilerHint);
         xmlWriter->writeEndElement();
@@ -1121,7 +1121,7 @@ void QXmppMessage::toXml(QXmlStreamWriter *xmlWriter) const
 
     // XEP-0428: Fallback Indication
     if (d->isFallback) {
-        xmlWriter->writeStartElement(QSL("fallback"));
+        xmlWriter->writeStartElement(QStringLiteral("fallback"));
         xmlWriter->writeDefaultNamespace(ns_fallback_indication);
         xmlWriter->writeEndElement();
     }
@@ -1140,20 +1140,20 @@ void QXmppMessage::toXml(QXmlStreamWriter *xmlWriter) const
 
 void QXmppMessage::parseExtension(const QDomElement &element, QXmppElementList &unknownExtensions)
 {
-    if (element.tagName() == QSL("x")) {
+    if (element.tagName() == QStringLiteral("x")) {
         parseXElement(element, unknownExtensions);
         // XEP-0071: XHTML-IM
-    } else if (checkElement(element, QSL("html"), ns_xhtml_im)) {
-        QDomElement bodyElement = element.firstChildElement(QSL("body"));
+    } else if (checkElement(element, QStringLiteral("html"), ns_xhtml_im)) {
+        QDomElement bodyElement = element.firstChildElement(QStringLiteral("body"));
         if (!bodyElement.isNull() && bodyElement.namespaceURI() == ns_xhtml) {
             QTextStream stream(&d->xhtml, QIODevice::WriteOnly);
             bodyElement.save(stream, 0);
 
             d->xhtml = d->xhtml.mid(d->xhtml.indexOf('>') + 1);
             d->xhtml.replace(
-                QSL(" xmlns=\"http://www.w3.org/1999/xhtml\""),
+                QStringLiteral(" xmlns=\"http://www.w3.org/1999/xhtml\""),
                 QString());
-            d->xhtml.replace(QSL("</body>"), QString());
+            d->xhtml.replace(QStringLiteral("</body>"), QString());
             d->xhtml = d->xhtml.trimmed();
         }
         // XEP-0085: Chat State Notifications
@@ -1162,21 +1162,21 @@ void QXmppMessage::parseExtension(const QDomElement &element, QXmppElementList &
         if (i > 0)
             d->state = static_cast<QXmppMessage::State>(i);
         // XEP-0184: Message Delivery Receipts
-    } else if (checkElement(element, QSL("received"), ns_message_receipts)) {
-        d->receiptId = element.attribute(QSL("id"));
+    } else if (checkElement(element, QStringLiteral("received"), ns_message_receipts)) {
+        d->receiptId = element.attribute(QStringLiteral("id"));
 
         // compatibility with old-style XEP
         if (d->receiptId.isEmpty())
             d->receiptId = id();
-    } else if (checkElement(element, QSL("request"), ns_message_receipts)) {
+    } else if (checkElement(element, QStringLiteral("request"), ns_message_receipts)) {
         d->receiptRequested = true;
         // XEP-0203: Delayed Delivery
-    } else if (checkElement(element, QSL("delay"), ns_delayed_delivery)) {
+    } else if (checkElement(element, QStringLiteral("delay"), ns_delayed_delivery)) {
         d->stamp = QXmppUtils::datetimeFromString(
-            element.attribute(QSL("stamp")));
+            element.attribute(QStringLiteral("stamp")));
         d->stampType = DelayedDelivery;
         // \xep{0224}: Attention
-    } else if (checkElement(element, QSL("attention"), ns_attention)) {
+    } else if (checkElement(element, QStringLiteral("attention"), ns_attention)) {
         d->attentionRequested = true;
         // XEP-0231: Bits of Binary
     } else if (QXmppBitsOfBinaryData::isBitsOfBinaryData(element)) {
@@ -1184,49 +1184,49 @@ void QXmppMessage::parseExtension(const QDomElement &element, QXmppElementList &
         data.parseElementFromChild(element);
         d->bitsOfBinaryData << data;
         // XEP-0280: Message Carbons
-    } else if (checkElement(element, QSL("private"), ns_carbons)) {
+    } else if (checkElement(element, QStringLiteral("private"), ns_carbons)) {
         d->privatemsg = true;
         // XEP-0308: Last Message Correction
-    } else if (checkElement(element, QSL("replace"), ns_message_correct)) {
-        d->replaceId = element.attribute(QSL("id"));
+    } else if (checkElement(element, QStringLiteral("replace"), ns_message_correct)) {
+        d->replaceId = element.attribute(QStringLiteral("id"));
         // XEP-0333: Chat Markers
     } else if (element.namespaceURI() == ns_chat_markers) {
-        if (element.tagName() == QSL("markable")) {
+        if (element.tagName() == QStringLiteral("markable")) {
             d->markable = true;
         } else {
             int marker = MARKER_TYPES.indexOf(element.tagName());
             if (marker != -1) {
                 d->marker = static_cast<QXmppMessage::Marker>(marker);
-                d->markedId = element.attribute(QSL("id"));
-                d->markedThread = element.attribute(QSL("thread"));
+                d->markedId = element.attribute(QStringLiteral("id"));
+                d->markedThread = element.attribute(QStringLiteral("thread"));
             }
         }
         // XEP-0334: Message Processing Hints
     } else if (element.namespaceURI() == ns_message_processing_hints &&
                HINT_TYPES.contains(element.tagName())) {
         addHint(Hint(1 << HINT_TYPES.indexOf(element.tagName())));
-    } else if (checkElement(element, QSL("stanza-id"), ns_sid)) {
+    } else if (checkElement(element, QStringLiteral("stanza-id"), ns_sid)) {
         // XEP-0359: Unique and Stable Stanza IDs
-        d->stanzaId = element.attribute(QSL("id"));
-        d->stanzaIdBy = element.attribute(QSL("by"));
-    } else if (checkElement(element, QSL("origin-id"), ns_sid)) {
-        d->originId = element.attribute(QSL("id"));
-    } else if (checkElement(element, QSL("attach-to"), ns_message_attaching)) {
+        d->stanzaId = element.attribute(QStringLiteral("id"));
+        d->stanzaIdBy = element.attribute(QStringLiteral("by"));
+    } else if (checkElement(element, QStringLiteral("origin-id"), ns_sid)) {
+        d->originId = element.attribute(QStringLiteral("id"));
+    } else if (checkElement(element, QStringLiteral("attach-to"), ns_message_attaching)) {
         // XEP-0367: Message Attaching
-        d->attachId = element.attribute(QSL("id"));
+        d->attachId = element.attribute(QStringLiteral("id"));
         // XEP-0369: Mediated Information eXchange (MIX)
-    } else if (checkElement(element, QSL("mix"), ns_mix)) {
-        d->mixUserJid = element.firstChildElement(QSL("jid")).text();
-        d->mixUserNick = element.firstChildElement(QSL("nick")).text();
+    } else if (checkElement(element, QStringLiteral("mix"), ns_mix)) {
+        d->mixUserJid = element.firstChildElement(QStringLiteral("jid")).text();
+        d->mixUserNick = element.firstChildElement(QStringLiteral("nick")).text();
         // XEP-0380: Explicit Message Encryption
-    } else if (checkElement(element, QSL("encryption"), ns_eme)) {
-        d->encryptionMethod = element.attribute(QSL("namespace"));
-        d->encryptionName = element.attribute(QSL("name"));
+    } else if (checkElement(element, QStringLiteral("encryption"), ns_eme)) {
+        d->encryptionMethod = element.attribute(QStringLiteral("namespace"));
+        d->encryptionName = element.attribute(QStringLiteral("name"));
         // XEP-0382: Spoiler messages
-    } else if (checkElement(element, QSL("spoiler"), ns_spoiler)) {
+    } else if (checkElement(element, QStringLiteral("spoiler"), ns_spoiler)) {
         d->isSpoiler = true;
         d->spoilerHint = element.text();
-    } else if (checkElement(element, QSL("fallback"), ns_fallback_indication)) {
+    } else if (checkElement(element, QStringLiteral("fallback"), ns_fallback_indication)) {
         // XEP-0428: Fallback Indication
         d->isFallback = true;
     } else {
@@ -1248,19 +1248,19 @@ void QXmppMessage::parseXElement(const QDomElement &element, QXmppElementList &u
         if (d->stamp.isNull()) {
             // XEP-0091: Legacy Delayed Delivery
             d->stamp = QDateTime::fromString(
-                element.attribute(QSL("stamp")),
-                QSL("yyyyMMddThh:mm:ss"));
+                element.attribute(QStringLiteral("stamp")),
+                QStringLiteral("yyyyMMddThh:mm:ss"));
             d->stamp.setTimeSpec(Qt::UTC);
             d->stampType = LegacyDelayedDelivery;
         }
     } else if (element.namespaceURI() == ns_conference) {
         // XEP-0249: Direct MUC Invitations
-        d->mucInvitationJid = element.attribute(QSL("jid"));
-        d->mucInvitationPassword = element.attribute(QSL("password"));
-        d->mucInvitationReason = element.attribute(QSL("reason"));
+        d->mucInvitationJid = element.attribute(QStringLiteral("jid"));
+        d->mucInvitationPassword = element.attribute(QStringLiteral("password"));
+        d->mucInvitationReason = element.attribute(QStringLiteral("reason"));
     } else if (element.namespaceURI() == ns_oob) {
         // XEP-0066: Out of Band Data
-        d->outOfBandUrl = element.firstChildElement(QSL("url")).text();
+        d->outOfBandUrl = element.firstChildElement(QStringLiteral("url")).text();
     } else {
         unknownExtensions << QXmppElement(element);
     }
diff --git a/src/base/QXmppMixIq.cpp b/src/base/QXmppMixIq.cpp
index 468d2d57..1575f721 100644
--- a/src/base/QXmppMixIq.cpp
+++ b/src/base/QXmppMixIq.cpp
@@ -32,14 +32,14 @@
 
 static const QStringList MIX_ACTION_TYPES = {
     QString(),
-    QSL("client-join"),
-    QSL("client-leave"),
-    QSL("join"),
-    QSL("leave"),
-    QSL("update-subscription"),
-    QSL("setnick"),
-    QSL("create"),
-    QSL("destroy")
+    QStringLiteral("client-join"),
+    QStringLiteral("client-leave"),
+    QStringLiteral("join"),
+    QStringLiteral("leave"),
+    QStringLiteral("update-subscription"),
+    QStringLiteral("setnick"),
+    QStringLiteral("create"),
+    QStringLiteral("destroy")
 };
 
 class QXmppMixIqPrivate : public QSharedData
@@ -153,23 +153,23 @@ void QXmppMixIq::parseElementFromChild(const QDomElement& element)
     d->actionType = (QXmppMixIq::Type)MIX_ACTION_TYPES.indexOf(child.tagName());
 
     if (child.namespaceURI() == ns_mix_pam) {
-        if (child.hasAttribute(QSL("channel")))
-            d->jid = child.attribute(QSL("channel"));
+        if (child.hasAttribute(QStringLiteral("channel")))
+            d->jid = child.attribute(QStringLiteral("channel"));
 
         child = child.firstChildElement();
     }
 
     if (!child.isNull() && child.namespaceURI() == ns_mix) {
-        if (child.hasAttribute(QSL("jid")))
-            d->jid = child.attribute(QSL("jid"));
-        if (child.hasAttribute(QSL("channel")))
-            d->channelName = child.attribute(QSL("channel"));
+        if (child.hasAttribute(QStringLiteral("jid")))
+            d->jid = child.attribute(QStringLiteral("jid"));
+        if (child.hasAttribute(QStringLiteral("channel")))
+            d->channelName = child.attribute(QStringLiteral("channel"));
 
         QDomElement subChild = child.firstChildElement();
         while (!subChild.isNull()) {
-            if (subChild.tagName() == QSL("subscribe"))
-                d->nodes << subChild.attribute(QSL("node"));
-            else if (subChild.tagName() == QSL("nick"))
+            if (subChild.tagName() == QStringLiteral("subscribe"))
+                d->nodes << subChild.attribute(QStringLiteral("node"));
+            else if (subChild.tagName() == QStringLiteral("nick"))
                 d->nick = subChild.text();
 
             subChild = subChild.nextSiblingElement();
@@ -186,26 +186,26 @@ void QXmppMixIq::toXmlElementFromChild(QXmlStreamWriter* writer) const
     if (d->actionType == ClientJoin || d->actionType == ClientLeave) {
         writer->writeDefaultNamespace(ns_mix_pam);
         if (type() == Set)
-            helperToXmlAddAttribute(writer, QSL("channel"), d->jid);
+            helperToXmlAddAttribute(writer, QStringLiteral("channel"), d->jid);
 
         if (d->actionType == ClientJoin)
-            writer->writeStartElement(QSL("join"));
+            writer->writeStartElement(QStringLiteral("join"));
         else if (d->actionType == ClientLeave)
-            writer->writeStartElement(QSL("leave"));
+            writer->writeStartElement(QStringLiteral("leave"));
     }
 
     writer->writeDefaultNamespace(ns_mix);
-    helperToXmlAddAttribute(writer, QSL("channel"), d->channelName);
+    helperToXmlAddAttribute(writer, QStringLiteral("channel"), d->channelName);
     if (type() == Result)
-        helperToXmlAddAttribute(writer, QSL("jid"), d->jid);
+        helperToXmlAddAttribute(writer, QStringLiteral("jid"), d->jid);
 
     for (const auto& node : d->nodes) {
-        writer->writeStartElement(QSL("subscribe"));
-        writer->writeAttribute(QSL("node"), node);
+        writer->writeStartElement(QStringLiteral("subscribe"));
+        writer->writeAttribute(QStringLiteral("node"), node);
         writer->writeEndElement();
     }
     if (!d->nick.isEmpty())
-        writer->writeTextElement(QSL("nick"), d->nick);
+        writer->writeTextElement(QStringLiteral("nick"), d->nick);
 
     writer->writeEndElement();
     if (d->actionType == ClientJoin || d->actionType == ClientLeave)
diff --git a/src/base/QXmppMixItem.cpp b/src/base/QXmppMixItem.cpp
index 2a5e214d..5b4c6029 100644
--- a/src/base/QXmppMixItem.cpp
+++ b/src/base/QXmppMixItem.cpp
@@ -100,7 +100,7 @@ bool QXmppMixInfoItem::isMixChannelInfo(const QDomElement& element)
     QXmppDataForm form;
     form.parse(element);
     for (const auto& field : form.fields()) {
-        if (field.key() == QSL("FORM_TYPE"))
+        if (field.key() == QStringLiteral("FORM_TYPE"))
             return field.value() == ns_mix;
     }
     return false;
@@ -112,11 +112,11 @@ void QXmppMixInfoItem::parse(const QXmppElement& element)
     form.parse(element.sourceDomElement());
 
     for (auto& field : form.fields()) {
-        if (field.key() == QSL("Name"))
+        if (field.key() == QStringLiteral("Name"))
             d->name = field.value().toString();
-        else if (field.key() == QSL("Description"))
+        else if (field.key() == QStringLiteral("Description"))
             d->description = field.value().toString();
-        else if (field.key() == QSL("Contact"))
+        else if (field.key() == QStringLiteral("Contact"))
             d->contactJids = field.value().toStringList();
     }
 }
@@ -129,22 +129,22 @@ QXmppElement QXmppMixInfoItem::toElement() const
 
     QXmppDataForm::Field formType;
     formType.setType(QXmppDataForm::Field::HiddenField);
-    formType.setKey(QSL("FORM_TYPE"));
+    formType.setKey(QStringLiteral("FORM_TYPE"));
     formType.setValue(ns_mix);
     fields << formType;
 
     QXmppDataForm::Field nameField;
-    nameField.setKey(QSL("Name"));
+    nameField.setKey(QStringLiteral("Name"));
     nameField.setValue(d->name);
     fields << nameField;
 
     QXmppDataForm::Field descriptionField;
-    descriptionField.setKey(QSL("Description"));
+    descriptionField.setKey(QStringLiteral("Description"));
     descriptionField.setValue(d->description);
     fields << descriptionField;
 
     QXmppDataForm::Field contactsField;
-    contactsField.setKey(QSL("Contact"));
+    contactsField.setKey(QStringLiteral("Contact"));
     contactsField.setValue(d->contactJids);
     contactsField.setType(QXmppDataForm::Field::JidMultiField);
     fields << contactsField;
@@ -210,23 +210,23 @@ void QXmppMixParticipantItem::setJid(const QString& jid)
 
 void QXmppMixParticipantItem::parse(const QXmppElement& itemContent)
 {
-    d->nick = itemContent.firstChildElement(QSL("nick")).value();
-    d->jid = itemContent.firstChildElement(QSL("jid")).value();
+    d->nick = itemContent.firstChildElement(QStringLiteral("nick")).value();
+    d->jid = itemContent.firstChildElement(QStringLiteral("jid")).value();
 }
 
 QXmppElement QXmppMixParticipantItem::toElement() const
 {
     QXmppElement element;
-    element.setTagName(QSL("participant"));
-    element.setAttribute(QSL("xmlns"), ns_mix);
+    element.setTagName(QStringLiteral("participant"));
+    element.setAttribute(QStringLiteral("xmlns"), ns_mix);
 
     QXmppElement jid;
-    jid.setTagName(QSL("jid"));
+    jid.setTagName(QStringLiteral("jid"));
     jid.setValue(d->jid);
     element.appendChild(jid);
 
     QXmppElement nick;
-    nick.setTagName(QSL("nick"));
+    nick.setTagName(QStringLiteral("nick"));
     nick.setValue(d->nick);
     element.appendChild(nick);
 
@@ -237,5 +237,5 @@ QXmppElement QXmppMixParticipantItem::toElement() const
 
 bool QXmppMixParticipantItem::isMixParticipantItem(const QDomElement& element)
 {
-    return element.tagName() == QSL("participant") && element.namespaceURI() == ns_mix;
+    return element.tagName() == QStringLiteral("participant") && element.namespaceURI() == ns_mix;
 }
diff --git a/src/base/QXmppMucIq.cpp b/src/base/QXmppMucIq.cpp
index 38606078..8a17cf49 100644
--- a/src/base/QXmppMucIq.cpp
+++ b/src/base/QXmppMucIq.cpp
@@ -72,15 +72,15 @@ QXmppMucItem::Affiliation QXmppMucItem::affiliation() const
 /// \cond
 QXmppMucItem::Affiliation QXmppMucItem::affiliationFromString(const QString &affiliationStr)
 {
-    if (affiliationStr == QSL("owner"))
+    if (affiliationStr == QStringLiteral("owner"))
         return QXmppMucItem::OwnerAffiliation;
-    else if (affiliationStr == QSL("admin"))
+    else if (affiliationStr == QStringLiteral("admin"))
         return QXmppMucItem::AdminAffiliation;
-    else if (affiliationStr == QSL("member"))
+    else if (affiliationStr == QStringLiteral("member"))
         return QXmppMucItem::MemberAffiliation;
-    else if (affiliationStr == QSL("outcast"))
+    else if (affiliationStr == QStringLiteral("outcast"))
         return QXmppMucItem::OutcastAffiliation;
-    else if (affiliationStr == QSL("none"))
+    else if (affiliationStr == QStringLiteral("none"))
         return QXmppMucItem::NoAffiliation;
     else
         return QXmppMucItem::UnspecifiedAffiliation;
@@ -172,13 +172,13 @@ QXmppMucItem::Role QXmppMucItem::role() const
 /// \cond
 QXmppMucItem::Role QXmppMucItem::roleFromString(const QString &roleStr)
 {
-    if (roleStr == QSL("moderator"))
+    if (roleStr == QStringLiteral("moderator"))
         return QXmppMucItem::ModeratorRole;
-    else if (roleStr == QSL("participant"))
+    else if (roleStr == QStringLiteral("participant"))
         return QXmppMucItem::ParticipantRole;
-    else if (roleStr == QSL("visitor"))
+    else if (roleStr == QStringLiteral("visitor"))
         return QXmppMucItem::VisitorRole;
-    else if (roleStr == QSL("none"))
+    else if (roleStr == QStringLiteral("none"))
         return QXmppMucItem::NoRole;
     else
         return QXmppMucItem::UnspecifiedRole;
@@ -188,13 +188,13 @@ QString QXmppMucItem::roleToString(Role role)
 {
     switch (role) {
     case QXmppMucItem::ModeratorRole:
-        return QSL("moderator");
+        return QStringLiteral("moderator");
     case QXmppMucItem::ParticipantRole:
-        return QSL("participant");
+        return QStringLiteral("participant");
     case QXmppMucItem::VisitorRole:
-        return QSL("visitor");
+        return QStringLiteral("visitor");
     case QXmppMucItem::NoRole:
-        return QSL("none");
+        return QStringLiteral("none");
     default:
         return QString();
     }
@@ -213,28 +213,28 @@ void QXmppMucItem::setRole(Role role)
 /// \cond
 void QXmppMucItem::parse(const QDomElement &element)
 {
-    m_affiliation = QXmppMucItem::affiliationFromString(element.attribute(QSL("affiliation")).toLower());
-    m_jid = element.attribute(QSL("jid"));
-    m_nick = element.attribute(QSL("nick"));
-    m_role = QXmppMucItem::roleFromString(element.attribute(QSL("role")).toLower());
-    m_actor = element.firstChildElement(QSL("actor")).attribute("jid");
-    m_reason = element.firstChildElement(QSL("reason")).text();
+    m_affiliation = QXmppMucItem::affiliationFromString(element.attribute(QStringLiteral("affiliation")).toLower());
+    m_jid = element.attribute(QStringLiteral("jid"));
+    m_nick = element.attribute(QStringLiteral("nick"));
+    m_role = QXmppMucItem::roleFromString(element.attribute(QStringLiteral("role")).toLower());
+    m_actor = element.firstChildElement(QStringLiteral("actor")).attribute("jid");
+    m_reason = element.firstChildElement(QStringLiteral("reason")).text();
 }
 
 void QXmppMucItem::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("item"));
-    helperToXmlAddAttribute(writer, QSL("affiliation"), affiliationToString(m_affiliation));
-    helperToXmlAddAttribute(writer, QSL("jid"), m_jid);
-    helperToXmlAddAttribute(writer, QSL("nick"), m_nick);
-    helperToXmlAddAttribute(writer, QSL("role"), roleToString(m_role));
+    writer->writeStartElement(QStringLiteral("item"));
+    helperToXmlAddAttribute(writer, QStringLiteral("affiliation"), affiliationToString(m_affiliation));
+    helperToXmlAddAttribute(writer, QStringLiteral("jid"), m_jid);
+    helperToXmlAddAttribute(writer, QStringLiteral("nick"), m_nick);
+    helperToXmlAddAttribute(writer, QStringLiteral("role"), roleToString(m_role));
     if (!m_actor.isEmpty()) {
-        writer->writeStartElement(QSL("actor"));
-        helperToXmlAddAttribute(writer, QSL("jid"), m_actor);
+        writer->writeStartElement(QStringLiteral("actor"));
+        helperToXmlAddAttribute(writer, QStringLiteral("jid"), m_actor);
         writer->writeEndElement();
     }
     if (!m_reason.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("reason"), m_reason);
+        helperToXmlAddTextElement(writer, QStringLiteral("reason"), m_reason);
     writer->writeEndElement();
 }
 /// \endcond
@@ -258,25 +258,25 @@ void QXmppMucAdminIq::setItems(const QList<QXmppMucItem> &items)
 /// \cond
 bool QXmppMucAdminIq::isMucAdminIq(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
     return (queryElement.namespaceURI() == ns_muc_admin);
 }
 
 void QXmppMucAdminIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    QDomElement child = queryElement.firstChildElement(QSL("item"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    QDomElement child = queryElement.firstChildElement(QStringLiteral("item"));
     while (!child.isNull()) {
         QXmppMucItem item;
         item.parse(child);
         m_items << item;
-        child = child.nextSiblingElement(QSL("item"));
+        child = child.nextSiblingElement(QStringLiteral("item"));
     }
 }
 
 void QXmppMucAdminIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_muc_admin);
     for (const QXmppMucItem &item : m_items)
         item.toXml(writer);
@@ -303,19 +303,19 @@ void QXmppMucOwnerIq::setForm(const QXmppDataForm &form)
 /// \cond
 bool QXmppMucOwnerIq::isMucOwnerIq(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
     return (queryElement.namespaceURI() == ns_muc_owner);
 }
 
 void QXmppMucOwnerIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    m_form.parse(queryElement.firstChildElement(QSL("x")));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    m_form.parse(queryElement.firstChildElement(QStringLiteral("x")));
 }
 
 void QXmppMucOwnerIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_muc_owner);
     m_form.toXml(writer);
     writer->writeEndElement();
diff --git a/src/base/QXmppNonSASLAuth.cpp b/src/base/QXmppNonSASLAuth.cpp
index eebb5a2e..bccf7121 100644
--- a/src/base/QXmppNonSASLAuth.cpp
+++ b/src/base/QXmppNonSASLAuth.cpp
@@ -78,31 +78,31 @@ void QXmppNonSASLAuthIq::setResource(const QString &resource)
 /// \cond
 bool QXmppNonSASLAuthIq::isNonSASLAuthIq(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
     return queryElement.namespaceURI() == ns_auth;
 }
 
 void QXmppNonSASLAuthIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    m_username = queryElement.firstChildElement(QSL("username")).text();
-    m_password = queryElement.firstChildElement(QSL("password")).text();
-    m_digest = QByteArray::fromHex(queryElement.firstChildElement(QSL("digest")).text().toLatin1());
-    m_resource = queryElement.firstChildElement(QSL("resource")).text();
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    m_username = queryElement.firstChildElement(QStringLiteral("username")).text();
+    m_password = queryElement.firstChildElement(QStringLiteral("password")).text();
+    m_digest = QByteArray::fromHex(queryElement.firstChildElement(QStringLiteral("digest")).text().toLatin1());
+    m_resource = queryElement.firstChildElement(QStringLiteral("resource")).text();
 }
 
 void QXmppNonSASLAuthIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_auth);
     if (!m_username.isEmpty())
-        writer->writeTextElement(QSL("username"), m_username);
+        writer->writeTextElement(QStringLiteral("username"), m_username);
     if (!m_digest.isEmpty())
-        writer->writeTextElement(QSL("digest"), m_digest.toHex());
+        writer->writeTextElement(QStringLiteral("digest"), m_digest.toHex());
     if (!m_password.isEmpty())
-        writer->writeTextElement(QSL("password"), m_password);
+        writer->writeTextElement(QStringLiteral("password"), m_password);
     if (!m_resource.isEmpty())
-        writer->writeTextElement(QSL("resource"), m_resource);
+        writer->writeTextElement(QStringLiteral("resource"), m_resource);
     writer->writeEndElement();
 }
 /// \endcond
diff --git a/src/base/QXmppPingIq.cpp b/src/base/QXmppPingIq.cpp
index e788e619..f277aae6 100644
--- a/src/base/QXmppPingIq.cpp
+++ b/src/base/QXmppPingIq.cpp
@@ -34,14 +34,14 @@ QXmppPingIq::QXmppPingIq() : QXmppIq(QXmppIq::Get)
 
 bool QXmppPingIq::isPingIq(const QDomElement &element)
 {
-    QDomElement pingElement = element.firstChildElement(QSL("ping"));
-    return (element.attribute(QSL("type")) == QSL("get") &&
+    QDomElement pingElement = element.firstChildElement(QStringLiteral("ping"));
+    return (element.attribute(QStringLiteral("type")) == QStringLiteral("get") &&
             pingElement.namespaceURI() == ns_ping);
 }
 
 void QXmppPingIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("ping"));
+    writer->writeStartElement(QStringLiteral("ping"));
     writer->writeDefaultNamespace(ns_ping);
     writer->writeEndElement();
 }
diff --git a/src/base/QXmppPresence.cpp b/src/base/QXmppPresence.cpp
index 4fd2e35b..207ac8b6 100644
--- a/src/base/QXmppPresence.cpp
+++ b/src/base/QXmppPresence.cpp
@@ -30,23 +30,23 @@
 #include <QDomElement>
 
 static const QStringList PRESENCE_TYPES = {
-    QSL("error"),
+    QStringLiteral("error"),
     QString(),
-    QSL("unavailable"),
-    QSL("subscribe"),
-    QSL("subscribed"),
-    QSL("unsubscribe"),
-    QSL("unsubscribed"),
-    QSL("probe")
+    QStringLiteral("unavailable"),
+    QStringLiteral("subscribe"),
+    QStringLiteral("subscribed"),
+    QStringLiteral("unsubscribe"),
+    QStringLiteral("unsubscribed"),
+    QStringLiteral("probe")
 };
 
 static const QStringList AVAILABLE_STATUS_TYPES = {
     QString(),
-    QSL("away"),
-    QSL("xa"),
-    QSL("dnd"),
-    QSL("chat"),
-    QSL("invisible")
+    QStringLiteral("away"),
+    QStringLiteral("xa"),
+    QStringLiteral("dnd"),
+    QStringLiteral("chat"),
+    QStringLiteral("invisible")
 };
 
 class QXmppPresencePrivate : public QSharedData
@@ -389,7 +389,7 @@ void QXmppPresence::parse(const QDomElement &element)
     QXmppStanza::parse(element);
 
     // attributes
-    int type = PRESENCE_TYPES.indexOf(element.attribute(QSL("type")));
+    int type = PRESENCE_TYPES.indexOf(element.attribute(QStringLiteral("type")));
     if (type > -1)
         d->type = Type(type);
 
@@ -397,17 +397,17 @@ void QXmppPresence::parse(const QDomElement &element)
     QDomElement childElement = element.firstChildElement();
 
     while (!childElement.isNull()) {
-        if (childElement.tagName() == QSL("show")) {
+        if (childElement.tagName() == QStringLiteral("show")) {
             int availableStatusType = AVAILABLE_STATUS_TYPES.indexOf(childElement.text());
             if (availableStatusType > -1)
                 d->availableStatusType = AvailableStatusType(availableStatusType);
-        } else if (childElement.tagName() == QSL("status")) {
+        } else if (childElement.tagName() == QStringLiteral("status")) {
             d->statusText = childElement.text();
-        } else if (childElement.tagName() == QSL("priority")) {
+        } else if (childElement.tagName() == QStringLiteral("priority")) {
             d->priority = childElement.text().toInt();
             // parse presence extensions
             // XEP-0033: Extended Stanza Addressing and errors are parsed by QXmppStanza
-        } else if (!(childElement.tagName() == QSL("addresses") && childElement.namespaceURI() == ns_extended_addressing) &&
+        } else if (!(childElement.tagName() == QStringLiteral("addresses") && childElement.namespaceURI() == ns_extended_addressing) &&
                    childElement.tagName() != "error") {
             parseExtension(childElement, unknownElements);
         }
@@ -420,28 +420,28 @@ void QXmppPresence::parse(const QDomElement &element)
 void QXmppPresence::parseExtension(const QDomElement &element, QXmppElementList &unknownElements)
 {
     // XEP-0045: Multi-User Chat
-    if (element.tagName() == QSL("x") && element.namespaceURI() == ns_muc) {
+    if (element.tagName() == QStringLiteral("x") && element.namespaceURI() == ns_muc) {
         d->mucSupported = true;
-        d->mucPassword = element.firstChildElement(QSL("password")).text();
-    } else if (element.tagName() == QSL("x") && element.namespaceURI() == ns_muc_user) {
-        QDomElement itemElement = element.firstChildElement(QSL("item"));
+        d->mucPassword = element.firstChildElement(QStringLiteral("password")).text();
+    } else if (element.tagName() == QStringLiteral("x") && element.namespaceURI() == ns_muc_user) {
+        QDomElement itemElement = element.firstChildElement(QStringLiteral("item"));
         d->mucItem.parse(itemElement);
-        QDomElement statusElement = element.firstChildElement(QSL("status"));
+        QDomElement statusElement = element.firstChildElement(QStringLiteral("status"));
         d->mucStatusCodes.clear();
 
         while (!statusElement.isNull()) {
-            d->mucStatusCodes << statusElement.attribute(QSL("code")).toInt();
-            statusElement = statusElement.nextSiblingElement(QSL("status"));
+            d->mucStatusCodes << statusElement.attribute(QStringLiteral("code")).toInt();
+            statusElement = statusElement.nextSiblingElement(QStringLiteral("status"));
         }
         // XEP-0115: Entity Capabilities
-    } else if (element.tagName() == QSL("c") && element.namespaceURI() == ns_capabilities) {
-        d->capabilityNode = element.attribute(QSL("node"));
-        d->capabilityVer = QByteArray::fromBase64(element.attribute(QSL("ver")).toLatin1());
-        d->capabilityHash = element.attribute(QSL("hash"));
-        d->capabilityExt = element.attribute(QSL("ext")).split(' ', QString::SkipEmptyParts);
+    } else if (element.tagName() == QStringLiteral("c") && element.namespaceURI() == ns_capabilities) {
+        d->capabilityNode = element.attribute(QStringLiteral("node"));
+        d->capabilityVer = QByteArray::fromBase64(element.attribute(QStringLiteral("ver")).toLatin1());
+        d->capabilityHash = element.attribute(QStringLiteral("hash"));
+        d->capabilityExt = element.attribute(QStringLiteral("ext")).split(' ', QString::SkipEmptyParts);
         // XEP-0153: vCard-Based Avatars
     } else if (element.namespaceURI() == ns_vcard_update) {
-        QDomElement photoElement = element.firstChildElement(QSL("photo"));
+        QDomElement photoElement = element.firstChildElement(QStringLiteral("photo"));
         if (photoElement.isNull()) {
             d->photoHash = {};
             d->vCardUpdateType = VCardUpdateNotReady;
@@ -453,15 +453,15 @@ void QXmppPresence::parseExtension(const QDomElement &element, QXmppElementList
                 d->vCardUpdateType = VCardUpdateValidPhoto;
         }
         // XEP-0319: Last User Interaction in Presence
-    } else if (element.tagName() == QSL("idle") && element.namespaceURI() == ns_idle) {
-        if (element.hasAttribute(QSL("since"))) {
-            const QString since = element.attribute(QSL("since"));
+    } else if (element.tagName() == QStringLiteral("idle") && element.namespaceURI() == ns_idle) {
+        if (element.hasAttribute(QStringLiteral("since"))) {
+            const QString since = element.attribute(QStringLiteral("since"));
             d->lastUserInteraction = QXmppUtils::datetimeFromString(since);
         }
         // XEP-0405: Mediated Information eXchange (MIX): Participant Server Requirements
-    } else if (element.tagName() == QSL("mix") && element.namespaceURI() == ns_mix_presence) {
-        d->mixUserJid = element.firstChildElement(QSL("jid")).text();
-        d->mixUserNick = element.firstChildElement(QSL("nick")).text();
+    } else if (element.tagName() == QStringLiteral("mix") && element.namespaceURI() == ns_mix_presence) {
+        d->mixUserJid = element.firstChildElement(QStringLiteral("jid")).text();
+        d->mixUserNick = element.firstChildElement(QStringLiteral("nick")).text();
     } else {
         unknownElements << element;
     }
@@ -469,40 +469,40 @@ void QXmppPresence::parseExtension(const QDomElement &element, QXmppElementList
 
 void QXmppPresence::toXml(QXmlStreamWriter *xmlWriter) const
 {
-    xmlWriter->writeStartElement(QSL("presence"));
-    helperToXmlAddAttribute(xmlWriter, QSL("xml:lang"), lang());
-    helperToXmlAddAttribute(xmlWriter, QSL("id"), id());
-    helperToXmlAddAttribute(xmlWriter, QSL("to"), to());
-    helperToXmlAddAttribute(xmlWriter, QSL("from"), from());
-    helperToXmlAddAttribute(xmlWriter, QSL("type"), PRESENCE_TYPES.at(d->type));
+    xmlWriter->writeStartElement(QStringLiteral("presence"));
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("xml:lang"), lang());
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("id"), id());
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("to"), to());
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("from"), from());
+    helperToXmlAddAttribute(xmlWriter, QStringLiteral("type"), PRESENCE_TYPES.at(d->type));
 
     const QString show = AVAILABLE_STATUS_TYPES.at(d->availableStatusType);
     if (!show.isEmpty())
-        helperToXmlAddTextElement(xmlWriter, QSL("show"), show);
+        helperToXmlAddTextElement(xmlWriter, QStringLiteral("show"), show);
     if (!d->statusText.isEmpty())
-        helperToXmlAddTextElement(xmlWriter, QSL("status"), d->statusText);
+        helperToXmlAddTextElement(xmlWriter, QStringLiteral("status"), d->statusText);
     if (d->priority != 0)
-        helperToXmlAddTextElement(xmlWriter, QSL("priority"), QString::number(d->priority));
+        helperToXmlAddTextElement(xmlWriter, QStringLiteral("priority"), QString::number(d->priority));
 
     error().toXml(xmlWriter);
 
     // XEP-0045: Multi-User Chat
     if (d->mucSupported) {
-        xmlWriter->writeStartElement(QSL("x"));
+        xmlWriter->writeStartElement(QStringLiteral("x"));
         xmlWriter->writeDefaultNamespace(ns_muc);
         if (!d->mucPassword.isEmpty())
-            xmlWriter->writeTextElement(QSL("password"), d->mucPassword);
+            xmlWriter->writeTextElement(QStringLiteral("password"), d->mucPassword);
         xmlWriter->writeEndElement();
     }
 
     if (!d->mucItem.isNull() || !d->mucStatusCodes.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("x"));
+        xmlWriter->writeStartElement(QStringLiteral("x"));
         xmlWriter->writeDefaultNamespace(ns_muc_user);
         if (!d->mucItem.isNull())
             d->mucItem.toXml(xmlWriter);
         for (const auto code : d->mucStatusCodes) {
-            xmlWriter->writeStartElement(QSL("status"));
-            xmlWriter->writeAttribute(QSL("code"), QString::number(code));
+            xmlWriter->writeStartElement(QStringLiteral("status"));
+            xmlWriter->writeAttribute(QStringLiteral("code"), QString::number(code));
             xmlWriter->writeEndElement();
         }
         xmlWriter->writeEndElement();
@@ -512,24 +512,24 @@ void QXmppPresence::toXml(QXmlStreamWriter *xmlWriter) const
     if (!d->capabilityNode.isEmpty() &&
         !d->capabilityVer.isEmpty() &&
         !d->capabilityHash.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("c"));
+        xmlWriter->writeStartElement(QStringLiteral("c"));
         xmlWriter->writeDefaultNamespace(ns_capabilities);
-        helperToXmlAddAttribute(xmlWriter, QSL("hash"), d->capabilityHash);
-        helperToXmlAddAttribute(xmlWriter, QSL("node"), d->capabilityNode);
-        helperToXmlAddAttribute(xmlWriter, QSL("ver"), d->capabilityVer.toBase64());
+        helperToXmlAddAttribute(xmlWriter, QStringLiteral("hash"), d->capabilityHash);
+        helperToXmlAddAttribute(xmlWriter, QStringLiteral("node"), d->capabilityNode);
+        helperToXmlAddAttribute(xmlWriter, QStringLiteral("ver"), d->capabilityVer.toBase64());
         xmlWriter->writeEndElement();
     }
 
     // XEP-0153: vCard-Based Avatars
     if (d->vCardUpdateType != VCardUpdateNone) {
-        xmlWriter->writeStartElement(QSL("x"));
+        xmlWriter->writeStartElement(QStringLiteral("x"));
         xmlWriter->writeDefaultNamespace(ns_vcard_update);
         switch (d->vCardUpdateType) {
         case VCardUpdateNoPhoto:
-            xmlWriter->writeEmptyElement(QSL("photo"));
+            xmlWriter->writeEmptyElement(QStringLiteral("photo"));
             break;
         case VCardUpdateValidPhoto:
-            helperToXmlAddTextElement(xmlWriter, QSL("photo"), d->photoHash.toHex());
+            helperToXmlAddTextElement(xmlWriter, QStringLiteral("photo"), d->photoHash.toHex());
             break;
         default:
             break;
@@ -539,20 +539,20 @@ void QXmppPresence::toXml(QXmlStreamWriter *xmlWriter) const
 
     // XEP-0319: Last User Interaction in Presence
     if (!d->lastUserInteraction.isNull() && d->lastUserInteraction.isValid()) {
-        xmlWriter->writeStartElement(QSL("idle"));
+        xmlWriter->writeStartElement(QStringLiteral("idle"));
         xmlWriter->writeDefaultNamespace(ns_idle);
-        helperToXmlAddAttribute(xmlWriter, QSL("since"), QXmppUtils::datetimeToString(d->lastUserInteraction));
+        helperToXmlAddAttribute(xmlWriter, QStringLiteral("since"), QXmppUtils::datetimeToString(d->lastUserInteraction));
         xmlWriter->writeEndElement();
     }
 
     // XEP-0405: Mediated Information eXchange (MIX): Participant Server Requirements
     if (!d->mixUserJid.isEmpty() || !d->mixUserNick.isEmpty()) {
-        xmlWriter->writeStartElement(QSL("mix"));
+        xmlWriter->writeStartElement(QStringLiteral("mix"));
         xmlWriter->writeDefaultNamespace(ns_mix_presence);
         if (!d->mixUserJid.isEmpty())
-            helperToXmlAddTextElement(xmlWriter, QSL("jid"), d->mixUserJid);
+            helperToXmlAddTextElement(xmlWriter, QStringLiteral("jid"), d->mixUserJid);
         if (!d->mixUserNick.isEmpty())
-            helperToXmlAddTextElement(xmlWriter, QSL("nick"), d->mixUserNick);
+            helperToXmlAddTextElement(xmlWriter, QStringLiteral("nick"), d->mixUserNick);
         xmlWriter->writeEndElement();
     }
 
diff --git a/src/base/QXmppPubSubIq.cpp b/src/base/QXmppPubSubIq.cpp
index 23551d59..8952dfad 100644
--- a/src/base/QXmppPubSubIq.cpp
+++ b/src/base/QXmppPubSubIq.cpp
@@ -30,15 +30,15 @@
 #include <QSharedData>
 
 static const QStringList PUBSUB_QUERIES = {
-    QSL("affiliations"),
-    QSL("default"),
-    QSL("items"),
-    QSL("publish"),
-    QSL("retract"),
-    QSL("subscribe"),
-    QSL("subscription"),
-    QSL("subscriptions"),
-    QSL("unsubscribe"),
+    QStringLiteral("affiliations"),
+    QStringLiteral("default"),
+    QStringLiteral("items"),
+    QStringLiteral("publish"),
+    QStringLiteral("retract"),
+    QStringLiteral("subscribe"),
+    QStringLiteral("subscription"),
+    QStringLiteral("subscriptions"),
+    QStringLiteral("unsubscribe"),
 };
 
 class QXmppPubSubIqPrivate : public QSharedData
@@ -153,12 +153,12 @@ void QXmppPubSubIq::setItems(const QList<QXmppPubSubItem> &items)
 /// \cond
 bool QXmppPubSubIq::isPubSubIq(const QDomElement &element)
 {
-    return element.firstChildElement(QSL("pubsub")).namespaceURI() == ns_pubsub;
+    return element.firstChildElement(QStringLiteral("pubsub")).namespaceURI() == ns_pubsub;
 }
 
 void QXmppPubSubIq::parseElementFromChild(const QDomElement &element)
 {
-    const QDomElement pubSubElement = element.firstChildElement(QSL("pubsub"));
+    const QDomElement pubSubElement = element.firstChildElement(QStringLiteral("pubsub"));
 
     const QDomElement queryElement = pubSubElement.firstChildElement();
 
@@ -168,8 +168,8 @@ void QXmppPubSubIq::parseElementFromChild(const QDomElement &element)
     if (queryType > -1)
         d->queryType = QueryType(queryType);
 
-    d->queryJid = queryElement.attribute(QSL("jid"));
-    d->queryNode = queryElement.attribute(QSL("node"));
+    d->queryJid = queryElement.attribute(QStringLiteral("jid"));
+    d->queryNode = queryElement.attribute(QStringLiteral("node"));
 
     // parse contents
     QDomElement childElement;
@@ -177,17 +177,17 @@ void QXmppPubSubIq::parseElementFromChild(const QDomElement &element)
     case QXmppPubSubIq::ItemsQuery:
     case QXmppPubSubIq::PublishQuery:
     case QXmppPubSubIq::RetractQuery:
-        childElement = queryElement.firstChildElement(QSL("item"));
+        childElement = queryElement.firstChildElement(QStringLiteral("item"));
         while (!childElement.isNull()) {
             QXmppPubSubItem item;
             item.parse(childElement);
             d->items << item;
-            childElement = childElement.nextSiblingElement(QSL("item"));
+            childElement = childElement.nextSiblingElement(QStringLiteral("item"));
         }
         break;
     case QXmppPubSubIq::SubscriptionQuery:
-        d->subscriptionId = queryElement.attribute(QSL("subid"));
-        d->subscriptionType = queryElement.attribute(QSL("subscription"));
+        d->subscriptionId = queryElement.attribute(QStringLiteral("subid"));
+        d->subscriptionType = queryElement.attribute(QStringLiteral("subscription"));
         break;
     default:
         break;
@@ -196,13 +196,13 @@ void QXmppPubSubIq::parseElementFromChild(const QDomElement &element)
 
 void QXmppPubSubIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("pubsub"));
+    writer->writeStartElement(QStringLiteral("pubsub"));
     writer->writeDefaultNamespace(ns_pubsub);
 
     // write query type
     writer->writeStartElement(PUBSUB_QUERIES.at(d->queryType));
-    helperToXmlAddAttribute(writer, QSL("jid"), d->queryJid);
-    helperToXmlAddAttribute(writer, QSL("node"), d->queryNode);
+    helperToXmlAddAttribute(writer, QStringLiteral("jid"), d->queryJid);
+    helperToXmlAddAttribute(writer, QStringLiteral("node"), d->queryNode);
 
     // write contents
     switch (d->queryType) {
@@ -213,8 +213,8 @@ void QXmppPubSubIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
             item.toXml(writer);
         break;
     case QXmppPubSubIq::SubscriptionQuery:
-        helperToXmlAddAttribute(writer, QSL("subid"), d->subscriptionId);
-        helperToXmlAddAttribute(writer, QSL("subscription"), d->subscriptionType);
+        helperToXmlAddAttribute(writer, QStringLiteral("subid"), d->subscriptionId);
+        helperToXmlAddAttribute(writer, QStringLiteral("subscription"), d->subscriptionType);
         break;
     default:
         break;
diff --git a/src/base/QXmppPubSubItem.cpp b/src/base/QXmppPubSubItem.cpp
index a5f875d4..4c2628ff 100644
--- a/src/base/QXmppPubSubItem.cpp
+++ b/src/base/QXmppPubSubItem.cpp
@@ -81,14 +81,14 @@ void QXmppPubSubItem::setContents(const QXmppElement &contents)
 /// \cond
 void QXmppPubSubItem::parse(const QDomElement &element)
 {
-    d->id = element.attribute(QSL("id"));
+    d->id = element.attribute(QStringLiteral("id"));
     d->contents = QXmppElement(element.firstChildElement());
 }
 
 void QXmppPubSubItem::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("item"));
-    helperToXmlAddAttribute(writer, QSL("id"), d->id);
+    writer->writeStartElement(QStringLiteral("item"));
+    helperToXmlAddAttribute(writer, QStringLiteral("id"), d->id);
     d->contents.toXml(writer);
     writer->writeEndElement();
 }
diff --git a/src/base/QXmppRegisterIq.cpp b/src/base/QXmppRegisterIq.cpp
index 17e3197a..e692b680 100644
--- a/src/base/QXmppRegisterIq.cpp
+++ b/src/base/QXmppRegisterIq.cpp
@@ -30,8 +30,8 @@
 #include <QDomElement>
 #include <QSharedData>
 
-#define ELEMENT_REGISTERED QSL("registered")
-#define ELEMENT_REMOVE QSL("remove")
+#define ELEMENT_REGISTERED QStringLiteral("registered")
+#define ELEMENT_REMOVE QStringLiteral("remove")
 
 class QXmppRegisterIqPrivate : public QSharedData
 {
@@ -260,17 +260,17 @@ void QXmppRegisterIq::setBitsOfBinaryData(const QXmppBitsOfBinaryDataList &bitsO
 /// \cond
 bool QXmppRegisterIq::isRegisterIq(const QDomElement &element)
 {
-    return (element.firstChildElement(QSL("query")).namespaceURI() == ns_register);
+    return (element.firstChildElement(QStringLiteral("query")).namespaceURI() == ns_register);
 }
 
 void QXmppRegisterIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    d->instructions = queryElement.firstChildElement(QSL("instructions")).text();
-    d->username = queryElement.firstChildElement(QSL("username")).text();
-    d->password = queryElement.firstChildElement(QSL("password")).text();
-    d->email = queryElement.firstChildElement(QSL("email")).text();
-    d->form.parse(queryElement.firstChildElement(QSL("x")));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    d->instructions = queryElement.firstChildElement(QStringLiteral("instructions")).text();
+    d->username = queryElement.firstChildElement(QStringLiteral("username")).text();
+    d->password = queryElement.firstChildElement(QStringLiteral("password")).text();
+    d->email = queryElement.firstChildElement(QStringLiteral("email")).text();
+    d->form.parse(queryElement.firstChildElement(QStringLiteral("x")));
     d->isRegistered = !queryElement.firstChildElement(ELEMENT_REGISTERED).isNull();
     d->isRemove = !queryElement.firstChildElement(ELEMENT_REMOVE).isNull();
     d->bitsOfBinaryData.parse(queryElement);
@@ -278,11 +278,11 @@ void QXmppRegisterIq::parseElementFromChild(const QDomElement &element)
 
 void QXmppRegisterIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_register);
 
     if (!d->instructions.isEmpty())
-        writer->writeTextElement(QSL("instructions"), d->instructions);
+        writer->writeTextElement(QStringLiteral("instructions"), d->instructions);
 
     if (d->isRegistered)
         writer->writeEmptyElement(ELEMENT_REGISTERED);
@@ -290,19 +290,19 @@ void QXmppRegisterIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
         writer->writeEmptyElement(ELEMENT_REMOVE);
 
     if (!d->username.isEmpty())
-        writer->writeTextElement(QSL("username"), d->username);
+        writer->writeTextElement(QStringLiteral("username"), d->username);
     else if (!d->username.isNull())
-        writer->writeEmptyElement(QSL("username"));
+        writer->writeEmptyElement(QStringLiteral("username"));
 
     if (!d->password.isEmpty())
-        writer->writeTextElement(QSL("password"), d->password);
+        writer->writeTextElement(QStringLiteral("password"), d->password);
     else if (!d->password.isNull())
-        writer->writeEmptyElement(QSL("password"));
+        writer->writeEmptyElement(QStringLiteral("password"));
 
     if (!d->email.isEmpty())
-        writer->writeTextElement(QSL("email"), d->email);
+        writer->writeTextElement(QStringLiteral("email"), d->email);
     else if (!d->email.isNull())
-        writer->writeEmptyElement(QSL("email"));
+        writer->writeEmptyElement(QStringLiteral("email"));
 
     d->form.toXml(writer);
     d->bitsOfBinaryData.toXml(writer);
diff --git a/src/base/QXmppResultSet.cpp b/src/base/QXmppResultSet.cpp
index 76e93f6a..b45bf4c8 100644
--- a/src/base/QXmppResultSet.cpp
+++ b/src/base/QXmppResultSet.cpp
@@ -117,15 +117,15 @@ bool QXmppResultSetQuery::isNull() const
 /// \cond
 void QXmppResultSetQuery::parse(const QDomElement& element)
 {
-    QDomElement setElement = (element.tagName() == QSL("set")) ? element : element.firstChildElement(QSL("set"));
+    QDomElement setElement = (element.tagName() == QStringLiteral("set")) ? element : element.firstChildElement(QStringLiteral("set"));
     if (setElement.namespaceURI() == ns_rsm) {
         bool ok = false;
-        m_max = setElement.firstChildElement(QSL("max")).text().toInt(&ok);
+        m_max = setElement.firstChildElement(QStringLiteral("max")).text().toInt(&ok);
         if (!ok)
             m_max = -1;
-        m_after = setElement.firstChildElement(QSL("after")).text();
-        m_before = setElement.firstChildElement(QSL("before")).text();
-        m_index = setElement.firstChildElement(QSL("index")).text().toInt(&ok);
+        m_after = setElement.firstChildElement(QStringLiteral("after")).text();
+        m_before = setElement.firstChildElement(QStringLiteral("before")).text();
+        m_index = setElement.firstChildElement(QStringLiteral("index")).text().toInt(&ok);
         if (!ok)
             m_index = -1;
     }
@@ -135,16 +135,16 @@ void QXmppResultSetQuery::toXml(QXmlStreamWriter* writer) const
 {
     if (isNull())
         return;
-    writer->writeStartElement(QSL("set"));
+    writer->writeStartElement(QStringLiteral("set"));
     writer->writeDefaultNamespace(ns_rsm);
     if (m_max >= 0)
-        helperToXmlAddTextElement(writer, QSL("max"), QString::number(m_max));
+        helperToXmlAddTextElement(writer, QStringLiteral("max"), QString::number(m_max));
     if (!m_after.isNull())
-        helperToXmlAddTextElement(writer, QSL("after"), m_after);
+        helperToXmlAddTextElement(writer, QStringLiteral("after"), m_after);
     if (!m_before.isNull())
-        helperToXmlAddTextElement(writer, QSL("before"), m_before);
+        helperToXmlAddTextElement(writer, QStringLiteral("before"), m_before);
     if (m_index >= 0)
-        helperToXmlAddTextElement(writer, QSL("index"), QString::number(m_index));
+        helperToXmlAddTextElement(writer, QStringLiteral("index"), QString::number(m_index));
     writer->writeEndElement();
 }
 /// \endcond
diff --git a/src/base/QXmppRosterIq.cpp b/src/base/QXmppRosterIq.cpp
index 20b49e11..36564c60 100644
--- a/src/base/QXmppRosterIq.cpp
+++ b/src/base/QXmppRosterIq.cpp
@@ -112,39 +112,39 @@ void QXmppRosterIq::setMixAnnotate(bool mixAnnotate)
 /// \cond
 bool QXmppRosterIq::isRosterIq(const QDomElement &element)
 {
-    return (element.firstChildElement(QSL("query")).namespaceURI() == ns_roster);
+    return (element.firstChildElement(QStringLiteral("query")).namespaceURI() == ns_roster);
 }
 
 void QXmppRosterIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    setVersion(queryElement.attribute(QSL("ver")));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    setVersion(queryElement.attribute(QStringLiteral("ver")));
 
-    QDomElement itemElement = queryElement.firstChildElement(QSL("item"));
+    QDomElement itemElement = queryElement.firstChildElement(QStringLiteral("item"));
     while (!itemElement.isNull()) {
         QXmppRosterIq::Item item;
         item.parse(itemElement);
         d->items.append(item);
-        itemElement = itemElement.nextSiblingElement(QSL("item"));
+        itemElement = itemElement.nextSiblingElement(QStringLiteral("item"));
     }
 
-    QDomElement annotateElement = queryElement.firstChildElement(QSL("annotate"));
+    QDomElement annotateElement = queryElement.firstChildElement(QStringLiteral("annotate"));
     setMixAnnotate(!annotateElement.isNull() && annotateElement.namespaceURI() == ns_mix_roster);
 }
 
 void QXmppRosterIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_roster);
 
     // XEP-0237 roster versioning - If the server does not advertise support for roster versioning, the client MUST NOT include the 'ver' attribute.
     if (!version().isEmpty())
-        writer->writeAttribute(QSL("ver"), version());
+        writer->writeAttribute(QStringLiteral("ver"), version());
 
     // XEP-0405: Mediated Information eXchange (MIX): Participant Server Requirements
     if (d->mixAnnotate) {
-        writer->writeStartElement(QSL("annotate"));
-        writer->writeAttribute(QSL("xmlns"), ns_mix_roster);
+        writer->writeStartElement(QStringLiteral("annotate"));
+        writer->writeAttribute(QStringLiteral("xmlns"), ns_mix_roster);
         writer->writeEndElement();
     }
 
@@ -311,15 +311,15 @@ void QXmppRosterIq::Item::setSubscriptionTypeFromStr(const QString &type)
 {
     if (type.isEmpty() && !type.isNull())  // TODO CHECK
         setSubscriptionType(NotSet);
-    else if (type == QSL("none"))
+    else if (type == QStringLiteral("none"))
         setSubscriptionType(None);
-    else if (type == QSL("both"))
+    else if (type == QStringLiteral("both"))
         setSubscriptionType(Both);
-    else if (type == QSL("from"))
+    else if (type == QStringLiteral("from"))
         setSubscriptionType(From);
-    else if (type == QSL("to"))
+    else if (type == QStringLiteral("to"))
         setSubscriptionType(To);
-    else if (type == QSL("remove"))
+    else if (type == QStringLiteral("remove"))
         setSubscriptionType(Remove);
     else
         qWarning("QXmppRosterIq::Item::setTypeFromStr(): invalid type");
@@ -368,44 +368,44 @@ void QXmppRosterIq::Item::setMixParticipantId(const QString &participantId)
 /// \cond
 void QXmppRosterIq::Item::parse(const QDomElement &element)
 {
-    d->name = element.attribute(QSL("name"));
-    d->bareJid = element.attribute(QSL("jid"));
-    setSubscriptionTypeFromStr(element.attribute(QSL("subscription")));
-    setSubscriptionStatus(element.attribute(QSL("ask")));
+    d->name = element.attribute(QStringLiteral("name"));
+    d->bareJid = element.attribute(QStringLiteral("jid"));
+    setSubscriptionTypeFromStr(element.attribute(QStringLiteral("subscription")));
+    setSubscriptionStatus(element.attribute(QStringLiteral("ask")));
 
-    QDomElement groupElement = element.firstChildElement(QSL("group"));
+    QDomElement groupElement = element.firstChildElement(QStringLiteral("group"));
     while (!groupElement.isNull()) {
         d->groups << groupElement.text();
-        groupElement = groupElement.nextSiblingElement(QSL("group"));
+        groupElement = groupElement.nextSiblingElement(QStringLiteral("group"));
     }
 
     // XEP-0405: Mediated Information eXchange (MIX): Participant Server Requirements
-    QDomElement channelElement = element.firstChildElement(QSL("channel"));
+    QDomElement channelElement = element.firstChildElement(QStringLiteral("channel"));
     if (!channelElement.isNull() && channelElement.namespaceURI() == ns_mix_roster) {
         d->isMixChannel = true;
-        d->mixParticipantId = channelElement.attribute(QSL("participant-id"));
+        d->mixParticipantId = channelElement.attribute(QStringLiteral("participant-id"));
     }
 }
 
 void QXmppRosterIq::Item::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("item"));
-    helperToXmlAddAttribute(writer, QSL("jid"), d->bareJid);
-    helperToXmlAddAttribute(writer, QSL("name"), d->name);
-    helperToXmlAddAttribute(writer, QSL("subscription"), getSubscriptionTypeStr());
-    helperToXmlAddAttribute(writer, QSL("ask"), subscriptionStatus());
+    writer->writeStartElement(QStringLiteral("item"));
+    helperToXmlAddAttribute(writer, QStringLiteral("jid"), d->bareJid);
+    helperToXmlAddAttribute(writer, QStringLiteral("name"), d->name);
+    helperToXmlAddAttribute(writer, QStringLiteral("subscription"), getSubscriptionTypeStr());
+    helperToXmlAddAttribute(writer, QStringLiteral("ask"), subscriptionStatus());
 
     QSet<QString>::const_iterator i = d->groups.constBegin();
     while (i != d->groups.constEnd()) {
-        helperToXmlAddTextElement(writer, QSL("group"), *i);
+        helperToXmlAddTextElement(writer, QStringLiteral("group"), *i);
         ++i;
     }
 
     // XEP-0405: Mediated Information eXchange (MIX): Participant Server Requirements
     if (d->isMixChannel) {
-        writer->writeStartElement(QSL("channel"));
-        writer->writeAttribute(QSL("xmlns"), ns_mix_roster);
-        helperToXmlAddAttribute(writer, QSL("participant-id"), d->mixParticipantId);
+        writer->writeStartElement(QStringLiteral("channel"));
+        writer->writeAttribute(QStringLiteral("xmlns"), ns_mix_roster);
+        helperToXmlAddAttribute(writer, QStringLiteral("participant-id"), d->mixParticipantId);
         writer->writeEndElement();
     }
 
diff --git a/src/base/QXmppRpcIq.cpp b/src/base/QXmppRpcIq.cpp
index 0f40c97b..40bd1fc6 100644
--- a/src/base/QXmppRpcIq.cpp
+++ b/src/base/QXmppRpcIq.cpp
@@ -35,33 +35,33 @@
 
 void QXmppRpcMarshaller::marshall(QXmlStreamWriter *writer, const QVariant &value)
 {
-    writer->writeStartElement(QSL("value"));
+    writer->writeStartElement(QStringLiteral("value"));
     switch (value.type()) {
     case QVariant::Int:
     case QVariant::UInt:
     case QVariant::LongLong:
     case QVariant::ULongLong:
-        writer->writeTextElement(QSL("i4"), value.toString());
+        writer->writeTextElement(QStringLiteral("i4"), value.toString());
         break;
     case QVariant::Double:
-        writer->writeTextElement(QSL("double"), value.toString());
+        writer->writeTextElement(QStringLiteral("double"), value.toString());
         break;
     case QVariant::Bool:
-        writer->writeTextElement(QSL("boolean"), value.toBool() ? QSL("1") : QSL("0"));
+        writer->writeTextElement(QStringLiteral("boolean"), value.toBool() ? QStringLiteral("1") : QStringLiteral("0"));
         break;
     case QVariant::Date:
-        writer->writeTextElement(QSL("dateTime.iso8601"), value.toDate().toString(Qt::ISODate));
+        writer->writeTextElement(QStringLiteral("dateTime.iso8601"), value.toDate().toString(Qt::ISODate));
         break;
     case QVariant::DateTime:
-        writer->writeTextElement(QSL("dateTime.iso8601"), value.toDateTime().toString(Qt::ISODate));
+        writer->writeTextElement(QStringLiteral("dateTime.iso8601"), value.toDateTime().toString(Qt::ISODate));
         break;
     case QVariant::Time:
-        writer->writeTextElement(QSL("dateTime.iso8601"), value.toTime().toString(Qt::ISODate));
+        writer->writeTextElement(QStringLiteral("dateTime.iso8601"), value.toTime().toString(Qt::ISODate));
         break;
     case QVariant::StringList:
     case QVariant::List: {
-        writer->writeStartElement(QSL("array"));
-        writer->writeStartElement(QSL("data"));
+        writer->writeStartElement(QStringLiteral("array"));
+        writer->writeStartElement(QStringLiteral("data"));
         for (const auto &item : value.toList())
             marshall(writer, item);
         writer->writeEndElement();
@@ -69,12 +69,12 @@ void QXmppRpcMarshaller::marshall(QXmlStreamWriter *writer, const QVariant &valu
         break;
     }
     case QVariant::Map: {
-        writer->writeStartElement(QSL("struct"));
+        writer->writeStartElement(QStringLiteral("struct"));
         QMap<QString, QVariant> map = value.toMap();
         QMap<QString, QVariant>::ConstIterator index = map.begin();
         while (index != map.end()) {
-            writer->writeStartElement(QSL("member"));
-            writer->writeTextElement(QSL("name"), index.key());
+            writer->writeStartElement(QStringLiteral("member"));
+            writer->writeTextElement(QStringLiteral("name"), index.key());
             marshall(writer, *index);
             writer->writeEndElement();
             ++index;
@@ -83,14 +83,14 @@ void QXmppRpcMarshaller::marshall(QXmlStreamWriter *writer, const QVariant &valu
         break;
     }
     case QVariant::ByteArray: {
-        writer->writeTextElement(QSL("base64"), value.toByteArray().toBase64());
+        writer->writeTextElement(QStringLiteral("base64"), value.toByteArray().toBase64());
         break;
     }
     default: {
         if (value.isNull())
-            writer->writeEmptyElement(QSL("nil"));
+            writer->writeEmptyElement(QStringLiteral("nil"));
         else if (value.canConvert(QVariant::String)) {
-            writer->writeTextElement(QSL("string"), value.toString());
+            writer->writeTextElement(QStringLiteral("string"), value.toString());
         }
         break;
     }
@@ -100,7 +100,7 @@ void QXmppRpcMarshaller::marshall(QXmlStreamWriter *writer, const QVariant &valu
 
 QVariant QXmppRpcMarshaller::demarshall(const QDomElement &elem, QStringList &errors)
 {
-    if (elem.tagName().toLower() != QSL("value")) {
+    if (elem.tagName().toLower() != QStringLiteral("value")) {
         errors << "Bad param value";
         return QVariant();
     }
@@ -112,54 +112,54 @@ QVariant QXmppRpcMarshaller::demarshall(const QDomElement &elem, QStringList &er
     const QDomElement typeData = elem.firstChild().toElement();
     const QString typeName = typeData.tagName().toLower();
 
-    if (typeName == QSL("nil")) {
+    if (typeName == QStringLiteral("nil")) {
         return QVariant();
     }
-    if (typeName == QSL("string")) {
+    if (typeName == QStringLiteral("string")) {
         return QVariant(typeData.text());
-    } else if (typeName == QSL("int") || typeName == QSL("i4")) {
+    } else if (typeName == QStringLiteral("int") || typeName == QStringLiteral("i4")) {
         bool ok = false;
         QVariant val(typeData.text().toInt(&ok));
         if (ok)
             return val;
         errors << "I was looking for an integer but data was courupt";
         return QVariant();
-    } else if (typeName == QSL("double")) {
+    } else if (typeName == QStringLiteral("double")) {
         bool ok = false;
         QVariant val(typeData.text().toDouble(&ok));
         if (ok)
             return val;
         errors << "I was looking for an double but data was corrupt";
-    } else if (typeName == QSL("boolean"))
-        return QVariant(typeData.text() == QSL("1") || typeData.text().toLower() == QSL("true"));
-    else if (typeName == QSL("datetime") || typeName == QSL("datetime.iso8601"))
+    } else if (typeName == QStringLiteral("boolean"))
+        return QVariant(typeData.text() == QStringLiteral("1") || typeData.text().toLower() == QStringLiteral("true"));
+    else if (typeName == QStringLiteral("datetime") || typeName == QStringLiteral("datetime.iso8601"))
         return QVariant(QDateTime::fromString(typeData.text(), Qt::ISODate));
-    else if (typeName == QSL("array")) {
+    else if (typeName == QStringLiteral("array")) {
         QVariantList arr;
-        QDomElement valueNode = typeData.firstChildElement(QSL("data")).firstChildElement();
+        QDomElement valueNode = typeData.firstChildElement(QStringLiteral("data")).firstChildElement();
         while (!valueNode.isNull() && errors.isEmpty()) {
             arr.append(demarshall(valueNode, errors));
             valueNode = valueNode.nextSiblingElement();
         }
         return QVariant(arr);
-    } else if (typeName == QSL("struct")) {
+    } else if (typeName == QStringLiteral("struct")) {
         QMap<QString, QVariant> stct;
         QDomNode valueNode = typeData.firstChild();
         while (!valueNode.isNull() && errors.isEmpty()) {
-            const QDomElement memberNode = valueNode.toElement().elementsByTagName(QSL("name")).item(0).toElement();
-            const QDomElement dataNode = valueNode.toElement().elementsByTagName(QSL("value")).item(0).toElement();
+            const QDomElement memberNode = valueNode.toElement().elementsByTagName(QStringLiteral("name")).item(0).toElement();
+            const QDomElement dataNode = valueNode.toElement().elementsByTagName(QStringLiteral("value")).item(0).toElement();
             stct[memberNode.text()] = demarshall(dataNode, errors);
             valueNode = valueNode.nextSibling();
         }
         return QVariant(stct);
-    } else if (typeName == QSL("base64")) {
+    } else if (typeName == QStringLiteral("base64")) {
         QVariant returnVariant;
         QByteArray dest;
         QByteArray src = typeData.text().toLatin1();
         return QVariant(QByteArray::fromBase64(src));
     }
 
-    errors << QSL("Cannot handle type %1").arg(typeName);
+    errors << QStringLiteral("Cannot handle type %1").arg(typeName);
     return QVariant();
 }
 
@@ -180,10 +180,10 @@ void QXmppRpcErrorIq::setQuery(const QXmppRpcInvokeIq &query)
 /// \cond
 bool QXmppRpcErrorIq::isRpcErrorIq(const QDomElement &element)
 {
-    QString type = element.attribute(QSL("type"));
-    QDomElement errorElement = element.firstChildElement(QSL("error"));
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    return (type == QSL("error")) &&
+    QString type = element.attribute(QStringLiteral("type"));
+    QDomElement errorElement = element.firstChildElement(QStringLiteral("error"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    return (type == QStringLiteral("error")) &&
         !errorElement.isNull() &&
         queryElement.namespaceURI() == ns_rpc;
 }
@@ -259,56 +259,56 @@ void QXmppRpcResponseIq::setValues(const QVariantList &values)
 /// \cond
 bool QXmppRpcResponseIq::isRpcResponseIq(const QDomElement &element)
 {
-    QString type = element.attribute(QSL("type"));
-    QDomElement dataElement = element.firstChildElement(QSL("query"));
+    QString type = element.attribute(QStringLiteral("type"));
+    QDomElement dataElement = element.firstChildElement(QStringLiteral("query"));
     return dataElement.namespaceURI() == ns_rpc &&
-        type == QSL("result");
+        type == QStringLiteral("result");
 }
 
 void QXmppRpcResponseIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    QDomElement methodElement = queryElement.firstChildElement(QSL("methodResponse"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    QDomElement methodElement = queryElement.firstChildElement(QStringLiteral("methodResponse"));
 
     const QDomElement contents = methodElement.firstChildElement();
-    if (contents.tagName().toLower() == QSL("params")) {
-        QDomNode param = contents.firstChildElement(QSL("param"));
+    if (contents.tagName().toLower() == QStringLiteral("params")) {
+        QDomNode param = contents.firstChildElement(QStringLiteral("param"));
         while (!param.isNull()) {
             QStringList errors;
-            const QVariant value = QXmppRpcMarshaller::demarshall(param.firstChildElement(QSL("value")), errors);
+            const QVariant value = QXmppRpcMarshaller::demarshall(param.firstChildElement(QStringLiteral("value")), errors);
             if (!errors.isEmpty())
                 break;
             m_values << value;
-            param = param.nextSiblingElement(QSL("param"));
+            param = param.nextSiblingElement(QStringLiteral("param"));
         }
-    } else if (contents.tagName().toLower() == QSL("fault")) {
+    } else if (contents.tagName().toLower() == QStringLiteral("fault")) {
         QStringList errors;
-        const QDomElement errElement = contents.firstChildElement(QSL("value"));
+        const QDomElement errElement = contents.firstChildElement(QStringLiteral("value"));
         const QVariant error = QXmppRpcMarshaller::demarshall(errElement, errors);
         if (!errors.isEmpty())
             return;
-        m_faultCode = error.toMap()[QSL("faultCode")].toInt();
-        m_faultString = error.toMap()[QSL("faultString")].toString();
+        m_faultCode = error.toMap()[QStringLiteral("faultCode")].toInt();
+        m_faultString = error.toMap()[QStringLiteral("faultString")].toString();
     }
 }
 
 void QXmppRpcResponseIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_rpc);
 
-    writer->writeStartElement(QSL("methodResponse"));
+    writer->writeStartElement(QStringLiteral("methodResponse"));
     if (m_faultCode) {
-        writer->writeStartElement(QSL("fault"));
+        writer->writeStartElement(QStringLiteral("fault"));
         QMap<QString, QVariant> fault;
-        fault[QSL("faultCode")] = m_faultCode;
-        fault[QSL("faultString")] = m_faultString;
+        fault[QStringLiteral("faultCode")] = m_faultCode;
+        fault[QStringLiteral("faultString")] = m_faultString;
         QXmppRpcMarshaller::marshall(writer, fault);
         writer->writeEndElement();
     } else if (!m_values.isEmpty()) {
-        writer->writeStartElement(QSL("params"));
+        writer->writeStartElement(QStringLiteral("params"));
         for (const auto &arg : m_values) {
-            writer->writeStartElement(QSL("param"));
+            writer->writeStartElement(QStringLiteral("param"));
             QXmppRpcMarshaller::marshall(writer, arg);
             writer->writeEndElement();
         }
@@ -362,45 +362,45 @@ void QXmppRpcInvokeIq::setMethod(const QString &method)
 /// \cond
 bool QXmppRpcInvokeIq::isRpcInvokeIq(const QDomElement &element)
 {
-    QString type = element.attribute(QSL("type"));
-    QDomElement dataElement = element.firstChildElement(QSL("query"));
+    QString type = element.attribute(QStringLiteral("type"));
+    QDomElement dataElement = element.firstChildElement(QStringLiteral("query"));
     return dataElement.namespaceURI() == ns_rpc &&
-        type == QSL("set");
+        type == QStringLiteral("set");
 }
 
 void QXmppRpcInvokeIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    QDomElement methodElement = queryElement.firstChildElement(QSL("methodCall"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    QDomElement methodElement = queryElement.firstChildElement(QStringLiteral("methodCall"));
 
-    m_method = methodElement.firstChildElement(QSL("methodName")).text();
+    m_method = methodElement.firstChildElement(QStringLiteral("methodName")).text();
 
-    const QDomElement methodParams = methodElement.firstChildElement(QSL("params"));
+    const QDomElement methodParams = methodElement.firstChildElement(QStringLiteral("params"));
     m_arguments.clear();
     if (!methodParams.isNull()) {
-        QDomNode param = methodParams.firstChildElement(QSL("param"));
+        QDomNode param = methodParams.firstChildElement(QStringLiteral("param"));
         while (!param.isNull()) {
             QStringList errors;
-            QVariant arg = QXmppRpcMarshaller::demarshall(param.firstChildElement(QSL("value")), errors);
+            QVariant arg = QXmppRpcMarshaller::demarshall(param.firstChildElement(QStringLiteral("value")), errors);
             if (!errors.isEmpty())
                 break;
             m_arguments << arg;
-            param = param.nextSiblingElement(QSL("param"));
+            param = param.nextSiblingElement(QStringLiteral("param"));
         }
     }
 }
 
 void QXmppRpcInvokeIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_rpc);
 
-    writer->writeStartElement(QSL("methodCall"));
-    writer->writeTextElement(QSL("methodName"), m_method);
+    writer->writeStartElement(QStringLiteral("methodCall"));
+    writer->writeTextElement(QStringLiteral("methodName"), m_method);
     if (!m_arguments.isEmpty()) {
-        writer->writeStartElement(QSL("params"));
+        writer->writeStartElement(QStringLiteral("params"));
         for (const auto &arg : m_arguments) {
-            writer->writeStartElement(QSL("param"));
+            writer->writeStartElement(QStringLiteral("param"));
             QXmppRpcMarshaller::marshall(writer, arg);
             writer->writeEndElement();
         }
diff --git a/src/base/QXmppSasl.cpp b/src/base/QXmppSasl.cpp
index 29b9b5d2..8d5217fb 100644
--- a/src/base/QXmppSasl.cpp
+++ b/src/base/QXmppSasl.cpp
@@ -131,15 +131,15 @@ void QXmppSaslAuth::setValue(const QByteArray &value)
 
 void QXmppSaslAuth::parse(const QDomElement &element)
 {
-    m_mechanism = element.attribute(QSL("mechanism"));
+    m_mechanism = element.attribute(QStringLiteral("mechanism"));
     m_value = QByteArray::fromBase64(element.text().toLatin1());
 }
 
 void QXmppSaslAuth::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("auth"));
+    writer->writeStartElement(QStringLiteral("auth"));
     writer->writeDefaultNamespace(ns_xmpp_sasl);
-    writer->writeAttribute(QSL("mechanism"), m_mechanism);
+    writer->writeAttribute(QStringLiteral("mechanism"), m_mechanism);
     if (!m_value.isEmpty())
         writer->writeCharacters(m_value.toBase64());
     writer->writeEndElement();
@@ -167,7 +167,7 @@ void QXmppSaslChallenge::parse(const QDomElement &element)
 
 void QXmppSaslChallenge::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("challenge"));
+    writer->writeStartElement(QStringLiteral("challenge"));
     writer->writeDefaultNamespace(ns_xmpp_sasl);
     if (!m_value.isEmpty())
         writer->writeCharacters(m_value.toBase64());
@@ -196,7 +196,7 @@ void QXmppSaslFailure::parse(const QDomElement &element)
 
 void QXmppSaslFailure::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("failure"));
+    writer->writeStartElement(QStringLiteral("failure"));
     writer->writeDefaultNamespace(ns_xmpp_sasl);
     if (!m_condition.isEmpty())
         writer->writeEmptyElement(m_condition);
@@ -225,7 +225,7 @@ void QXmppSaslResponse::parse(const QDomElement &element)
 
 void QXmppSaslResponse::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("response"));
+    writer->writeStartElement(QStringLiteral("response"));
     writer->writeDefaultNamespace(ns_xmpp_sasl);
     if (!m_value.isEmpty())
         writer->writeCharacters(m_value.toBase64());
@@ -243,7 +243,7 @@ void QXmppSaslSuccess::parse(const QDomElement &element)
 
 void QXmppSaslSuccess::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("success"));
+    writer->writeStartElement(QStringLiteral("success"));
     writer->writeDefaultNamespace(ns_xmpp_sasl);
     writer->writeEndElement();
 }
@@ -271,35 +271,35 @@ QXmppSaslClient::~QXmppSaslClient()
 
 QStringList QXmppSaslClient::availableMechanisms()
 {
-    return QStringList() << QSL("SCRAM-SHA-256")
-                         << QSL("SCRAM-SHA-1")
-                         << QSL("DIGEST-MD5")
-                         << QSL("PLAIN")
-                         << QSL("ANONYMOUS")
-                         << QSL("X-FACEBOOK-PLATFORM")
-                         << QSL("X-MESSENGER-OAUTH2")
-                         << QSL("X-OAUTH2");
+    return QStringList() << QStringLiteral("SCRAM-SHA-256")
+                         << QStringLiteral("SCRAM-SHA-1")
+                         << QStringLiteral("DIGEST-MD5")
+                         << QStringLiteral("PLAIN")
+                         << QStringLiteral("ANONYMOUS")
+                         << QStringLiteral("X-FACEBOOK-PLATFORM")
+                         << QStringLiteral("X-MESSENGER-OAUTH2")
+                         << QStringLiteral("X-OAUTH2");
 }
 
 /// Creates an SASL client for the given mechanism.
 
 QXmppSaslClient *QXmppSaslClient::create(const QString &mechanism, QObject *parent)
 {
-    if (mechanism == QSL("PLAIN")) {
+    if (mechanism == QStringLiteral("PLAIN")) {
         return new QXmppSaslClientPlain(parent);
-    } else if (mechanism == QSL("DIGEST-MD5")) {
+    } else if (mechanism == QStringLiteral("DIGEST-MD5")) {
         return new QXmppSaslClientDigestMd5(parent);
-    } else if (mechanism == QSL("ANONYMOUS")) {
+    } else if (mechanism == QStringLiteral("ANONYMOUS")) {
         return new QXmppSaslClientAnonymous(parent);
-    } else if (mechanism == QSL("SCRAM-SHA-1")) {
+    } else if (mechanism == QStringLiteral("SCRAM-SHA-1")) {
         return new QXmppSaslClientScram(QCryptographicHash::Sha1, parent);
-    } else if (mechanism == QSL("SCRAM-SHA-256")) {
+    } else if (mechanism == QStringLiteral("SCRAM-SHA-256")) {
         return new QXmppSaslClientScram(QCryptographicHash::Sha256, parent);
-    } else if (mechanism == QSL("X-FACEBOOK-PLATFORM")) {
+    } else if (mechanism == QStringLiteral("X-FACEBOOK-PLATFORM")) {
         return new QXmppSaslClientFacebook(parent);
-    } else if (mechanism == QSL("X-MESSENGER-OAUTH2")) {
+    } else if (mechanism == QStringLiteral("X-MESSENGER-OAUTH2")) {
         return new QXmppSaslClientWindowsLive(parent);
-    } else if (mechanism == QSL("X-OAUTH2")) {
+    } else if (mechanism == QStringLiteral("X-OAUTH2")) {
         return new QXmppSaslClientGoogle(parent);
     } else {
         return nullptr;
@@ -369,7 +369,7 @@ QXmppSaslClientAnonymous::QXmppSaslClientAnonymous(QObject *parent)
 
 QString QXmppSaslClientAnonymous::mechanism() const
 {
-    return QSL("ANONYMOUS");
+    return QStringLiteral("ANONYMOUS");
 }
 
 bool QXmppSaslClientAnonymous::respond(const QByteArray &challenge, QByteArray &response)
@@ -380,13 +380,13 @@ bool QXmppSaslClientAnonymous::respond(const QByteArray &challenge, QByteArray &
         m_step++;
         return true;
     } else {
-        warning(QSL("QXmppSaslClientAnonymous : Invalid step"));
+        warning(QStringLiteral("QXmppSaslClientAnonymous : Invalid step"));
         return false;
     }
 }
 
 QXmppSaslClientDigestMd5::QXmppSaslClientDigestMd5(QObject *parent)
-    : QXmppSaslClient(parent), m_nc(QBL("00000001")), m_step(0)
+    : QXmppSaslClient(parent), m_nc(QByteArrayLiteral("00000001")), m_step(0)
 {
     m_cnonce = generateNonce();
 }
@@ -399,7 +399,7 @@ QString QXmppSaslClientDigestMd5::mechanism() const
 bool QXmppSaslClientDigestMd5::respond(const QByteArray &challenge, QByteArray &response)
 {
     Q_UNUSED(challenge);
-    const QByteArray digestUri = QSL("%1/%2").arg(serviceType(), host()).toUtf8();
+    const QByteArray digestUri = QStringLiteral("%1/%2").arg(serviceType(), host()).toUtf8();
 
     if (m_step == 0) {
         response = QByteArray();
@@ -408,38 +408,38 @@ bool QXmppSaslClientDigestMd5::respond(const QByteArray &challenge, QByteArray &
     } else if (m_step == 1) {
         const QMap<QByteArray, QByteArray> input = QXmppSaslDigestMd5::parseMessage(challenge);
 
-        if (!input.contains(QBL("nonce"))) {
-            warning(QSL("QXmppSaslClientDigestMd5 : Invalid input on step 1"));
+        if (!input.contains(QByteArrayLiteral("nonce"))) {
+            warning(QStringLiteral("QXmppSaslClientDigestMd5 : Invalid input on step 1"));
             return false;
         }
 
         // determine realm
-        const QByteArray realm = input.value(QBL("realm"));
+        const QByteArray realm = input.value(QByteArrayLiteral("realm"));
 
         // determine quality of protection
-        const QList<QByteArray> qops = input.value(QBL("qop"), QBL("auth")).split(',');
-        if (!qops.contains(QBL("auth"))) {
-            warning(QSL("QXmppSaslClientDigestMd5 : Invalid quality of protection"));
+        const QList<QByteArray> qops = input.value(QByteArrayLiteral("qop"), QByteArrayLiteral("auth")).split(',');
+        if (!qops.contains(QByteArrayLiteral("auth"))) {
+            warning(QStringLiteral("QXmppSaslClientDigestMd5 : Invalid quality of protection"));
             return false;
         }
 
-        m_nonce = input.value(QBL("nonce"));
+        m_nonce = input.value(QByteArrayLiteral("nonce"));
         m_secret = QCryptographicHash::hash(
-            username().toUtf8() + QBL(":") + realm + QBL(":") + password().toUtf8(),
+            username().toUtf8() + QByteArrayLiteral(":") + realm + QByteArrayLiteral(":") + password().toUtf8(),
             QCryptographicHash::Md5);
 
         // Build response
         QMap<QByteArray, QByteArray> output;
-        output[QBL("username")] = username().toUtf8();
+        output[QByteArrayLiteral("username")] = username().toUtf8();
         if (!realm.isEmpty())
-            output[QBL("realm")] = realm;
-        output[QBL("nonce")] = m_nonce;
-        output[QBL("qop")] = QBL("auth");
-        output[QBL("cnonce")] = m_cnonce;
-        output[QBL("nc")] = m_nc;
-        output[QBL("digest-uri")] = digestUri;
-        output[QBL("response")] = calculateDigest(QBL("AUTHENTICATE"), digestUri, m_secret, m_nonce, m_cnonce, m_nc);
-        output[QBL("charset")] = QBL("utf-8");
+            output[QByteArrayLiteral("realm")] = realm;
+        output[QByteArrayLiteral("nonce")] = m_nonce;
+        output[QByteArrayLiteral("qop")] = QByteArrayLiteral("auth");
+        output[QByteArrayLiteral("cnonce")] = m_cnonce;
+        output[QByteArrayLiteral("nc")] = m_nc;
+        output[QByteArrayLiteral("digest-uri")] = digestUri;
+        output[QByteArrayLiteral("response")] = calculateDigest(QByteArrayLiteral("AUTHENTICATE"), digestUri, m_secret, m_nonce, m_cnonce, m_nc);
+        output[QByteArrayLiteral("charset")] = QByteArrayLiteral("utf-8");
 
         response = QXmppSaslDigestMd5::serializeMessage(output);
         m_step++;
@@ -448,8 +448,8 @@ bool QXmppSaslClientDigestMd5::respond(const QByteArray &challenge, QByteArray &
         const QMap<QByteArray, QByteArray> input = QXmppSaslDigestMd5::parseMessage(challenge);
 
         // check new challenge
-        if (input.value(QBL("rspauth")) != calculateDigest(QByteArray(), digestUri, m_secret, m_nonce, m_cnonce, m_nc)) {
-            warning(QSL("QXmppSaslClientDigestMd5 : Invalid challenge on step 2"));
+        if (input.value(QByteArrayLiteral("rspauth")) != calculateDigest(QByteArray(), digestUri, m_secret, m_nonce, m_cnonce, m_nc)) {
+            warning(QStringLiteral("QXmppSaslClientDigestMd5 : Invalid challenge on step 2"));
             return false;
         }
 
@@ -457,7 +457,7 @@ bool QXmppSaslClientDigestMd5::respond(const QByteArray &challenge, QByteArray &
         m_step++;
         return true;
     } else {
-        warning(QSL("QXmppSaslClientDigestMd5 : Invalid step"));
+        warning(QStringLiteral("QXmppSaslClientDigestMd5 : Invalid step"));
         return false;
     }
 }
@@ -469,7 +469,7 @@ QXmppSaslClientFacebook::QXmppSaslClientFacebook(QObject *parent)
 
 QString QXmppSaslClientFacebook::mechanism() const
 {
-    return QSL("X-FACEBOOK-PLATFORM");
+    return QStringLiteral("X-FACEBOOK-PLATFORM");
 }
 
 bool QXmppSaslClientFacebook::respond(const QByteArray &challenge, QByteArray &response)
@@ -482,26 +482,26 @@ bool QXmppSaslClientFacebook::respond(const QByteArray &challenge, QByteArray &r
     } else if (m_step == 1) {
         // parse request
         QUrlQuery requestUrl(challenge);
-        if (!requestUrl.hasQueryItem(QSL("method")) || !requestUrl.hasQueryItem(QSL("nonce"))) {
-            warning(QSL("QXmppSaslClientFacebook : Invalid challenge, nonce or method missing"));
+        if (!requestUrl.hasQueryItem(QStringLiteral("method")) || !requestUrl.hasQueryItem(QStringLiteral("nonce"))) {
+            warning(QStringLiteral("QXmppSaslClientFacebook : Invalid challenge, nonce or method missing"));
             return false;
         }
 
         // build response
         QUrlQuery responseUrl;
-        responseUrl.addQueryItem(QSL("access_token"), password());
-        responseUrl.addQueryItem(QSL("api_key"), username());
-        responseUrl.addQueryItem(QSL("call_id"), nullptr);
-        responseUrl.addQueryItem(QSL("method"), requestUrl.queryItemValue(QSL("method")));
-        responseUrl.addQueryItem(QSL("nonce"), requestUrl.queryItemValue(QSL("nonce")));
-        responseUrl.addQueryItem(QSL("v"), QSL("1.0"));
+        responseUrl.addQueryItem(QStringLiteral("access_token"), password());
+        responseUrl.addQueryItem(QStringLiteral("api_key"), username());
+        responseUrl.addQueryItem(QStringLiteral("call_id"), nullptr);
+        responseUrl.addQueryItem(QStringLiteral("method"), requestUrl.queryItemValue(QStringLiteral("method")));
+        responseUrl.addQueryItem(QStringLiteral("nonce"), requestUrl.queryItemValue(QStringLiteral("nonce")));
+        responseUrl.addQueryItem(QStringLiteral("v"), QStringLiteral("1.0"));
 
         response = responseUrl.query().toUtf8();
 
         m_step++;
         return true;
     } else {
-        warning(QSL("QXmppSaslClientFacebook : Invalid step"));
+        warning(QStringLiteral("QXmppSaslClientFacebook : Invalid step"));
         return false;
     }
 }
@@ -513,7 +513,7 @@ QXmppSaslClientGoogle::QXmppSaslClientGoogle(QObject *parent)
 
 QString QXmppSaslClientGoogle::mechanism() const
 {
-    return QSL("X-OAUTH2");
+    return QStringLiteral("X-OAUTH2");
 }
 
 bool QXmppSaslClientGoogle::respond(const QByteArray &challenge, QByteArray &response)
@@ -525,7 +525,7 @@ bool QXmppSaslClientGoogle::respond(const QByteArray &challenge, QByteArray &res
         m_step++;
         return true;
     } else {
-        warning(QSL("QXmppSaslClientGoogle : Invalid step"));
+        warning(QStringLiteral("QXmppSaslClientGoogle : Invalid step"));
         return false;
     }
 }
@@ -537,7 +537,7 @@ QXmppSaslClientPlain::QXmppSaslClientPlain(QObject *parent)
 
 QString QXmppSaslClientPlain::mechanism() const
 {
-    return QSL("PLAIN");
+    return QStringLiteral("PLAIN");
 }
 
 bool QXmppSaslClientPlain::respond(const QByteArray &challenge, QByteArray &response)
@@ -548,7 +548,7 @@ bool QXmppSaslClientPlain::respond(const QByteArray &challenge, QByteArray &resp
         m_step++;
         return true;
     } else {
-        warning(QSL("QXmppSaslClientPlain : Invalid step"));
+        warning(QStringLiteral("QXmppSaslClientPlain : Invalid step"));
         return false;
     }
 }
@@ -561,10 +561,10 @@ QXmppSaslClientScram::QXmppSaslClientScram(QCryptographicHash::Algorithm algorit
 
     if (m_algorithm == QCryptographicHash::Sha256) {
         m_dklen = 32;
-        m_mechanism = QSL("SCRAM-SHA-256");
+        m_mechanism = QStringLiteral("SCRAM-SHA-256");
     } else {
         m_dklen = 20;
-        m_mechanism = QSL("SCRAM-SHA-1");
+        m_mechanism = QStringLiteral("SCRAM-SHA-1");
     }
 }
 
@@ -577,8 +577,8 @@ bool QXmppSaslClientScram::respond(const QByteArray &challenge, QByteArray &resp
 {
     Q_UNUSED(challenge);
     if (m_step == 0) {
-        m_gs2Header = QBL("n,,");
-        m_clientFirstMessageBare = QBL("n=") + username().toUtf8() + QBL(",r=") + m_nonce;
+        m_gs2Header = QByteArrayLiteral("n,,");
+        m_clientFirstMessageBare = QByteArrayLiteral("n=") + username().toUtf8() + QByteArrayLiteral(",r=") + m_nonce;
 
         response = m_gs2Header + m_clientFirstMessageBare;
         m_step++;
@@ -594,20 +594,20 @@ bool QXmppSaslClientScram::respond(const QByteArray &challenge, QByteArray &resp
         }
 
         // calculate proofs
-        const QByteArray clientFinalMessageBare = QBL("c=") + m_gs2Header.toBase64() + QBL(",r=") + nonce;
+        const QByteArray clientFinalMessageBare = QByteArrayLiteral("c=") + m_gs2Header.toBase64() + QByteArrayLiteral(",r=") + nonce;
         const QByteArray saltedPassword = deriveKeyPbkdf2(m_algorithm, password().toUtf8(), salt,
                                                           iterations, m_dklen);
-        const QByteArray clientKey = QMessageAuthenticationCode::hash(QBL("Client Key"), saltedPassword, m_algorithm);
+        const QByteArray clientKey = QMessageAuthenticationCode::hash(QByteArrayLiteral("Client Key"), saltedPassword, m_algorithm);
         const QByteArray storedKey = QCryptographicHash::hash(clientKey, m_algorithm);
-        const QByteArray authMessage = m_clientFirstMessageBare + QBL(",") + challenge + QBL(",") + clientFinalMessageBare;
+        const QByteArray authMessage = m_clientFirstMessageBare + QByteArrayLiteral(",") + challenge + QByteArrayLiteral(",") + clientFinalMessageBare;
         QByteArray clientProof = QMessageAuthenticationCode::hash(authMessage, storedKey, m_algorithm);
         std::transform(clientProof.cbegin(), clientProof.cend(), clientKey.cbegin(),
                        clientProof.begin(), std::bit_xor<char>());
 
-        const QByteArray serverKey = QMessageAuthenticationCode::hash(QBL("Server Key"), saltedPassword, m_algorithm);
+        const QByteArray serverKey = QMessageAuthenticationCode::hash(QByteArrayLiteral("Server Key"), saltedPassword, m_algorithm);
         m_serverSignature = QMessageAuthenticationCode::hash(authMessage, serverKey, m_algorithm);
 
-        response = clientFinalMessageBare + QBL(",p=") + clientProof.toBase64();
+        response = clientFinalMessageBare + QByteArrayLiteral(",p=") + clientProof.toBase64();
         m_step++;
         return true;
     } else if (m_step == 2) {
@@ -616,7 +616,7 @@ bool QXmppSaslClientScram::respond(const QByteArray &challenge, QByteArray &resp
         m_step++;
         return QByteArray::fromBase64(input.value('v')) == m_serverSignature;
     } else {
-        warning(QSL("QXmppSaslClientPlain : Invalid step"));
+        warning(QStringLiteral("QXmppSaslClientPlain : Invalid step"));
         return false;
     }
 }
@@ -628,7 +628,7 @@ QXmppSaslClientWindowsLive::QXmppSaslClientWindowsLive(QObject *parent)
 
 QString QXmppSaslClientWindowsLive::mechanism() const
 {
-    return QSL("X-MESSENGER-OAUTH2");
+    return QStringLiteral("X-MESSENGER-OAUTH2");
 }
 
 bool QXmppSaslClientWindowsLive::respond(const QByteArray &challenge, QByteArray &response)
@@ -640,7 +640,7 @@ bool QXmppSaslClientWindowsLive::respond(const QByteArray &challenge, QByteArray
         m_step++;
         return true;
     } else {
-        warning(QSL("QXmppSaslClientWindowsLive : Invalid step"));
+        warning(QStringLiteral("QXmppSaslClientWindowsLive : Invalid step"));
         return false;
     }
 }
@@ -668,11 +668,11 @@ QXmppSaslServer::~QXmppSaslServer()
 
 QXmppSaslServer *QXmppSaslServer::create(const QString &mechanism, QObject *parent)
 {
-    if (mechanism == QSL("PLAIN")) {
+    if (mechanism == QStringLiteral("PLAIN")) {
         return new QXmppSaslServerPlain(parent);
-    } else if (mechanism == QSL("DIGEST-MD5")) {
+    } else if (mechanism == QStringLiteral("DIGEST-MD5")) {
         return new QXmppSaslServerDigestMd5(parent);
-    } else if (mechanism == QSL("ANONYMOUS")) {
+    } else if (mechanism == QStringLiteral("ANONYMOUS")) {
         return new QXmppSaslServerAnonymous(parent);
     } else {
         return nullptr;
@@ -742,7 +742,7 @@ QXmppSaslServerAnonymous::QXmppSaslServerAnonymous(QObject *parent)
 
 QString QXmppSaslServerAnonymous::mechanism() const
 {
-    return QSL("ANONYMOUS");
+    return QStringLiteral("ANONYMOUS");
 }
 
 QXmppSaslServer::Response QXmppSaslServerAnonymous::respond(const QByteArray &request, QByteArray &response)
@@ -753,7 +753,7 @@ QXmppSaslServer::Response QXmppSaslServerAnonymous::respond(const QByteArray &re
         response = QByteArray();
         return Succeeded;
     } else {
-        warning(QSL("QXmppSaslServerAnonymous : Invalid step"));
+        warning(QStringLiteral("QXmppSaslServerAnonymous : Invalid step"));
         return Failed;
     }
 }
@@ -766,52 +766,52 @@ QXmppSaslServerDigestMd5::QXmppSaslServerDigestMd5(QObject *parent)
 
 QString QXmppSaslServerDigestMd5::mechanism() const
 {
-    return QSL("DIGEST-MD5");
+    return QStringLiteral("DIGEST-MD5");
 }
 
 QXmppSaslServer::Response QXmppSaslServerDigestMd5::respond(const QByteArray &request, QByteArray &response)
 {
     if (m_step == 0) {
         QMap<QByteArray, QByteArray> output;
-        output[QBL("nonce")] = m_nonce;
+        output[QByteArrayLiteral("nonce")] = m_nonce;
         if (!realm().isEmpty())
-            output[QBL("realm")] = realm().toUtf8();
-        output[QBL("qop")] = QBL("auth");
-        output[QBL("charset")] = QBL("utf-8");
-        output[QBL("algorithm")] = QBL("md5-sess");
+            output[QByteArrayLiteral("realm")] = realm().toUtf8();
+        output[QByteArrayLiteral("qop")] = QByteArrayLiteral("auth");
+        output[QByteArrayLiteral("charset")] = QByteArrayLiteral("utf-8");
+        output[QByteArrayLiteral("algorithm")] = QByteArrayLiteral("md5-sess");
 
         m_step++;
         response = QXmppSaslDigestMd5::serializeMessage(output);
         return Challenge;
     } else if (m_step == 1) {
         const QMap<QByteArray, QByteArray> input = QXmppSaslDigestMd5::parseMessage(request);
-        const QByteArray realm = input.value(QBL("realm"));
-        const QByteArray digestUri = input.value(QBL("digest-uri"));
+        const QByteArray realm = input.value(QByteArrayLiteral("realm"));
+        const QByteArray digestUri = input.value(QByteArrayLiteral("digest-uri"));
 
-        if (input.value(QBL("qop")) != QBL("auth")) {
-            warning(QSL("QXmppSaslServerDigestMd5 : Invalid quality of protection"));
+        if (input.value(QByteArrayLiteral("qop")) != QByteArrayLiteral("auth")) {
+            warning(QStringLiteral("QXmppSaslServerDigestMd5 : Invalid quality of protection"));
             return Failed;
         }
 
-        setUsername(QString::fromUtf8(input.value(QBL("username"))));
+        setUsername(QString::fromUtf8(input.value(QByteArrayLiteral("username"))));
         if (password().isEmpty() && passwordDigest().isEmpty())
             return InputNeeded;
 
-        m_nc = input.value(QBL("nc"));
-        m_cnonce = input.value(QBL("cnonce"));
+        m_nc = input.value(QByteArrayLiteral("nc"));
+        m_cnonce = input.value(QByteArrayLiteral("cnonce"));
         if (!password().isEmpty()) {
             m_secret = QCryptographicHash::hash(
-                username().toUtf8() + QBL(":") + realm + QBL(":") + password().toUtf8(),
+                username().toUtf8() + QByteArrayLiteral(":") + realm + QByteArrayLiteral(":") + password().toUtf8(),
                 QCryptographicHash::Md5);
         } else {
             m_secret = passwordDigest();
         }
 
-        if (input.value(QBL("response")) != calculateDigest(QBL("AUTHENTICATE"), digestUri, m_secret, m_nonce, m_cnonce, m_nc))
+        if (input.value(QByteArrayLiteral("response")) != calculateDigest(QByteArrayLiteral("AUTHENTICATE"), digestUri, m_secret, m_nonce, m_cnonce, m_nc))
             return Failed;
 
         QMap<QByteArray, QByteArray> output;
-        output[QBL("rspauth")] = calculateDigest(QByteArray(), digestUri, m_secret, m_nonce, m_cnonce, m_nc);
+        output[QByteArrayLiteral("rspauth")] = calculateDigest(QByteArray(), digestUri, m_secret, m_nonce, m_cnonce, m_nc);
 
         m_step++;
         response = QXmppSaslDigestMd5::serializeMessage(output);
@@ -821,7 +821,7 @@ QXmppSaslServer::Response QXmppSaslServerDigestMd5::respond(const QByteArray &re
         response = QByteArray();
         return Succeeded;
     } else {
-        warning(QSL("QXmppSaslServerDigestMd5 : Invalid step"));
+        warning(QStringLiteral("QXmppSaslServerDigestMd5 : Invalid step"));
         return Failed;
     }
 }
@@ -833,7 +833,7 @@ QXmppSaslServerPlain::QXmppSaslServerPlain(QObject *parent)
 
 QString QXmppSaslServerPlain::mechanism() const
 {
-    return QSL("PLAIN");
+    return QStringLiteral("PLAIN");
 }
 
 QXmppSaslServer::Response QXmppSaslServerPlain::respond(const QByteArray &request, QByteArray &response)
@@ -846,7 +846,7 @@ QXmppSaslServer::Response QXmppSaslServerPlain::respond(const QByteArray &reques
 
         QList<QByteArray> auth = request.split('\0');
         if (auth.size() != 3) {
-            warning(QSL("QXmppSaslServerPlain : Invalid input"));
+            warning(QStringLiteral("QXmppSaslServerPlain : Invalid input"));
             return Failed;
         }
         setUsername(QString::fromUtf8(auth[1]));
@@ -856,7 +856,7 @@ QXmppSaslServer::Response QXmppSaslServerPlain::respond(const QByteArray &reques
         response = QByteArray();
         return InputNeeded;
     } else {
-        warning(QSL("QXmppSaslServerPlain : Invalid step"));
+        warning(QStringLiteral("QXmppSaslServerPlain : Invalid step"));
         return Failed;
     }
 }
@@ -871,7 +871,7 @@ QMap<QByteArray, QByteArray> QXmppSaslDigestMd5::parseMessage(const QByteArray &
     QMap<QByteArray, QByteArray> map;
     int startIndex = 0;
     int pos = 0;
-    while ((pos = ba.indexOf(QSL("="), startIndex)) >= 0) {
+    while ((pos = ba.indexOf(QStringLiteral("="), startIndex)) >= 0) {
         // key get name and skip equals
         const QByteArray key = ba.mid(startIndex, pos - startIndex).trimmed();
         pos++;
@@ -914,7 +914,7 @@ QByteArray QXmppSaslDigestMd5::serializeMessage(const QMap<QByteArray, QByteArra
     for (const auto &key : map.keys()) {
         if (!ba.isEmpty())
             ba.append(',');
-        ba.append(key + QBL("="));
+        ba.append(key + QByteArrayLiteral("="));
         QByteArray value = map[key];
         const char *separators = "()<>@,;:\\\"/[]?={} \t";
         bool quote = false;
@@ -925,9 +925,9 @@ QByteArray QXmppSaslDigestMd5::serializeMessage(const QMap<QByteArray, QByteArra
             }
         }
         if (quote) {
-            value.replace(QBL("\\"), QBL("\\\\"));
-            value.replace(QBL("\""), QBL("\\\""));
-            ba.append(QSL("\"") + value + QSL("\""));
+            value.replace(QByteArrayLiteral("\\"), QByteArrayLiteral("\\\\"));
+            value.replace(QByteArrayLiteral("\""), QByteArrayLiteral("\\\""));
+            ba.append(QStringLiteral("\"") + value + QStringLiteral("\""));
         } else
             ba.append(value);
     }
diff --git a/src/base/QXmppSessionIq.cpp b/src/base/QXmppSessionIq.cpp
index 16436148..b21cd4ac 100644
--- a/src/base/QXmppSessionIq.cpp
+++ b/src/base/QXmppSessionIq.cpp
@@ -33,13 +33,13 @@
 /// \cond
 bool QXmppSessionIq::isSessionIq(const QDomElement &element)
 {
-    QDomElement sessionElement = element.firstChildElement(QSL("session"));
+    QDomElement sessionElement = element.firstChildElement(QStringLiteral("session"));
     return (sessionElement.namespaceURI() == ns_session);
 }
 
 void QXmppSessionIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("session"));
+    writer->writeStartElement(QStringLiteral("session"));
     ;
     writer->writeDefaultNamespace(ns_session);
     writer->writeEndElement();
diff --git a/src/base/QXmppStanza.cpp b/src/base/QXmppStanza.cpp
index cb5622b6..1a870935 100644
--- a/src/base/QXmppStanza.cpp
+++ b/src/base/QXmppStanza.cpp
@@ -137,21 +137,21 @@ bool QXmppExtendedAddress::isValid() const
 /// \cond
 void QXmppExtendedAddress::parse(const QDomElement &element)
 {
-    d->delivered = element.attribute(QSL("delivered")) == QSL("true");
-    d->description = element.attribute(QSL("desc"));
-    d->jid = element.attribute(QSL("jid"));
-    d->type = element.attribute(QSL("type"));
+    d->delivered = element.attribute(QStringLiteral("delivered")) == QStringLiteral("true");
+    d->description = element.attribute(QStringLiteral("desc"));
+    d->jid = element.attribute(QStringLiteral("jid"));
+    d->type = element.attribute(QStringLiteral("type"));
 }
 
 void QXmppExtendedAddress::toXml(QXmlStreamWriter *xmlWriter) const
 {
-    xmlWriter->writeStartElement(QSL("address"));
+    xmlWriter->writeStartElement(QStringLiteral("address"));
     if (d->delivered)
-        xmlWriter->writeAttribute(QSL("delivered"), QSL("true"));
+        xmlWriter->writeAttribute(QStringLiteral("delivered"), QStringLiteral("true"));
     if (!d->description.isEmpty())
-        xmlWriter->writeAttribute(QSL("desc"), d->description);
-    xmlWriter->writeAttribute(QSL("jid"), d->jid);
-    xmlWriter->writeAttribute(QSL("type"), d->type);
+        xmlWriter->writeAttribute(QStringLiteral("desc"), d->description);
+    xmlWriter->writeAttribute(QStringLiteral("jid"), d->jid);
+    xmlWriter->writeAttribute(QStringLiteral("type"), d->type);
     xmlWriter->writeEndElement();
 }
 /// \endcond
@@ -347,15 +347,15 @@ QString QXmppStanza::Error::getTypeStr() const
 {
     switch (d->type) {
     case Cancel:
-        return QSL("cancel");
+        return QStringLiteral("cancel");
     case Continue:
-        return QSL("continue");
+        return QStringLiteral("continue");
     case Modify:
-        return QSL("modify");
+        return QStringLiteral("modify");
     case Auth:
-        return QSL("auth");
+        return QStringLiteral("auth");
     case Wait:
-        return QSL("wait");
+        return QStringLiteral("wait");
     default:
         return {};
     }
@@ -368,15 +368,15 @@ QString QXmppStanza::Error::getConditionStr() const
 
 void QXmppStanza::Error::setTypeFromStr(const QString &type)
 {
-    if (type == QSL("cancel"))
+    if (type == QStringLiteral("cancel"))
         setType(Cancel);
-    else if (type == QSL("continue"))
+    else if (type == QStringLiteral("continue"))
         setType(Continue);
-    else if (type == QSL("modify"))
+    else if (type == QStringLiteral("modify"))
         setType(Modify);
-    else if (type == QSL("auth"))
+    else if (type == QStringLiteral("auth"))
         setType(Auth);
-    else if (type == QSL("wait"))
+    else if (type == QStringLiteral("wait"))
         setType(Wait);
     else
         setType(static_cast<QXmppStanza::Error::Type>(-1));
@@ -389,28 +389,28 @@ void QXmppStanza::Error::setConditionFromStr(const QString &type)
 
 void QXmppStanza::Error::parse(const QDomElement &errorElement)
 {
-    setCode(errorElement.attribute(QSL("code")).toInt());
-    setTypeFromStr(errorElement.attribute(QSL("type")));
+    setCode(errorElement.attribute(QStringLiteral("code")).toInt());
+    setTypeFromStr(errorElement.attribute(QStringLiteral("type")));
 
     QDomElement element = errorElement.firstChildElement();
     while (!element.isNull()) {
         if (element.namespaceURI() == ns_stanza) {
-            if (element.tagName() == QSL("text"))
+            if (element.tagName() == QStringLiteral("text"))
                 setText(element.text());
             else
                 setConditionFromStr(element.tagName());
             // XEP-0363: HTTP File Upload
         } else if (element.namespaceURI() == ns_http_upload) {
             // file is too large
-            if (element.tagName() == QSL("file-too-large")) {
+            if (element.tagName() == QStringLiteral("file-too-large")) {
                 d->fileTooLarge = true;
-                d->maxFileSize = element.firstChildElement(QSL("max-file-size"))
+                d->maxFileSize = element.firstChildElement(QStringLiteral("max-file-size"))
                                      .text()
                                      .toLongLong();
                 // retry later
-            } else if (element.tagName() == QSL("retry")) {
+            } else if (element.tagName() == QStringLiteral("retry")) {
                 d->retryDate = QXmppUtils::datetimeFromString(
-                    element.attribute(QSL("stamp")));
+                    element.attribute(QStringLiteral("stamp")));
             }
         }
         element = element.nextSiblingElement();
@@ -425,11 +425,11 @@ void QXmppStanza::Error::toXml(QXmlStreamWriter *writer) const
     if (cond.isEmpty() && type.isEmpty())
         return;
 
-    writer->writeStartElement(QSL("error"));
-    helperToXmlAddAttribute(writer, QSL("type"), type);
+    writer->writeStartElement(QStringLiteral("error"));
+    helperToXmlAddAttribute(writer, QStringLiteral("type"), type);
 
     if (d->code > 0)
-        helperToXmlAddAttribute(writer, QSL("code"), QString::number(d->code));
+        helperToXmlAddAttribute(writer, QStringLiteral("code"), QString::number(d->code));
 
     if (!cond.isEmpty()) {
         writer->writeStartElement(cond);
@@ -437,8 +437,8 @@ void QXmppStanza::Error::toXml(QXmlStreamWriter *writer) const
         writer->writeEndElement();
     }
     if (!d->text.isEmpty()) {
-        writer->writeStartElement(QSL("text"));
-        writer->writeAttribute(QSL("xml:lang"), QSL("en"));
+        writer->writeStartElement(QStringLiteral("text"));
+        writer->writeAttribute(QStringLiteral("xml:lang"), QStringLiteral("en"));
         writer->writeDefaultNamespace(ns_stanza);
         writer->writeCharacters(d->text);
         writer->writeEndElement();
@@ -446,15 +446,15 @@ void QXmppStanza::Error::toXml(QXmlStreamWriter *writer) const
 
     // XEP-0363: HTTP File Upload
     if (d->fileTooLarge) {
-        writer->writeStartElement(QSL("file-too-large"));
+        writer->writeStartElement(QStringLiteral("file-too-large"));
         writer->writeDefaultNamespace(ns_http_upload);
-        helperToXmlAddTextElement(writer, QSL("max-file-size"),
+        helperToXmlAddTextElement(writer, QStringLiteral("max-file-size"),
                                   QString::number(d->maxFileSize));
         writer->writeEndElement();
     } else if (!d->retryDate.isNull() && d->retryDate.isValid()) {
-        writer->writeStartElement(QSL("retry"));
+        writer->writeStartElement(QStringLiteral("retry"));
         writer->writeDefaultNamespace(ns_http_upload);
-        writer->writeAttribute(QSL("stamp"),
+        writer->writeAttribute(QStringLiteral("stamp"),
                                QXmppUtils::datetimeToString(d->retryDate));
         writer->writeEndElement();
     }
diff --git a/src/base/QXmppStartTlsPacket.cpp b/src/base/QXmppStartTlsPacket.cpp
index 77c8738e..ea5feef9 100644
--- a/src/base/QXmppStartTlsPacket.cpp
+++ b/src/base/QXmppStartTlsPacket.cpp
@@ -29,9 +29,9 @@
 #include <QXmlStreamWriter>
 
 const static QStringList STARTTLS_TYPES = {
-    QSL("starttls"),
-    QSL("proceed"),
-    QSL("failure")
+    QStringLiteral("starttls"),
+    QStringLiteral("proceed"),
+    QStringLiteral("failure")
 };
 
 /// Constructs a new QXmppStartTlsPacket
diff --git a/src/base/QXmppStream.cpp b/src/base/QXmppStream.cpp
index eafbc8b4..1d81dbdb 100644
--- a/src/base/QXmppStream.cpp
+++ b/src/base/QXmppStream.cpp
@@ -41,7 +41,7 @@
 #include <QXmlStreamWriter>
 
 static bool randomSeeded = false;
-static const QByteArray streamRootElementEnd = QBL("</stream:stream>");
+static const QByteArray streamRootElementEnd = QByteArrayLiteral("</stream:stream>");
 
 class QXmppStreamPrivate
 {
@@ -190,7 +190,7 @@ void QXmppStream::setSocket(QSslSocket *socket)
 
 void QXmppStream::_q_socketConnected()
 {
-    info(QSL("Socket connected to %1 %2").arg(d->socket->peerAddress().toString(), QString::number(d->socket->peerPort())));
+    info(QStringLiteral("Socket connected to %1 %2").arg(d->socket->peerAddress().toString(), QString::number(d->socket->peerPort())));
     handleStart();
 }
 
@@ -203,7 +203,7 @@ void QXmppStream::_q_socketEncrypted()
 void QXmppStream::_q_socketError(QAbstractSocket::SocketError socketError)
 {
     Q_UNUSED(socketError);
-    warning(QSL("Socket error: ") + socket()->errorString());
+    warning(QStringLiteral("Socket error: ") + socket()->errorString());
 }
 
 void QXmppStream::_q_socketReadyRead()
diff --git a/src/base/QXmppStreamFeatures.cpp b/src/base/QXmppStreamFeatures.cpp
index de852330..a2ed180d 100644
--- a/src/base/QXmppStreamFeatures.cpp
+++ b/src/base/QXmppStreamFeatures.cpp
@@ -188,7 +188,7 @@ void QXmppStreamFeatures::setRegisterMode(const QXmppStreamFeatures::Mode &regis
 bool QXmppStreamFeatures::isStreamFeatures(const QDomElement &element)
 {
     return element.namespaceURI() == ns_stream &&
-        element.tagName() == QSL("features");
+        element.tagName() == QStringLiteral("features");
 }
 
 static QXmppStreamFeatures::Mode readFeature(const QDomElement &element, const char *tagName, const char *tagNs)
@@ -197,7 +197,7 @@ static QXmppStreamFeatures::Mode readFeature(const QDomElement &element, const c
     QXmppStreamFeatures::Mode mode = QXmppStreamFeatures::Disabled;
     while (!subElement.isNull()) {
         if (subElement.namespaceURI() == tagNs) {
-            if (!subElement.firstChildElement(QSL("required")).isNull())
+            if (!subElement.firstChildElement(QStringLiteral("required")).isNull())
                 mode = QXmppStreamFeatures::Required;
             else if (mode != QXmppStreamFeatures::Required)
                 mode = QXmppStreamFeatures::Enabled;
@@ -218,22 +218,22 @@ void QXmppStreamFeatures::parse(const QDomElement &element)
     d->registerMode = readFeature(element, "register", ns_register_feature);
 
     // parse advertised compression methods
-    QDomElement compression = element.firstChildElement(QSL("compression"));
+    QDomElement compression = element.firstChildElement(QStringLiteral("compression"));
     if (compression.namespaceURI() == ns_compressFeature) {
-        QDomElement subElement = compression.firstChildElement(QSL("method"));
+        QDomElement subElement = compression.firstChildElement(QStringLiteral("method"));
         while (!subElement.isNull()) {
             d->compressionMethods << subElement.text();
-            subElement = subElement.nextSiblingElement(QSL("method"));
+            subElement = subElement.nextSiblingElement(QStringLiteral("method"));
         }
     }
 
     // parse advertised SASL Authentication mechanisms
-    QDomElement mechs = element.firstChildElement(QSL("mechanisms"));
+    QDomElement mechs = element.firstChildElement(QStringLiteral("mechanisms"));
     if (mechs.namespaceURI() == ns_sasl) {
-        QDomElement subElement = mechs.firstChildElement(QSL("mechanism"));
+        QDomElement subElement = mechs.firstChildElement(QStringLiteral("mechanism"));
         while (!subElement.isNull()) {
             d->authMechanisms << subElement.text();
-            subElement = subElement.nextSiblingElement(QSL("mechanism"));
+            subElement = subElement.nextSiblingElement(QStringLiteral("mechanism"));
         }
     }
 }
@@ -244,14 +244,14 @@ static void writeFeature(QXmlStreamWriter *writer, const char *tagName, const ch
         writer->writeStartElement(tagName);
         writer->writeDefaultNamespace(tagNs);
         if (mode == QXmppStreamFeatures::Required)
-            writer->writeEmptyElement(QSL("required"));
+            writer->writeEmptyElement(QStringLiteral("required"));
         writer->writeEndElement();
     }
 }
 
 void QXmppStreamFeatures::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("stream:features"));
+    writer->writeStartElement(QStringLiteral("stream:features"));
     writeFeature(writer, "bind", ns_bind, d->bindMode);
     writeFeature(writer, "session", ns_session, d->sessionMode);
     writeFeature(writer, "auth", ns_authFeature, d->nonSaslAuthMode);
@@ -261,17 +261,17 @@ void QXmppStreamFeatures::toXml(QXmlStreamWriter *writer) const
     writeFeature(writer, "register", ns_register_feature, d->registerMode);
 
     if (!d->compressionMethods.isEmpty()) {
-        writer->writeStartElement(QSL("compression"));
+        writer->writeStartElement(QStringLiteral("compression"));
         writer->writeDefaultNamespace(ns_compressFeature);
         for (const auto &method : d->compressionMethods)
-            writer->writeTextElement(QSL("method"), method);
+            writer->writeTextElement(QStringLiteral("method"), method);
         writer->writeEndElement();
     }
     if (!d->authMechanisms.isEmpty()) {
-        writer->writeStartElement(QSL("mechanisms"));
+        writer->writeStartElement(QStringLiteral("mechanisms"));
         writer->writeDefaultNamespace(ns_sasl);
         for (const auto &mechanism : d->authMechanisms)
-            writer->writeTextElement(QSL("mechanism"), mechanism);
+            writer->writeTextElement(QStringLiteral("mechanism"), mechanism);
         writer->writeEndElement();
     }
     writer->writeEndElement();
diff --git a/src/base/QXmppStreamInitiationIq.cpp b/src/base/QXmppStreamInitiationIq.cpp
index a63a08fe..973f0937 100644
--- a/src/base/QXmppStreamInitiationIq.cpp
+++ b/src/base/QXmppStreamInitiationIq.cpp
@@ -80,25 +80,25 @@ void QXmppStreamInitiationIq::setSiId(const QString &id)
 /// \cond
 bool QXmppStreamInitiationIq::isStreamInitiationIq(const QDomElement &element)
 {
-    QDomElement siElement = element.firstChildElement(QSL("si"));
+    QDomElement siElement = element.firstChildElement(QStringLiteral("si"));
     return (siElement.namespaceURI() == ns_stream_initiation);
 }
 
 void QXmppStreamInitiationIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement siElement = element.firstChildElement(QSL("si"));
-    m_siId = siElement.attribute(QSL("id"));
-    m_mimeType = siElement.attribute(QSL("mime-type"));
-    if (siElement.attribute(QSL("profile")) == ns_stream_initiation_file_transfer)
+    QDomElement siElement = element.firstChildElement(QStringLiteral("si"));
+    m_siId = siElement.attribute(QStringLiteral("id"));
+    m_mimeType = siElement.attribute(QStringLiteral("mime-type"));
+    if (siElement.attribute(QStringLiteral("profile")) == ns_stream_initiation_file_transfer)
         m_profile = FileTransfer;
     else
         m_profile = None;
 
     QDomElement itemElement = siElement.firstChildElement();
     while (!itemElement.isNull()) {
-        if (itemElement.tagName() == QSL("feature") && itemElement.namespaceURI() == ns_feature_negotiation) {
+        if (itemElement.tagName() == QStringLiteral("feature") && itemElement.namespaceURI() == ns_feature_negotiation) {
             m_featureForm.parse(itemElement.firstChildElement());
-        } else if (itemElement.tagName() == QSL("file") && itemElement.namespaceURI() == ns_stream_initiation_file_transfer) {
+        } else if (itemElement.tagName() == QStringLiteral("file") && itemElement.namespaceURI() == ns_stream_initiation_file_transfer) {
             m_fileInfo.parse(itemElement);
         }
         itemElement = itemElement.nextSiblingElement();
@@ -107,16 +107,16 @@ void QXmppStreamInitiationIq::parseElementFromChild(const QDomElement &element)
 
 void QXmppStreamInitiationIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("si"));
+    writer->writeStartElement(QStringLiteral("si"));
     writer->writeDefaultNamespace(ns_stream_initiation);
-    helperToXmlAddAttribute(writer, QSL("id"), m_siId);
-    helperToXmlAddAttribute(writer, QSL("mime-type"), m_mimeType);
+    helperToXmlAddAttribute(writer, QStringLiteral("id"), m_siId);
+    helperToXmlAddAttribute(writer, QStringLiteral("mime-type"), m_mimeType);
     if (m_profile == FileTransfer)
-        helperToXmlAddAttribute(writer, QSL("profile"), ns_stream_initiation_file_transfer);
+        helperToXmlAddAttribute(writer, QStringLiteral("profile"), ns_stream_initiation_file_transfer);
     if (!m_fileInfo.isNull())
         m_fileInfo.toXml(writer);
     if (!m_featureForm.isNull()) {
-        writer->writeStartElement(QSL("feature"));
+        writer->writeStartElement(QStringLiteral("feature"));
         writer->writeDefaultNamespace(ns_feature_negotiation);
         m_featureForm.toXml(writer);
         writer->writeEndElement();
diff --git a/src/base/QXmppStreamManagement.cpp b/src/base/QXmppStreamManagement.cpp
index 24e1f913..5f1e735b 100644
--- a/src/base/QXmppStreamManagement.cpp
+++ b/src/base/QXmppStreamManagement.cpp
@@ -59,19 +59,19 @@ bool QXmppStreamManagementEnable::isStreamManagementEnable(const QDomElement &el
 
 void QXmppStreamManagementEnable::parse(const QDomElement &element)
 {
-    QString resume = element.attribute(QSL("resume"));
-    m_resume = resume == QSL("true") || resume == QSL("1");
-    m_max = element.attribute(QSL("max")).toUInt();
+    QString resume = element.attribute(QStringLiteral("resume"));
+    m_resume = resume == QStringLiteral("true") || resume == QStringLiteral("1");
+    m_max = element.attribute(QStringLiteral("max")).toUInt();
 }
 
 void QXmppStreamManagementEnable::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("enable"));
+    writer->writeStartElement(QStringLiteral("enable"));
     writer->writeDefaultNamespace(ns_stream_management);
     if (m_resume)
-        writer->writeAttribute(QSL("resume"), QSL("true"));
+        writer->writeAttribute(QStringLiteral("resume"), QStringLiteral("true"));
     if (m_max > 0)
-        writer->writeAttribute(QSL("max"), QString::number(m_max));
+        writer->writeAttribute(QStringLiteral("max"), QString::number(m_max));
     writer->writeEndElement();
 }
 
@@ -128,22 +128,22 @@ bool QXmppStreamManagementEnabled::isStreamManagementEnabled(const QDomElement &
 
 void QXmppStreamManagementEnabled::parse(const QDomElement &element)
 {
-    QString resume = element.attribute(QSL("resume"));
-    m_resume = resume == QSL("true") || resume == QSL("1");
-    m_max = element.attribute(QSL("max")).toUInt();
-    m_location = element.attribute(QSL("location"));
+    QString resume = element.attribute(QStringLiteral("resume"));
+    m_resume = resume == QStringLiteral("true") || resume == QStringLiteral("1");
+    m_max = element.attribute(QStringLiteral("max")).toUInt();
+    m_location = element.attribute(QStringLiteral("location"));
 }
 
 void QXmppStreamManagementEnabled::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("enable"));
+    writer->writeStartElement(QStringLiteral("enable"));
     writer->writeDefaultNamespace(ns_stream_management);
     if (m_resume)
-        writer->writeAttribute(QSL("resume"), QSL("true"));
+        writer->writeAttribute(QStringLiteral("resume"), QStringLiteral("true"));
     if (m_max > 0)
-        writer->writeAttribute(QSL("max"), QString::number(m_max));
+        writer->writeAttribute(QStringLiteral("max"), QString::number(m_max));
     if (!m_location.isEmpty())
-        writer->writeAttribute(QSL("location"), m_location);
+        writer->writeAttribute(QStringLiteral("location"), m_location);
     writer->writeEndElement();
 }
 
@@ -180,15 +180,15 @@ bool QXmppStreamManagementResume::isStreamManagementResume(const QDomElement &el
 
 void QXmppStreamManagementResume::parse(const QDomElement &element)
 {
-    m_h = element.attribute(QSL("h")).toUInt();
-    m_previd = element.attribute(QSL("previd"));
+    m_h = element.attribute(QStringLiteral("h")).toUInt();
+    m_previd = element.attribute(QStringLiteral("previd"));
 }
 
 void QXmppStreamManagementResume::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("resume"));
-    writer->writeAttribute(QSL("h"), QString::number(m_h));
-    writer->writeAttribute(QSL("previd"), m_previd);
+    writer->writeStartElement(QStringLiteral("resume"));
+    writer->writeAttribute(QStringLiteral("h"), QString::number(m_h));
+    writer->writeAttribute(QStringLiteral("previd"), m_previd);
     writer->writeEndElement();
 }
 
@@ -225,15 +225,15 @@ bool QXmppStreamManagementResumed::isStreamManagementResumed(const QDomElement &
 
 void QXmppStreamManagementResumed::parse(const QDomElement &element)
 {
-    m_h = element.attribute(QSL("h")).toUInt();
-    m_previd = element.attribute(QSL("previd"));
+    m_h = element.attribute(QStringLiteral("h")).toUInt();
+    m_previd = element.attribute(QStringLiteral("previd"));
 }
 
 void QXmppStreamManagementResumed::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("resumed"));
-    writer->writeAttribute(QSL("h"), QString::number(m_h));
-    writer->writeAttribute(QSL("previd"), m_previd);
+    writer->writeStartElement(QStringLiteral("resumed"));
+    writer->writeAttribute(QStringLiteral("h"), QString::number(m_h));
+    writer->writeAttribute(QStringLiteral("previd"), m_previd);
     writer->writeEndElement();
 }
 
@@ -270,7 +270,7 @@ void QXmppStreamManagementFailed::toXml(QXmlStreamWriter *writer) const
 {
     QString errorString = strFromCondition(m_error);
 
-    writer->writeStartElement(QSL("failed"));
+    writer->writeStartElement(QStringLiteral("failed"));
     writer->writeDefaultNamespace(ns_stream_management);
     writer->writeStartElement(errorString, ns_stanza);
     writer->writeEndElement();
@@ -294,14 +294,14 @@ void QXmppStreamManagementAck::setSeqNo(const unsigned seqNo)
 
 void QXmppStreamManagementAck::parse(const QDomElement &element)
 {
-    m_seqNo = element.attribute(QSL("h")).toUInt();
+    m_seqNo = element.attribute(QStringLiteral("h")).toUInt();
 }
 
 void QXmppStreamManagementAck::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("a"));
+    writer->writeStartElement(QStringLiteral("a"));
     writer->writeDefaultNamespace(ns_stream_management);
-    writer->writeAttribute(QSL("h"), QString::number(m_seqNo));
+    writer->writeAttribute(QStringLiteral("h"), QString::number(m_seqNo));
     writer->writeEndElement();
 }
 
diff --git a/src/base/QXmppStun.cpp b/src/base/QXmppStun.cpp
index 5725ce35..f109d5c6 100644
--- a/src/base/QXmppStun.cpp
+++ b/src/base/QXmppStun.cpp
@@ -773,7 +773,7 @@ bool QXmppStunMessage::decode(const QByteArray &buffer, const QByteArray &key, Q
 
             // Unknown attribute
             stream.skipRawData(a_length);
-            *errors << QSL("Skipping unknown attribute %1").arg(QString::number(a_type));
+            *errors << QStringLiteral("Skipping unknown attribute %1").arg(QString::number(a_type));
         }
         stream.skipRawData(pad_length);
         done += 4 + a_length + pad_length;
@@ -988,108 +988,108 @@ QString QXmppStunMessage::toString() const
     QString typeName;
     switch (messageMethod()) {
     case Binding:
-        typeName = QSL("Binding");
+        typeName = QStringLiteral("Binding");
         break;
     case SharedSecret:
-        typeName = QSL("Shared Secret");
+        typeName = QStringLiteral("Shared Secret");
         break;
     case Allocate:
-        typeName = QSL("Allocate");
+        typeName = QStringLiteral("Allocate");
         break;
     case Refresh:
-        typeName = QSL("Refresh");
+        typeName = QStringLiteral("Refresh");
         break;
     case Send:
-        typeName = QSL("Send");
+        typeName = QStringLiteral("Send");
         break;
     case Data:
-        typeName = QSL("Data");
+        typeName = QStringLiteral("Data");
         break;
     case CreatePermission:
-        typeName = QSL("CreatePermission");
+        typeName = QStringLiteral("CreatePermission");
         break;
     case ChannelBind:
-        typeName = QSL("ChannelBind");
+        typeName = QStringLiteral("ChannelBind");
         break;
     default:
-        typeName = QSL("Unknown");
+        typeName = QStringLiteral("Unknown");
         break;
     }
     switch (messageClass()) {
     case Request:
-        typeName += QSL(" Request");
+        typeName += QStringLiteral(" Request");
         break;
     case Indication:
-        typeName += QSL(" Indication");
+        typeName += QStringLiteral(" Indication");
         break;
     case Response:
-        typeName += QSL(" Response");
+        typeName += QStringLiteral(" Response");
         break;
     case Error:
-        typeName += QSL(" Error");
+        typeName += QStringLiteral(" Error");
         break;
     default:
         break;
     }
-    dumpLines << QSL(" type %1 (%2)")
+    dumpLines << QStringLiteral(" type %1 (%2)")
                      .arg(typeName)
                      .arg(QString::number(m_type));
-    dumpLines << QSL(" id %1").arg(QString::fromLatin1(m_id.toHex()));
+    dumpLines << QStringLiteral(" id %1").arg(QString::fromLatin1(m_id.toHex()));
 
     // attributes
     if (m_attributes.contains(ChannelNumber))
-        dumpLines << QSL(" * CHANNEL-NUMBER %1").arg(QString::number(m_channelNumber));
+        dumpLines << QStringLiteral(" * CHANNEL-NUMBER %1").arg(QString::number(m_channelNumber));
     if (errorCode)
-        dumpLines << QSL(" * ERROR-CODE %1 %2")
+        dumpLines << QStringLiteral(" * ERROR-CODE %1 %2")
                          .arg(QString::number(errorCode), errorPhrase);
     if (m_attributes.contains(Lifetime))
-        dumpLines << QSL(" * LIFETIME %1").arg(QString::number(m_lifetime));
+        dumpLines << QStringLiteral(" * LIFETIME %1").arg(QString::number(m_lifetime));
     if (m_attributes.contains(Nonce))
-        dumpLines << QSL(" * NONCE %1").arg(QString::fromLatin1(m_nonce));
+        dumpLines << QStringLiteral(" * NONCE %1").arg(QString::fromLatin1(m_nonce));
     if (m_attributes.contains(Realm))
-        dumpLines << QSL(" * REALM %1").arg(m_realm);
+        dumpLines << QStringLiteral(" * REALM %1").arg(m_realm);
     if (m_attributes.contains(RequestedTransport))
-        dumpLines << QSL(" * REQUESTED-TRANSPORT 0x%1").arg(QString::number(m_requestedTransport, 16));
+        dumpLines << QStringLiteral(" * REQUESTED-TRANSPORT 0x%1").arg(QString::number(m_requestedTransport, 16));
     if (m_attributes.contains(ReservationToken))
-        dumpLines << QSL(" * RESERVATION-TOKEN %1").arg(QString::fromLatin1(m_reservationToken.toHex()));
+        dumpLines << QStringLiteral(" * RESERVATION-TOKEN %1").arg(QString::fromLatin1(m_reservationToken.toHex()));
     if (m_attributes.contains(Software))
-        dumpLines << QSL(" * SOFTWARE %1").arg(m_software);
+        dumpLines << QStringLiteral(" * SOFTWARE %1").arg(m_software);
     if (m_attributes.contains(Username))
-        dumpLines << QSL(" * USERNAME %1").arg(m_username);
+        dumpLines << QStringLiteral(" * USERNAME %1").arg(m_username);
     if (mappedPort)
-        dumpLines << QSL(" * MAPPED-ADDRESS %1 %2")
+        dumpLines << QStringLiteral(" * MAPPED-ADDRESS %1 %2")
                          .arg(mappedHost.toString(), QString::number(mappedPort));
     if (m_attributes.contains(ChangeRequest))
-        dumpLines << QSL(" * CHANGE-REQUEST %1")
+        dumpLines << QStringLiteral(" * CHANGE-REQUEST %1")
                          .arg(QString::number(m_changeRequest));
     if (sourcePort)
-        dumpLines << QSL(" * SOURCE-ADDRESS %1 %2")
+        dumpLines << QStringLiteral(" * SOURCE-ADDRESS %1 %2")
                          .arg(sourceHost.toString(), QString::number(sourcePort));
     if (changedPort)
-        dumpLines << QSL(" * CHANGED-ADDRESS %1 %2")
+        dumpLines << QStringLiteral(" * CHANGED-ADDRESS %1 %2")
                          .arg(changedHost.toString(), QString::number(changedPort));
     if (otherPort)
-        dumpLines << QSL(" * OTHER-ADDRESS %1 %2")
+        dumpLines << QStringLiteral(" * OTHER-ADDRESS %1 %2")
                          .arg(otherHost.toString(), QString::number(otherPort));
     if (xorMappedPort)
-        dumpLines << QSL(" * XOR-MAPPED-ADDRESS %1 %2")
+        dumpLines << QStringLiteral(" * XOR-MAPPED-ADDRESS %1 %2")
                          .arg(xorMappedHost.toString(), QString::number(xorMappedPort));
     if (xorPeerPort)
-        dumpLines << QSL(" * XOR-PEER-ADDRESS %1 %2")
+        dumpLines << QStringLiteral(" * XOR-PEER-ADDRESS %1 %2")
                          .arg(xorPeerHost.toString(), QString::number(xorPeerPort));
     if (xorRelayedPort)
-        dumpLines << QSL(" * XOR-RELAYED-ADDRESS %1 %2")
+        dumpLines << QStringLiteral(" * XOR-RELAYED-ADDRESS %1 %2")
                          .arg(xorRelayedHost.toString(), QString::number(xorRelayedPort));
     if (m_attributes.contains(Priority))
-        dumpLines << QSL(" * PRIORITY %1").arg(QString::number(m_priority));
+        dumpLines << QStringLiteral(" * PRIORITY %1").arg(QString::number(m_priority));
     if (!iceControlling.isEmpty())
-        dumpLines << QSL(" * ICE-CONTROLLING %1")
+        dumpLines << QStringLiteral(" * ICE-CONTROLLING %1")
                          .arg(QString::fromLatin1(iceControlling.toHex()));
     if (!iceControlled.isEmpty())
-        dumpLines << QSL(" * ICE-CONTROLLED %1")
+        dumpLines << QStringLiteral(" * ICE-CONTROLLED %1")
                          .arg(QString::fromLatin1(iceControlled.toHex()));
     if (useCandidate)
-        dumpLines << QSL(" * USE-CANDIDATE");
+        dumpLines << QStringLiteral(" * USE-CANDIDATE");
 
     return dumpLines.join("\n");
 }
@@ -1212,7 +1212,7 @@ void QXmppTurnAllocation::connectToHost()
     // start listening for UDP
     if (socket->state() == QAbstractSocket::UnconnectedState) {
         if (!socket->bind()) {
-            warning(QSL("Could not start listening for TURN"));
+            warning(QStringLiteral("Could not start listening for TURN"));
             return;
         }
     }
@@ -1314,7 +1314,7 @@ void QXmppTurnAllocation::handleDatagram(const QByteArray &buffer, const QHostAd
     }
 
 #ifdef QXMPP_DEBUG_STUN
-    logReceived(QSL("TURN packet from %1 port %2\n%3").arg(remoteHost.toString(), QString::number(remotePort), message.toString()));
+    logReceived(QStringLiteral("TURN packet from %1 port %2\n%3").arg(remoteHost.toString(), QString::number(remotePort), message.toString()));
 #endif
 
     // find transaction
@@ -1457,7 +1457,7 @@ void QXmppTurnAllocation::transactionFinished()
     if (method == QXmppStunMessage::Allocate) {
 
         if (reply.messageClass() == QXmppStunMessage::Error) {
-            warning(QSL("Allocation failed: %1 %2").arg(QString::number(reply.errorCode), reply.errorPhrase));
+            warning(QStringLiteral("Allocation failed: %1 %2").arg(QString::number(reply.errorCode), reply.errorPhrase));
             setState(UnconnectedState);
             return;
         }
@@ -1482,7 +1482,7 @@ void QXmppTurnAllocation::transactionFinished()
     } else if (method == QXmppStunMessage::ChannelBind) {
 
         if (reply.messageClass() == QXmppStunMessage::Error) {
-            warning(QSL("ChannelBind failed: %1 %2").arg(QString::number(reply.errorCode), reply.errorPhrase));
+            warning(QStringLiteral("ChannelBind failed: %1 %2").arg(QString::number(reply.errorCode), reply.errorPhrase));
 
             // remove channel
             m_channels.remove(transaction->request().channelNumber());
@@ -1494,7 +1494,7 @@ void QXmppTurnAllocation::transactionFinished()
     } else if (method == QXmppStunMessage::Refresh) {
 
         if (reply.messageClass() == QXmppStunMessage::Error) {
-            warning(QSL("Refresh failed: %1 %2").arg(QString::number(reply.errorCode), reply.errorPhrase));
+            warning(QStringLiteral("Refresh failed: %1 %2").arg(QString::number(reply.errorCode), reply.errorPhrase));
             setState(UnconnectedState);
             return;
         }
@@ -1556,7 +1556,7 @@ void QXmppTurnAllocation::writeStun(const QXmppStunMessage &message)
 {
     socket->writeDatagram(message.encode(m_key), m_turnHost, m_turnPort);
 #ifdef QXMPP_DEBUG_STUN
-    logSent(QSL("TURN packet to %1 port %2\n%3").arg(m_turnHost.toString(), QString::number(m_turnPort), message.toString()));
+    logSent(QStringLiteral("TURN packet to %1 port %2\n%3").arg(m_turnHost.toString(), QString::number(m_turnPort), message.toString()));
 #endif
 }
 
@@ -1589,7 +1589,7 @@ QXmppJingleCandidate QXmppUdpTransport::localCandidate(int component) const
     candidate.setHost(addr);
     candidate.setId(QXmppUtils::generateStanzaHash(10));
     candidate.setPort(m_socket->localPort());
-    candidate.setProtocol(QSL("udp"));
+    candidate.setProtocol(QStringLiteral("udp"));
     candidate.setType(QXmppJingleCandidate::HostType);
     candidate.setPriority(candidatePriority(candidate));
     candidate.setFoundation(computeFoundation(
@@ -1677,19 +1677,19 @@ CandidatePair::State CandidatePair::state() const
 void CandidatePair::setState(CandidatePair::State state)
 {
     m_state = state;
-    info(QSL("ICE pair changed to state %1 %2").arg(QLatin1String(pair_states[state]), toString()));
+    info(QStringLiteral("ICE pair changed to state %1 %2").arg(QLatin1String(pair_states[state]), toString()));
 }
 
 QString CandidatePair::toString() const
 {
     const QXmppJingleCandidate candidate = transport->localCandidate(m_component);
-    QString str = QSL("%1 port %2").arg(remote.host().toString(), QString::number(remote.port()));
+    QString str = QStringLiteral("%1 port %2").arg(remote.host().toString(), QString::number(remote.port()));
     if (candidate.type() == QXmppJingleCandidate::HostType)
-        str += QSL(" (local %1 port %2)").arg(candidate.host().toString(), QString::number(candidate.port()));
+        str += QStringLiteral(" (local %1 port %2)").arg(candidate.host().toString(), QString::number(candidate.port()));
     else
-        str += QSL(" (relayed)");
+        str += QStringLiteral(" (relayed)");
     if (!reflexive.host().isNull() && reflexive.port())
-        str += QSL(" (reflexive %1 port %2)").arg(reflexive.host().toString(), QString::number(reflexive.port()));
+        str += QStringLiteral(" (reflexive %1 port %2)").arg(reflexive.host().toString(), QString::number(reflexive.port()));
     return str;
 }
 
@@ -1772,7 +1772,7 @@ bool QXmppIceComponentPrivate::addRemoteCandidate(const QXmppJingleCandidate &ca
         (candidate.type() != QXmppJingleCandidate::HostType &&
          candidate.type() != QXmppJingleCandidate::RelayedType &&
          candidate.type() != QXmppJingleCandidate::ServerReflexiveType) ||
-        candidate.protocol() != QSL("udp") ||
+        candidate.protocol() != QStringLiteral("udp") ||
         (candidate.host().protocol() != QAbstractSocket::IPv4Protocol &&
          candidate.host().protocol() != QAbstractSocket::IPv6Protocol))
         return false;
@@ -1817,7 +1817,7 @@ void QXmppIceComponentPrivate::performCheck(CandidatePair *pair, bool nominate)
     message.setId(QXmppUtils::generateRandomBytes(STUN_ID_SIZE));
     message.setType(QXmppStunMessage::Binding | QXmppStunMessage::Request);
     message.setPriority(peerReflexivePriority);
-    message.setUsername(QSL("%1:%2").arg(config->remoteUser, config->localUser));
+    message.setUsername(QStringLiteral("%1:%2").arg(config->remoteUser, config->localUser));
     if (config->iceControlling) {
         message.iceControlling = config->tieBreaker;
         message.useCandidate = true;
@@ -1902,7 +1902,7 @@ void QXmppIceComponentPrivate::writeStun(const QXmppStunMessage &message, QXmppI
     const QByteArray data = message.encode(messagePassword.toUtf8());
     transport->writeDatagram(data, address, port);
 #ifdef QXMPP_DEBUG_STUN
-    q->logSent(QSL("STUN packet to %1 port %2\n%3").arg(address.toString(), QString::number(port), message.toString()));
+    q->logSent(QStringLiteral("STUN packet to %1 port %2\n%3").arg(address.toString(), QString::number(port), message.toString()));
 #endif
 }
 
@@ -1936,7 +1936,7 @@ QXmppIceComponent::QXmppIceComponent(int component, QXmppIcePrivate *config, QOb
     reflexive.setType(QXmppJingleCandidate::PeerReflexiveType);
     d->peerReflexivePriority = candidatePriority(reflexive);
 
-    setObjectName(QSL("STUN(%1)").arg(QString::number(d->component)));
+    setObjectName(QStringLiteral("STUN(%1)").arg(QString::number(d->component)));
 }
 
 /// Destroys the QXmppIceComponent.
@@ -1959,7 +1959,7 @@ void QXmppIceComponent::checkCandidates()
 {
     if (d->config->remoteUser.isEmpty())
         return;
-    debug(QSL("Checking remote candidates"));
+    debug(QStringLiteral("Checking remote candidates"));
 
     for (auto *pair : d->pairs) {
         if (pair->state() == CandidatePair::WaitingState) {
@@ -2055,7 +2055,7 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
         return;
     }
 #ifdef QXMPP_DEBUG_STUN
-    logReceived(QSL("STUN packet from %1 port %2\n%3").arg(remoteHost.toString(), QString::number(remotePort), message.toString()));
+    logReceived(QStringLiteral("STUN packet from %1 port %2\n%3").arg(remoteHost.toString(), QString::number(remotePort), message.toString()));
 #endif
 
     // we only want binding requests and responses
@@ -2073,10 +2073,10 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
     if (message.messageClass() == QXmppStunMessage::Request) {
         // check for role conflict
         if (d->config->iceControlling && (!message.iceControlling.isEmpty() || message.useCandidate)) {
-            warning(QSL("Role conflict, expected to be controlling"));
+            warning(QStringLiteral("Role conflict, expected to be controlling"));
             return;
         } else if (!d->config->iceControlling && !message.iceControlled.isEmpty()) {
-            warning(QSL("Role conflict, expected to be controlled"));
+            warning(QStringLiteral("Role conflict, expected to be controlled"));
             return;
         }
 
@@ -2105,7 +2105,7 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
             remoteCandidate.setId(QXmppUtils::generateStanzaHash(10));
             remoteCandidate.setPort(remotePort);
             remoteCandidate.setPriority(message.priority());
-            remoteCandidate.setProtocol(QSL("udp"));
+            remoteCandidate.setProtocol(QStringLiteral("udp"));
             remoteCandidate.setType(QXmppJingleCandidate::PeerReflexiveType);
             remoteCandidate.setFoundation(QXmppUtils::generateStanzaHash(32));
 
@@ -2162,7 +2162,7 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
         if (remoteHost != pair->remote.host() || remotePort != pair->remote.port()) {
             QXmppStunMessage error;
             error.setType(QXmppStunMessage::Error);
-            error.errorPhrase = QSL("Received response from unexpected %1:%1").arg(remoteHost.toString(), QString::number(remotePort));
+            error.errorPhrase = QStringLiteral("Received response from unexpected %1:%1").arg(remoteHost.toString(), QString::number(remotePort));
             pair->transaction->readStun(error);
             return;
         }
@@ -2174,7 +2174,7 @@ void QXmppIceComponent::handleDatagram(const QByteArray &buffer, const QHostAddr
     if (pair && pair->nominated) {
         d->timer->stop();
         if (!d->activePair || pair->priority() > d->activePair->priority()) {
-            info(QSL("ICE pair selected %1 (priority: %2)").arg(pair->toString(), QString::number(pair->priority())));
+            info(QStringLiteral("ICE pair selected %1 (priority: %2)").arg(pair->toString(), QString::number(pair->priority())));
             const bool wasConnected = (d->activePair != nullptr);
             d->activePair = pair;
             if (!wasConnected)
@@ -2205,7 +2205,7 @@ void QXmppIceComponent::transactionFinished()
                 pair->nominated = true;
             }
         } else {
-            debug(QSL("ICE forward check failed %1 (error %2)").arg(pair->toString(), transaction->response().errorPhrase));
+            debug(QStringLiteral("ICE forward check failed %1 (error %2)").arg(pair->toString(), transaction->response().errorPhrase));
             pair->setState(CandidatePair::FailedState);
         }
         pair->transaction = nullptr;
@@ -2227,7 +2227,7 @@ void QXmppIceComponent::transactionFinished()
                 reflexiveHost = response.mappedHost;
                 reflexivePort = response.mappedPort;
             } else {
-                warning(QSL("STUN server did not provide a reflexive address"));
+                warning(QStringLiteral("STUN server did not provide a reflexive address"));
                 return;
             }
 
@@ -2240,7 +2240,7 @@ void QXmppIceComponent::transactionFinished()
             }
 
             // add the new local candidate
-            debug(QSL("Adding server-reflexive candidate %1 port %2").arg(reflexiveHost.toString(), QString::number(reflexivePort)));
+            debug(QStringLiteral("Adding server-reflexive candidate %1 port %2").arg(reflexiveHost.toString(), QString::number(reflexivePort)));
             QXmppJingleCandidate candidate;
             candidate.setComponent(d->component);
             candidate.setHost(reflexiveHost);
@@ -2258,7 +2258,7 @@ void QXmppIceComponent::transactionFinished()
 
             emit localCandidatesChanged();
         } else {
-            debug(QSL("STUN test failed (error %1)").arg(transaction->response().errorPhrase));
+            debug(QStringLiteral("STUN test failed (error %1)").arg(transaction->response().errorPhrase));
         }
         d->stunTransactions.remove(transaction);
         updateGatheringState();
@@ -2271,7 +2271,7 @@ void QXmppIceComponent::turnConnected()
     const QXmppJingleCandidate candidate = d->turnAllocation->localCandidate(d->component);
 
     // add the new local candidate
-    debug(QSL("Adding relayed candidate %1 port %2").arg(candidate.host().toString(), QString::number(candidate.port())));
+    debug(QStringLiteral("Adding relayed candidate %1 port %2").arg(candidate.host().toString(), QString::number(candidate.port())));
     d->localCandidates << candidate;
 
     emit localCandidatesChanged();
@@ -2421,7 +2421,7 @@ void QXmppIceComponent::writeStun(const QXmppStunMessage &message)
     if (transport) {
         transport->writeDatagram(message.encode(), transportDetails.stunHost, transportDetails.stunPort);
 #ifdef QXMPP_DEBUG_STUN
-        logSent(QSL("STUN packet to %1 port %2\n%3").arg(transportDetails.stunHost.toString(), QString::number(transportDetails.stunPort), message.toString()));
+        logSent(QStringLiteral("STUN packet to %1 port %2\n%3").arg(transportDetails.stunHost.toString(), QString::number(transportDetails.stunPort), message.toString()));
 #endif
         return;
     }
@@ -2487,7 +2487,7 @@ void QXmppIceConnection::addComponent(int component)
 {
 
     if (d->components.contains(component)) {
-        warning(QSL("Already have component %1").arg(QString::number(component)));
+        warning(QStringLiteral("Already have component %1").arg(QString::number(component)));
         return;
     }
 
@@ -2516,7 +2516,7 @@ void QXmppIceConnection::addRemoteCandidate(const QXmppJingleCandidate &candidat
 {
     QXmppIceComponent *socket = d->components.value(candidate.component());
     if (!socket) {
-        warning(QSL("Not adding candidate for unknown component %1").arg(QString::number(candidate.component())));
+        warning(QStringLiteral("Not adding candidate for unknown component %1").arg(QString::number(candidate.component())));
         return;
     }
     socket->d->addRemoteCandidate(candidate);
@@ -2708,7 +2708,7 @@ void QXmppIceConnection::slotConnected()
     for (auto *socket : d->components.values())
         if (!socket->isConnected())
             return;
-    info(QSL("ICE negotiation completed"));
+    info(QStringLiteral("ICE negotiation completed"));
     d->connectTimer->stop();
     emit connected();
 }
@@ -2732,7 +2732,7 @@ void QXmppIceConnection::slotGatheringStateChanged()
         newGatheringState = BusyGatheringState;
 
     if (newGatheringState != d->gatheringState) {
-        info(QSL("ICE gathering state changed from '%1' to '%2'").arg(gathering_states[d->gatheringState], gathering_states[newGatheringState]));
+        info(QStringLiteral("ICE gathering state changed from '%1' to '%2'").arg(gathering_states[d->gatheringState], gathering_states[newGatheringState]));
         d->gatheringState = newGatheringState;
         emit gatheringStateChanged();
     }
@@ -2740,7 +2740,7 @@ void QXmppIceConnection::slotGatheringStateChanged()
 
 void QXmppIceConnection::slotTimeout()
 {
-    warning(QSL("ICE negotiation timed out"));
+    warning(QStringLiteral("ICE negotiation timed out"));
     for (auto *socket : d->components.values())
         socket->close();
     emit disconnected();
diff --git a/src/base/QXmppUtils.cpp b/src/base/QXmppUtils.cpp
index ff331f39..23071580 100644
--- a/src/base/QXmppUtils.cpp
+++ b/src/base/QXmppUtils.cpp
@@ -113,25 +113,25 @@ static quint32 crctable[256] = {
 ///
 QDateTime QXmppUtils::datetimeFromString(const QString &str)
 {
-    QRegExp tzRe(QSL("(Z|([+-])([0-9]{2}):([0-9]{2}))"));
+    QRegExp tzRe(QStringLiteral("(Z|([+-])([0-9]{2}):([0-9]{2}))"));
     int tzPos = tzRe.indexIn(str, 19);
     if (str.size() < 20 || tzPos < 0)
         return QDateTime();
 
     // process date and time
-    QDateTime dt = QDateTime::fromString(str.left(19), QSL("yyyy-MM-ddThh:mm:ss"));
+    QDateTime dt = QDateTime::fromString(str.left(19), QStringLiteral("yyyy-MM-ddThh:mm:ss"));
     dt.setTimeSpec(Qt::UTC);
 
     // process milliseconds
     if (tzPos > 20 && str.at(19) == '.') {
-        QString millis = (str.mid(20, tzPos - 20) + QSL("000")).left(3);
+        QString millis = (str.mid(20, tzPos - 20) + QStringLiteral("000")).left(3);
         dt = dt.addMSecs(millis.toInt());
     }
 
     // process time zone
-    if (tzRe.cap(1) != QSL("Z")) {
+    if (tzRe.cap(1) != QStringLiteral("Z")) {
         int offset = tzRe.cap(3).toInt() * 3600 + tzRe.cap(4).toInt() * 60;
-        if (tzRe.cap(2) == QSL("+"))
+        if (tzRe.cap(2) == QStringLiteral("+"))
             dt = dt.addSecs(-offset);
         else
             dt = dt.addSecs(offset);
@@ -147,9 +147,9 @@ QString QXmppUtils::datetimeToString(const QDateTime &dt)
 {
     QDateTime utc = dt.toUTC();
     if (utc.time().msec())
-        return utc.toString(QSL("yyyy-MM-ddThh:mm:ss.zzzZ"));
+        return utc.toString(QStringLiteral("yyyy-MM-ddThh:mm:ss.zzzZ"));
     else
-        return utc.toString(QSL("yyyy-MM-ddThh:mm:ssZ"));
+        return utc.toString(QStringLiteral("yyyy-MM-ddThh:mm:ssZ"));
 }
 
 ///
@@ -158,18 +158,18 @@ QString QXmppUtils::datetimeToString(const QDateTime &dt)
 ///
 int QXmppUtils::timezoneOffsetFromString(const QString &str)
 {
-    QRegExp tzRe(QSL("(Z|([+-])([0-9]{2}):([0-9]{2}))"));
+    QRegExp tzRe(QStringLiteral("(Z|([+-])([0-9]{2}):([0-9]{2}))"));
     if (!tzRe.exactMatch(str))
         return 0;
 
     // No offset from UTC
-    if (tzRe.cap(1) == QSL("Z"))
+    if (tzRe.cap(1) == QStringLiteral("Z"))
         return 0;
 
     // Calculate offset
     const int offset = tzRe.cap(3).toInt() * 3600 +
         tzRe.cap(4).toInt() * 60;
-    if (tzRe.cap(2) == QSL("-"))
+    if (tzRe.cap(2) == QStringLiteral("-"))
         return -offset;
     else
         return offset;
@@ -182,17 +182,17 @@ int QXmppUtils::timezoneOffsetFromString(const QString &str)
 QString QXmppUtils::timezoneOffsetToString(int secs)
 {
     if (!secs)
-        return QSL("Z");
+        return QStringLiteral("Z");
 
     const QTime tzoTime = QTime(0, 0, 0).addSecs(qAbs(secs));
-    return (secs < 0 ? QSL("-") : QSL("+")) + tzoTime.toString(QSL("hh:mm"));
+    return (secs < 0 ? QStringLiteral("-") : QStringLiteral("+")) + tzoTime.toString(QStringLiteral("hh:mm"));
 }
 
 /// Returns the domain for the given \a jid.
 
 QString QXmppUtils::jidToDomain(const QString &jid)
 {
-    return jidToBareJid(jid).split(QSL("@")).last();
+    return jidToBareJid(jid).split(QStringLiteral("@")).last();
 }
 
 /// Returns the resource for the given \a jid.
@@ -331,7 +331,7 @@ QString QXmppUtils::generateStanzaHash(int length)
     if (length == 36)
         return QXmppUtils::generateStanzaUuid();
 
-    const QString somechars = QSL("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+    const QString somechars = QStringLiteral("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
     const int N = somechars.size();
     QString hashResult;
     for (int idx = 0; idx < length; ++idx)
diff --git a/src/base/QXmppVCardIq.cpp b/src/base/QXmppVCardIq.cpp
index 30a6bc65..b1096d4f 100644
--- a/src/base/QXmppVCardIq.cpp
+++ b/src/base/QXmppVCardIq.cpp
@@ -32,20 +32,20 @@
 static QString getImageType(const QByteArray &contents)
 {
     if (contents.startsWith("\x89PNG\x0d\x0a\x1a\x0a"))
-        return QSL("image/png");
+        return QStringLiteral("image/png");
     else if (contents.startsWith("\x8aMNG"))
-        return QSL("video/x-mng");
+        return QStringLiteral("video/x-mng");
     else if (contents.startsWith("GIF8"))
-        return QSL("image/gif");
+        return QStringLiteral("image/gif");
     else if (contents.startsWith("BM"))
-        return QSL("image/bmp");
+        return QStringLiteral("image/bmp");
     else if (contents.contains("/* XPM */"))
-        return QSL("image/x-xpm");
+        return QStringLiteral("image/x-xpm");
     else if (contents.contains("<?xml") && contents.contains("<svg"))
-        return QSL("image/svg+xml");
+        return QStringLiteral("image/svg+xml");
     else if (contents.startsWith("\xFF\xD8\xFF\xE0"))
-        return QSL("image/jpeg");
-    return QSL("image/unknown");
+        return QStringLiteral("image/jpeg");
+    return QStringLiteral("image/unknown");
 }
 
 class QXmppVCardAddressPrivate : public QSharedData
@@ -192,44 +192,44 @@ void QXmppVCardAddress::setType(QXmppVCardAddress::Type type)
 /// \cond
 void QXmppVCardAddress::parse(const QDomElement &element)
 {
-    if (!element.firstChildElement(QSL("HOME")).isNull())
+    if (!element.firstChildElement(QStringLiteral("HOME")).isNull())
         d->type |= Home;
-    if (!element.firstChildElement(QSL("WORK")).isNull())
+    if (!element.firstChildElement(QStringLiteral("WORK")).isNull())
         d->type |= Work;
-    if (!element.firstChildElement(QSL("POSTAL")).isNull())
+    if (!element.firstChildElement(QStringLiteral("POSTAL")).isNull())
         d->type |= Postal;
-    if (!element.firstChildElement(QSL("PREF")).isNull())
+    if (!element.firstChildElement(QStringLiteral("PREF")).isNull())
         d->type |= Preferred;
 
-    d->country = element.firstChildElement(QSL("CTRY")).text();
-    d->locality = element.firstChildElement(QSL("LOCALITY")).text();
-    d->postcode = element.firstChildElement(QSL("PCODE")).text();
-    d->region = element.firstChildElement(QSL("REGION")).text();
-    d->street = element.firstChildElement(QSL("STREET")).text();
+    d->country = element.firstChildElement(QStringLiteral("CTRY")).text();
+    d->locality = element.firstChildElement(QStringLiteral("LOCALITY")).text();
+    d->postcode = element.firstChildElement(QStringLiteral("PCODE")).text();
+    d->region = element.firstChildElement(QStringLiteral("REGION")).text();
+    d->street = element.firstChildElement(QStringLiteral("STREET")).text();
 }
 
 void QXmppVCardAddress::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("ADR"));
+    writer->writeStartElement(QStringLiteral("ADR"));
     if (d->type & Home)
-        writer->writeEmptyElement(QSL("HOME"));
+        writer->writeEmptyElement(QStringLiteral("HOME"));
     if (d->type & Work)
-        writer->writeEmptyElement(QSL("WORK"));
+        writer->writeEmptyElement(QStringLiteral("WORK"));
     if (d->type & Postal)
-        writer->writeEmptyElement(QSL("POSTAL"));
+        writer->writeEmptyElement(QStringLiteral("POSTAL"));
     if (d->type & Preferred)
-        writer->writeEmptyElement(QSL("PREF"));
+        writer->writeEmptyElement(QStringLiteral("PREF"));
 
     if (!d->country.isEmpty())
-        writer->writeTextElement(QSL("CTRY"), d->country);
+        writer->writeTextElement(QStringLiteral("CTRY"), d->country);
     if (!d->locality.isEmpty())
-        writer->writeTextElement(QSL("LOCALITY"), d->locality);
+        writer->writeTextElement(QStringLiteral("LOCALITY"), d->locality);
     if (!d->postcode.isEmpty())
-        writer->writeTextElement(QSL("PCODE"), d->postcode);
+        writer->writeTextElement(QStringLiteral("PCODE"), d->postcode);
     if (!d->region.isEmpty())
-        writer->writeTextElement(QSL("REGION"), d->region);
+        writer->writeTextElement(QStringLiteral("REGION"), d->region);
     if (!d->street.isEmpty())
-        writer->writeTextElement(QSL("STREET"), d->street);
+        writer->writeTextElement(QStringLiteral("STREET"), d->street);
 
     writer->writeEndElement();
 }
@@ -315,33 +315,33 @@ void QXmppVCardEmail::setType(QXmppVCardEmail::Type type)
 /// \cond
 void QXmppVCardEmail::parse(const QDomElement &element)
 {
-    if (!element.firstChildElement(QSL("HOME")).isNull())
+    if (!element.firstChildElement(QStringLiteral("HOME")).isNull())
         d->type |= Home;
-    if (!element.firstChildElement(QSL("WORK")).isNull())
+    if (!element.firstChildElement(QStringLiteral("WORK")).isNull())
         d->type |= Work;
-    if (!element.firstChildElement(QSL("INTERNET")).isNull())
+    if (!element.firstChildElement(QStringLiteral("INTERNET")).isNull())
         d->type |= Internet;
-    if (!element.firstChildElement(QSL("PREF")).isNull())
+    if (!element.firstChildElement(QStringLiteral("PREF")).isNull())
         d->type |= Preferred;
-    if (!element.firstChildElement(QSL("X400")).isNull())
+    if (!element.firstChildElement(QStringLiteral("X400")).isNull())
         d->type |= X400;
-    d->address = element.firstChildElement(QSL("USERID")).text();
+    d->address = element.firstChildElement(QStringLiteral("USERID")).text();
 }
 
 void QXmppVCardEmail::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("EMAIL"));
+    writer->writeStartElement(QStringLiteral("EMAIL"));
     if (d->type & Home)
-        writer->writeEmptyElement(QSL("HOME"));
+        writer->writeEmptyElement(QStringLiteral("HOME"));
     if (d->type & Work)
-        writer->writeEmptyElement(QSL("WORK"));
+        writer->writeEmptyElement(QStringLiteral("WORK"));
     if (d->type & Internet)
-        writer->writeEmptyElement(QSL("INTERNET"));
+        writer->writeEmptyElement(QStringLiteral("INTERNET"));
     if (d->type & Preferred)
-        writer->writeEmptyElement(QSL("PREF"));
+        writer->writeEmptyElement(QStringLiteral("PREF"));
     if (d->type & X400)
-        writer->writeEmptyElement(QSL("X400"));
-    writer->writeTextElement(QSL("USERID"), d->address);
+        writer->writeEmptyElement(QStringLiteral("X400"));
+    writer->writeTextElement(QStringLiteral("USERID"), d->address);
     writer->writeEndElement();
 }
 /// \endcond
@@ -426,65 +426,65 @@ void QXmppVCardPhone::setType(QXmppVCardPhone::Type type)
 /// \cond
 void QXmppVCardPhone::parse(const QDomElement &element)
 {
-    if (!element.firstChildElement(QSL("HOME")).isNull())
+    if (!element.firstChildElement(QStringLiteral("HOME")).isNull())
         d->type |= Home;
-    if (!element.firstChildElement(QSL("WORK")).isNull())
+    if (!element.firstChildElement(QStringLiteral("WORK")).isNull())
         d->type |= Work;
-    if (!element.firstChildElement(QSL("VOICE")).isNull())
+    if (!element.firstChildElement(QStringLiteral("VOICE")).isNull())
         d->type |= Voice;
-    if (!element.firstChildElement(QSL("FAX")).isNull())
+    if (!element.firstChildElement(QStringLiteral("FAX")).isNull())
         d->type |= Fax;
-    if (!element.firstChildElement(QSL("PAGER")).isNull())
+    if (!element.firstChildElement(QStringLiteral("PAGER")).isNull())
         d->type |= Pager;
-    if (!element.firstChildElement(QSL("MSG")).isNull())
+    if (!element.firstChildElement(QStringLiteral("MSG")).isNull())
         d->type |= Messaging;
-    if (!element.firstChildElement(QSL("CELL")).isNull())
+    if (!element.firstChildElement(QStringLiteral("CELL")).isNull())
         d->type |= Cell;
-    if (!element.firstChildElement(QSL("VIDEO")).isNull())
+    if (!element.firstChildElement(QStringLiteral("VIDEO")).isNull())
         d->type |= Video;
-    if (!element.firstChildElement(QSL("BBS")).isNull())
+    if (!element.firstChildElement(QStringLiteral("BBS")).isNull())
         d->type |= BBS;
-    if (!element.firstChildElement(QSL("MODEM")).isNull())
+    if (!element.firstChildElement(QStringLiteral("MODEM")).isNull())
         d->type |= Modem;
-    if (!element.firstChildElement(QSL("ISDN")).isNull())
+    if (!element.firstChildElement(QStringLiteral("ISDN")).isNull())
         d->type |= ISDN;
-    if (!element.firstChildElement(QSL("PCS")).isNull())
+    if (!element.firstChildElement(QStringLiteral("PCS")).isNull())
         d->type |= PCS;
-    if (!element.firstChildElement(QSL("PREF")).isNull())
+    if (!element.firstChildElement(QStringLiteral("PREF")).isNull())
         d->type |= Preferred;
-    d->number = element.firstChildElement(QSL("NUMBER")).text();
+    d->number = element.firstChildElement(QStringLiteral("NUMBER")).text();
 }
 
 void QXmppVCardPhone::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("TEL"));
+    writer->writeStartElement(QStringLiteral("TEL"));
     if (d->type & Home)
-        writer->writeEmptyElement(QSL("HOME"));
+        writer->writeEmptyElement(QStringLiteral("HOME"));
     if (d->type & Work)
-        writer->writeEmptyElement(QSL("WORK"));
+        writer->writeEmptyElement(QStringLiteral("WORK"));
     if (d->type & Voice)
-        writer->writeEmptyElement(QSL("VOICE"));
+        writer->writeEmptyElement(QStringLiteral("VOICE"));
     if (d->type & Fax)
-        writer->writeEmptyElement(QSL("FAX"));
+        writer->writeEmptyElement(QStringLiteral("FAX"));
     if (d->type & Pager)
-        writer->writeEmptyElement(QSL("PAGER"));
+        writer->writeEmptyElement(QStringLiteral("PAGER"));
     if (d->type & Messaging)
-        writer->writeEmptyElement(QSL("MSG"));
+        writer->writeEmptyElement(QStringLiteral("MSG"));
     if (d->type & Cell)
-        writer->writeEmptyElement(QSL("CELL"));
+        writer->writeEmptyElement(QStringLiteral("CELL"));
     if (d->type & Video)
-        writer->writeEmptyElement(QSL("VIDEO"));
+        writer->writeEmptyElement(QStringLiteral("VIDEO"));
     if (d->type & BBS)
-        writer->writeEmptyElement(QSL("BBS"));
+        writer->writeEmptyElement(QStringLiteral("BBS"));
     if (d->type & Modem)
-        writer->writeEmptyElement(QSL("MODEM"));
+        writer->writeEmptyElement(QStringLiteral("MODEM"));
     if (d->type & ISDN)
-        writer->writeEmptyElement(QSL("ISDN"));
+        writer->writeEmptyElement(QStringLiteral("ISDN"));
     if (d->type & PCS)
-        writer->writeEmptyElement(QSL("PCS"));
+        writer->writeEmptyElement(QStringLiteral("PCS"));
     if (d->type & Preferred)
-        writer->writeEmptyElement(QSL("PREF"));
-    writer->writeTextElement(QSL("NUMBER"), d->number);
+        writer->writeEmptyElement(QStringLiteral("PREF"));
+    writer->writeTextElement(QStringLiteral("NUMBER"), d->number);
     writer->writeEndElement();
 }
 /// \endcond
@@ -600,25 +600,25 @@ void QXmppVCardOrganization::setTitle(const QString &title)
 /// \cond
 void QXmppVCardOrganization::parse(const QDomElement &cardElem)
 {
-    d->title = cardElem.firstChildElement(QSL("TITLE")).text();
-    d->role = cardElem.firstChildElement(QSL("ROLE")).text();
+    d->title = cardElem.firstChildElement(QStringLiteral("TITLE")).text();
+    d->role = cardElem.firstChildElement(QStringLiteral("ROLE")).text();
 
-    const QDomElement &orgElem = cardElem.firstChildElement(QSL("ORG"));
-    d->organization = orgElem.firstChildElement(QSL("ORGNAME")).text();
-    d->unit = orgElem.firstChildElement(QSL("ORGUNIT")).text();
+    const QDomElement &orgElem = cardElem.firstChildElement(QStringLiteral("ORG"));
+    d->organization = orgElem.firstChildElement(QStringLiteral("ORGNAME")).text();
+    d->unit = orgElem.firstChildElement(QStringLiteral("ORGUNIT")).text();
 }
 
 void QXmppVCardOrganization::toXml(QXmlStreamWriter *stream) const
 {
     if (!d->unit.isEmpty() || !d->organization.isEmpty()) {
-        stream->writeStartElement(QSL("ORG"));
-        stream->writeTextElement(QSL("ORGNAME"), d->organization);
-        stream->writeTextElement(QSL("ORGUNIT"), d->unit);
+        stream->writeStartElement(QStringLiteral("ORG"));
+        stream->writeTextElement(QStringLiteral("ORGNAME"), d->organization);
+        stream->writeTextElement(QStringLiteral("ORGUNIT"), d->unit);
         stream->writeEndElement();
     }
 
-    helperToXmlAddTextElement(stream, QSL("TITLE"), d->title);
-    helperToXmlAddTextElement(stream, QSL("ROLE"), d->role);
+    helperToXmlAddTextElement(stream, QStringLiteral("TITLE"), d->title);
+    helperToXmlAddTextElement(stream, QStringLiteral("ROLE"), d->role);
 }
 /// \endcond
 
@@ -959,38 +959,38 @@ void QXmppVCardIq::setOrganization(const QXmppVCardOrganization &org)
 /// \cond
 bool QXmppVCardIq::isVCard(const QDomElement &nodeRecv)
 {
-    return nodeRecv.firstChildElement(QSL("vCard")).namespaceURI() == ns_vcard;
+    return nodeRecv.firstChildElement(QStringLiteral("vCard")).namespaceURI() == ns_vcard;
 }
 
 void QXmppVCardIq::parseElementFromChild(const QDomElement &nodeRecv)
 {
     // vCard
-    QDomElement cardElement = nodeRecv.firstChildElement(QSL("vCard"));
-    d->birthday = QDate::fromString(cardElement.firstChildElement(QSL("BDAY")).text(), QSL("yyyy-MM-dd"));
-    d->description = cardElement.firstChildElement(QSL("DESC")).text();
-    d->fullName = cardElement.firstChildElement(QSL("FN")).text();
-    d->nickName = cardElement.firstChildElement(QSL("NICKNAME")).text();
-    QDomElement nameElement = cardElement.firstChildElement(QSL("N"));
-    d->firstName = nameElement.firstChildElement(QSL("GIVEN")).text();
-    d->lastName = nameElement.firstChildElement(QSL("FAMILY")).text();
-    d->middleName = nameElement.firstChildElement(QSL("MIDDLE")).text();
-    d->url = cardElement.firstChildElement(QSL("URL")).text();
-    QDomElement photoElement = cardElement.firstChildElement(QSL("PHOTO"));
-    QByteArray base64data = photoElement.firstChildElement(QSL("BINVAL")).text().toLatin1();
+    QDomElement cardElement = nodeRecv.firstChildElement(QStringLiteral("vCard"));
+    d->birthday = QDate::fromString(cardElement.firstChildElement(QStringLiteral("BDAY")).text(), QStringLiteral("yyyy-MM-dd"));
+    d->description = cardElement.firstChildElement(QStringLiteral("DESC")).text();
+    d->fullName = cardElement.firstChildElement(QStringLiteral("FN")).text();
+    d->nickName = cardElement.firstChildElement(QStringLiteral("NICKNAME")).text();
+    QDomElement nameElement = cardElement.firstChildElement(QStringLiteral("N"));
+    d->firstName = nameElement.firstChildElement(QStringLiteral("GIVEN")).text();
+    d->lastName = nameElement.firstChildElement(QStringLiteral("FAMILY")).text();
+    d->middleName = nameElement.firstChildElement(QStringLiteral("MIDDLE")).text();
+    d->url = cardElement.firstChildElement(QStringLiteral("URL")).text();
+    QDomElement photoElement = cardElement.firstChildElement(QStringLiteral("PHOTO"));
+    QByteArray base64data = photoElement.firstChildElement(QStringLiteral("BINVAL")).text().toLatin1();
     d->photo = QByteArray::fromBase64(base64data);
-    d->photoType = photoElement.firstChildElement(QSL("TYPE")).text();
+    d->photoType = photoElement.firstChildElement(QStringLiteral("TYPE")).text();
 
     QDomElement child = cardElement.firstChildElement();
     while (!child.isNull()) {
-        if (child.tagName() == QSL("ADR")) {
+        if (child.tagName() == QStringLiteral("ADR")) {
             QXmppVCardAddress address;
             address.parse(child);
             d->addresses << address;
-        } else if (child.tagName() == QSL("EMAIL")) {
+        } else if (child.tagName() == QStringLiteral("EMAIL")) {
             QXmppVCardEmail email;
             email.parse(child);
             d->emails << email;
-        } else if (child.tagName() == QSL("TEL")) {
+        } else if (child.tagName() == QStringLiteral("TEL")) {
             QXmppVCardPhone phone;
             phone.parse(child);
             d->phones << phone;
@@ -1003,46 +1003,46 @@ void QXmppVCardIq::parseElementFromChild(const QDomElement &nodeRecv)
 
 void QXmppVCardIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("vCard"));
+    writer->writeStartElement(QStringLiteral("vCard"));
     writer->writeDefaultNamespace(ns_vcard);
     for (const QXmppVCardAddress &address : d->addresses)
         address.toXml(writer);
     if (d->birthday.isValid())
-        helperToXmlAddTextElement(writer, QSL("BDAY"), d->birthday.toString(QSL("yyyy-MM-dd")));
+        helperToXmlAddTextElement(writer, QStringLiteral("BDAY"), d->birthday.toString(QStringLiteral("yyyy-MM-dd")));
     if (!d->description.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("DESC"), d->description);
+        helperToXmlAddTextElement(writer, QStringLiteral("DESC"), d->description);
     for (const QXmppVCardEmail &email : d->emails)
         email.toXml(writer);
     if (!d->fullName.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("FN"), d->fullName);
+        helperToXmlAddTextElement(writer, QStringLiteral("FN"), d->fullName);
     if (!d->nickName.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("NICKNAME"), d->nickName);
+        helperToXmlAddTextElement(writer, QStringLiteral("NICKNAME"), d->nickName);
     if (!d->firstName.isEmpty() ||
         !d->lastName.isEmpty() ||
         !d->middleName.isEmpty()) {
         writer->writeStartElement("N");
         if (!d->firstName.isEmpty())
-            helperToXmlAddTextElement(writer, QSL("GIVEN"), d->firstName);
+            helperToXmlAddTextElement(writer, QStringLiteral("GIVEN"), d->firstName);
         if (!d->lastName.isEmpty())
-            helperToXmlAddTextElement(writer, QSL("FAMILY"), d->lastName);
+            helperToXmlAddTextElement(writer, QStringLiteral("FAMILY"), d->lastName);
         if (!d->middleName.isEmpty())
-            helperToXmlAddTextElement(writer, QSL("MIDDLE"), d->middleName);
+            helperToXmlAddTextElement(writer, QStringLiteral("MIDDLE"), d->middleName);
         writer->writeEndElement();
     }
 
     for (const QXmppVCardPhone &phone : d->phones)
         phone.toXml(writer);
     if (!photo().isEmpty()) {
-        writer->writeStartElement(QSL("PHOTO"));
+        writer->writeStartElement(QStringLiteral("PHOTO"));
         QString photoType = d->photoType;
         if (photoType.isEmpty())
             photoType = getImageType(d->photo);
-        helperToXmlAddTextElement(writer, QSL("TYPE"), photoType);
-        helperToXmlAddTextElement(writer, QSL("BINVAL"), d->photo.toBase64());
+        helperToXmlAddTextElement(writer, QStringLiteral("TYPE"), photoType);
+        helperToXmlAddTextElement(writer, QStringLiteral("BINVAL"), d->photo.toBase64());
         writer->writeEndElement();
     }
     if (!d->url.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("URL"), d->url);
+        helperToXmlAddTextElement(writer, QStringLiteral("URL"), d->url);
 
     d->organization.toXml(writer);
 
diff --git a/src/base/QXmppVersionIq.cpp b/src/base/QXmppVersionIq.cpp
index c0017515..6cad6456 100644
--- a/src/base/QXmppVersionIq.cpp
+++ b/src/base/QXmppVersionIq.cpp
@@ -82,31 +82,31 @@ void QXmppVersionIq::setVersion(const QString &version)
 /// \cond
 bool QXmppVersionIq::isVersionIq(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
     return queryElement.namespaceURI() == ns_version;
 }
 
 void QXmppVersionIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement queryElement = element.firstChildElement(QSL("query"));
-    m_name = queryElement.firstChildElement(QSL("name")).text();
-    m_os = queryElement.firstChildElement(QSL("os")).text();
-    m_version = queryElement.firstChildElement(QSL("version")).text();
+    QDomElement queryElement = element.firstChildElement(QStringLiteral("query"));
+    m_name = queryElement.firstChildElement(QStringLiteral("name")).text();
+    m_os = queryElement.firstChildElement(QStringLiteral("os")).text();
+    m_version = queryElement.firstChildElement(QStringLiteral("version")).text();
 }
 
 void QXmppVersionIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement(QSL("query"));
+    writer->writeStartElement(QStringLiteral("query"));
     writer->writeDefaultNamespace(ns_version);
 
     if (!m_name.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("name"), m_name);
+        helperToXmlAddTextElement(writer, QStringLiteral("name"), m_name);
 
     if (!m_os.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("os"), m_os);
+        helperToXmlAddTextElement(writer, QStringLiteral("os"), m_os);
 
     if (!m_version.isEmpty())
-        helperToXmlAddTextElement(writer, QSL("version"), m_version);
+        helperToXmlAddTextElement(writer, QStringLiteral("version"), m_version);
 
     writer->writeEndElement();
 }