base: Convert to QStringLiteral

Two new macros were added:
* QBL (short alias for QByteArrayLiteral)
* QSL (short alias for QStringLiteral)

1 files changed, 127 insertions, 127 deletions

diff --git a/src/base/QXmppJingleIq.cpp b/src/base/QXmppJingleIq.cpp
index ea95c0e0..b37c75cd 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 QString("IN %1 %2").arg(host.protocol() == QAbstractSocket::IPv6Protocol ? "IP6" : "IP4", host.toString());
+    return QSL("IN %1 %2").arg(host.protocol() == QAbstractSocket::IPv6Protocol ? QSL("IP6") : QSL("IP4"), host.toString());
 }
 
 static bool candidateParseSdp(QXmppJingleCandidate *candidate, const QString &sdp)
 {
-    if (!sdp.startsWith("candidate:"))
+    if (!sdp.startsWith(QSL("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] == "typ") {
+        if (bits[i] == QSL("typ")) {
             bool ok;
             candidate->setType(QXmppJingleCandidate::typeFromString(bits[i + 1], &ok));
             if (!ok)
                 return false;
-        } else if (bits[i] == "generation") {
+        } else if (bits[i] == QSL("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 QString("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 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()));
 }
 
 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("creator");
-    d->disposition = element.attribute("disposition");
-    d->name = element.attribute("name");
-    d->senders = element.attribute("senders");
+    d->creator = element.attribute(QSL("creator"));
+    d->disposition = element.attribute(QSL("disposition"));
+    d->name = element.attribute(QSL("name"));
+    d->senders = element.attribute(QSL("senders"));
 
     // description
-    QDomElement descriptionElement = element.firstChildElement("description");
+    QDomElement descriptionElement = element.firstChildElement(QSL("description"));
     d->descriptionType = descriptionElement.namespaceURI();
-    d->descriptionMedia = descriptionElement.attribute("media");
-    d->descriptionSsrc = descriptionElement.attribute("ssrc").toULong();
-    QDomElement child = descriptionElement.firstChildElement("payload-type");
+    d->descriptionMedia = descriptionElement.attribute(QSL("media"));
+    d->descriptionSsrc = descriptionElement.attribute(QSL("ssrc")).toULong();
+    QDomElement child = descriptionElement.firstChildElement(QSL("payload-type"));
     while (!child.isNull()) {
         QXmppJinglePayloadType payload;
         payload.parse(child);
         d->payloadTypes << payload;
-        child = child.nextSiblingElement("payload-type");
+        child = child.nextSiblingElement(QSL("payload-type"));
     }
 
     // transport
-    QDomElement transportElement = element.firstChildElement("transport");
+    QDomElement transportElement = element.firstChildElement(QSL("transport"));
     d->transportType = transportElement.namespaceURI();
-    d->transportUser = transportElement.attribute("ufrag");
-    d->transportPassword = transportElement.attribute("pwd");
-    child = transportElement.firstChildElement("candidate");
+    d->transportUser = transportElement.attribute(QSL("ufrag"));
+    d->transportPassword = transportElement.attribute(QSL("pwd"));
+    child = transportElement.firstChildElement(QSL("candidate"));
     while (!child.isNull()) {
         QXmppJingleCandidate candidate;
         candidate.parse(child);
         d->transportCandidates << candidate;
-        child = child.nextSiblingElement("candidate");
+        child = child.nextSiblingElement(QSL("candidate"));
     }
-    child = transportElement.firstChildElement("fingerprint");
+    child = transportElement.firstChildElement(QSL("fingerprint"));
 
     /// XEP-0320
     if (!child.isNull()) {
         d->transportFingerprint = parseFingerprint(child.text());
-        d->transportFingerprintHash = child.attribute("hash");
-        d->transportFingerprintSetup = child.attribute("setup");
+        d->transportFingerprintHash = child.attribute(QSL("hash"));
+        d->transportFingerprintSetup = child.attribute(QSL("setup"));
     }
 }
 
@@ -401,19 +401,19 @@ void QXmppJingleIq::Content::toXml(QXmlStreamWriter *writer) const
     if (d->creator.isEmpty() || d->name.isEmpty())
         return;
 
-    writer->writeStartElement("content");
-    helperToXmlAddAttribute(writer, "creator", d->creator);
-    helperToXmlAddAttribute(writer, "disposition", d->disposition);
-    helperToXmlAddAttribute(writer, "name", d->name);
-    helperToXmlAddAttribute(writer, "senders", d->senders);
+    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);
 
     // description
     if (!d->descriptionType.isEmpty() || !d->payloadTypes.isEmpty()) {
-        writer->writeStartElement("description");
+        writer->writeStartElement(QSL("description"));
         writer->writeDefaultNamespace(d->descriptionType);
-        helperToXmlAddAttribute(writer, "media", d->descriptionMedia);
+        helperToXmlAddAttribute(writer, QSL("media"), d->descriptionMedia);
         if (d->descriptionSsrc)
-            writer->writeAttribute("ssrc", QString::number(d->descriptionSsrc));
+            writer->writeAttribute(QSL("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("transport");
+        writer->writeStartElement(QSL("transport"));
         writer->writeDefaultNamespace(d->transportType);
-        helperToXmlAddAttribute(writer, "ufrag", d->transportUser);
-        helperToXmlAddAttribute(writer, "pwd", d->transportPassword);
+        helperToXmlAddAttribute(writer, QSL("ufrag"), d->transportUser);
+        helperToXmlAddAttribute(writer, QSL("pwd"), d->transportPassword);
         for (const auto &candidate : d->transportCandidates)
             candidate.toXml(writer);
 
         // XEP-0320
         if (!d->transportFingerprint.isEmpty() && !d->transportFingerprintHash.isEmpty()) {
-            writer->writeStartElement("fingerprint");
+            writer->writeStartElement(QSL("fingerprint"));
             writer->writeDefaultNamespace(ns_jingle_dtls);
-            writer->writeAttribute("hash", d->transportFingerprintHash);
-            writer->writeAttribute("setup", d->transportFingerprintSetup);
+            writer->writeAttribute(QSL("hash"), d->transportFingerprintHash);
+            writer->writeAttribute(QSL("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("a=")) {
+        if (line.startsWith(QSL("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 == "candidate") {
+            if (attrName == QSL("candidate")) {
                 QXmppJingleCandidate candidate;
                 if (!candidateParseSdp(&candidate, line.mid(2))) {
                     qWarning() << "Could not parse candidate" << line;
                     return false;
                 }
                 addTransportCandidate(candidate);
-            } else if (attrName == "fingerprint") {
+            } else if (attrName == QSL("fingerprint")) {
                 const QStringList bits = attrValue.split(' ');
                 if (bits.size() > 1) {
                     d->transportFingerprintHash = bits[0];
                     d->transportFingerprint = parseFingerprint(bits[1]);
                 }
-            } else if (attrName == "fmtp") {
+            } else if (attrName == QSL("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() == "telephone-event") {
-                            params.insert("events", paramStr);
+                        if (payload.name() == QSL("telephone-event")) {
+                            params.insert(QSL("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 == "rtpmap") {
+            } else if (attrName == QSL("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 == "ice-ufrag") {
+            } else if (attrName == QSL("ice-ufrag")) {
                 d->transportUser = attrValue;
-            } else if (attrName == "ice-pwd") {
+            } else if (attrName == QSL("ice-pwd")) {
                 d->transportPassword = attrValue;
-            } else if (attrName == "setup") {
+            } else if (attrName == QSL("setup")) {
                 d->transportFingerprintSetup = attrValue;
-            } else if (attrName == "ssrc") {
+            } else if (attrName == QSL("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("m=")) {
+        } else if (line.startsWith(QSL("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() == "telephone-event") {
-            if (params.contains("events"))
-                paramList << params.value("events");
+        if (payload.name() == QSL("telephone-event")) {
+            if (params.contains(QSL("events")))
+                paramList << params.value(QSL("events"));
         } else {
             QMap<QString, QString>::const_iterator i;
             for (i = params.begin(); i != params.end(); ++i)
-                paramList << i.key() + "=" + i.value();
+                paramList << i.key() + QSL("=") + i.value();
         }
         if (!paramList.isEmpty())
-            attrs << "a=fmtp:" + QByteArray::number(payload.id()) + " " + paramList.join("; ");
+            attrs << QSL("a=fmtp:") + QByteArray::number(payload.id()) + QSL(" ") + paramList.join("; ");
     }
-    sdp << QString("m=%1 %2 RTP/AVP%3").arg(d->descriptionMedia, QString::number(localRtpPort), payloads);
-    sdp << QString("c=%1").arg(addressToSdp(localRtpAddress));
+    sdp << QSL("m=%1 %2 RTP/AVP%3").arg(d->descriptionMedia, QString::number(localRtpPort), payloads);
+    sdp << QSL("c=%1").arg(addressToSdp(localRtpAddress));
     sdp += attrs;
 
     // transport
     for (const auto &candidate : d->transportCandidates)
-        sdp << QString("a=%1").arg(candidateToSdp(candidate));
+        sdp << QSL("a=%1").arg(candidateToSdp(candidate));
     if (!d->transportUser.isEmpty())
-        sdp << QString("a=ice-ufrag:%1").arg(d->transportUser);
+        sdp << QSL("a=ice-ufrag:%1").arg(d->transportUser);
     if (!d->transportPassword.isEmpty())
-        sdp << QString("a=ice-pwd:%1").arg(d->transportPassword);
+        sdp << QSL("a=ice-pwd:%1").arg(d->transportPassword);
     if (!d->transportFingerprint.isEmpty() && !d->transportFingerprintHash.isEmpty())
-        sdp << QString("a=fingerprint:%1 %2").arg(d->transportFingerprintHash, formatFingerprint(d->transportFingerprint));
+        sdp << QSL("a=fingerprint:%1 %2").arg(d->transportFingerprintHash, formatFingerprint(d->transportFingerprint));
     if (!d->transportFingerprintSetup.isEmpty())
-        sdp << QString("a=setup:%1").arg(d->transportFingerprintSetup);
+        sdp << QSL("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("text").text();
+    m_text = element.firstChildElement(QSL("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("reason");
+    writer->writeStartElement(QSL("reason"));
     if (!m_text.isEmpty())
-        helperToXmlAddTextElement(writer, "text", m_text);
+        helperToXmlAddTextElement(writer, QSL("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("jingle");
+    QDomElement jingleElement = element.firstChildElement(QSL("jingle"));
     return (jingleElement.namespaceURI() == ns_jingle);
 }
 
 void QXmppJingleIq::parseElementFromChild(const QDomElement &element)
 {
-    QDomElement jingleElement = element.firstChildElement("jingle");
-    const QString action = jingleElement.attribute("action");
+    QDomElement jingleElement = element.firstChildElement(QSL("jingle"));
+    const QString action = jingleElement.attribute(QSL("action"));
     for (int i = ContentAccept; i <= TransportReplace; i++) {
         if (action == jingle_actions[i]) {
             d->action = static_cast<Action>(i);
             break;
         }
     }
-    d->initiator = jingleElement.attribute("initiator");
-    d->responder = jingleElement.attribute("responder");
-    d->sid = jingleElement.attribute("sid");
+    d->initiator = jingleElement.attribute(QSL("initiator"));
+    d->responder = jingleElement.attribute(QSL("responder"));
+    d->sid = jingleElement.attribute(QSL("sid"));
 
     // content
     d->contents.clear();
-    QDomElement contentElement = jingleElement.firstChildElement("content");
+    QDomElement contentElement = jingleElement.firstChildElement(QSL("content"));
     while (!contentElement.isNull()) {
         QXmppJingleIq::Content content;
         content.parse(contentElement);
         addContent(content);
-        contentElement = contentElement.nextSiblingElement("content");
+        contentElement = contentElement.nextSiblingElement(QSL("content"));
     }
-    QDomElement reasonElement = jingleElement.firstChildElement("reason");
+    QDomElement reasonElement = jingleElement.firstChildElement(QSL("reason"));
     d->reason.parse(reasonElement);
 
     // ringing
-    QDomElement ringingElement = jingleElement.firstChildElement("ringing");
+    QDomElement ringingElement = jingleElement.firstChildElement(QSL("ringing"));
     d->ringing = (ringingElement.namespaceURI() == ns_jingle_rtp_info);
 }
 
 void QXmppJingleIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement("jingle");
+    writer->writeStartElement(QSL("jingle"));
     writer->writeDefaultNamespace(ns_jingle);
-    helperToXmlAddAttribute(writer, "action", jingle_actions[d->action]);
-    helperToXmlAddAttribute(writer, "initiator", d->initiator);
-    helperToXmlAddAttribute(writer, "responder", d->responder);
-    helperToXmlAddAttribute(writer, "sid", d->sid);
+    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);
     for (const auto &content : d->contents)
         content.toXml(writer);
     d->reason.toXml(writer);
 
     // ringing
     if (d->ringing) {
-        writer->writeStartElement("ringing");
+        writer->writeStartElement(QSL("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("component").toInt();
-    d->foundation = element.attribute("foundation");
-    d->generation = element.attribute("generation").toInt();
-    d->host = QHostAddress(element.attribute("ip"));
-    d->id = element.attribute("id");
-    d->network = element.attribute("network").toInt();
-    d->port = element.attribute("port").toInt();
-    d->priority = element.attribute("priority").toInt();
-    d->protocol = element.attribute("protocol");
-    d->type = typeFromString(element.attribute("type"));
+    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")));
 }
 
 void QXmppJingleCandidate::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement("candidate");
-    helperToXmlAddAttribute(writer, "component", QString::number(d->component));
-    helperToXmlAddAttribute(writer, "foundation", d->foundation);
-    helperToXmlAddAttribute(writer, "generation", QString::number(d->generation));
-    helperToXmlAddAttribute(writer, "id", d->id);
-    helperToXmlAddAttribute(writer, "ip", d->host.toString());
-    helperToXmlAddAttribute(writer, "network", QString::number(d->network));
-    helperToXmlAddAttribute(writer, "port", QString::number(d->port));
-    helperToXmlAddAttribute(writer, "priority", QString::number(d->priority));
-    helperToXmlAddAttribute(writer, "protocol", d->protocol);
-    helperToXmlAddAttribute(writer, "type", typeToString(d->type));
+    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->writeEndElement();
 }
 
 QXmppJingleCandidate::Type QXmppJingleCandidate::typeFromString(const QString &typeStr, bool *ok)
 {
     QXmppJingleCandidate::Type type;
-    if (typeStr == "host")
+    if (typeStr == QSL("host"))
         type = HostType;
-    else if (typeStr == "prflx")
+    else if (typeStr == QSL("prflx"))
         type = PeerReflexiveType;
-    else if (typeStr == "srflx")
+    else if (typeStr == QSL("srflx"))
         type = ServerReflexiveType;
-    else if (typeStr == "relay")
+    else if (typeStr == QSL("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 = "host";
+        typeStr = QSL("host");
         break;
     case PeerReflexiveType:
-        typeStr = "prflx";
+        typeStr = QSL("prflx");
         break;
     case ServerReflexiveType:
-        typeStr = "srflx";
+        typeStr = QSL("srflx");
         break;
     case RelayedType:
-        typeStr = "relay";
+        typeStr = QSL("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("id").toInt();
-    d->name = element.attribute("name");
-    d->channels = element.attribute("channels").toInt();
+    d->id = element.attribute(QSL("id")).toInt();
+    d->name = element.attribute(QSL("name"));
+    d->channels = element.attribute(QSL("channels")).toInt();
     if (!d->channels)
         d->channels = 1;
-    d->clockrate = element.attribute("clockrate").toInt();
-    d->maxptime = element.attribute("maxptime").toInt();
-    d->ptime = element.attribute("ptime").toInt();
+    d->clockrate = element.attribute(QSL("clockrate")).toInt();
+    d->maxptime = element.attribute(QSL("maxptime")).toInt();
+    d->ptime = element.attribute(QSL("ptime")).toInt();
 
-    QDomElement child = element.firstChildElement("parameter");
+    QDomElement child = element.firstChildElement(QSL("parameter"));
     while (!child.isNull()) {
-        d->parameters.insert(child.attribute("name"), child.attribute("value"));
-        child = child.nextSiblingElement("parameter");
+        d->parameters.insert(child.attribute(QSL("name")), child.attribute(QSL("value")));
+        child = child.nextSiblingElement(QSL("parameter"));
     }
 }
 
 void QXmppJinglePayloadType::toXml(QXmlStreamWriter *writer) const
 {
-    writer->writeStartElement("payload-type");
-    helperToXmlAddAttribute(writer, "id", QString::number(d->id));
-    helperToXmlAddAttribute(writer, "name", d->name);
+    writer->writeStartElement(QSL("payload-type"));
+    helperToXmlAddAttribute(writer, QSL("id"), QString::number(d->id));
+    helperToXmlAddAttribute(writer, QSL("name"), d->name);
     if (d->channels > 1)
-        helperToXmlAddAttribute(writer, "channels", QString::number(d->channels));
+        helperToXmlAddAttribute(writer, QSL("channels"), QString::number(d->channels));
     if (d->clockrate > 0)
-        helperToXmlAddAttribute(writer, "clockrate", QString::number(d->clockrate));
+        helperToXmlAddAttribute(writer, QSL("clockrate"), QString::number(d->clockrate));
     if (d->maxptime > 0)
-        helperToXmlAddAttribute(writer, "maxptime", QString::number(d->maxptime));
+        helperToXmlAddAttribute(writer, QSL("maxptime"), QString::number(d->maxptime));
     if (d->ptime > 0)
-        helperToXmlAddAttribute(writer, "ptime", QString::number(d->ptime));
+        helperToXmlAddAttribute(writer, QSL("ptime"), QString::number(d->ptime));
 
     for (const auto &key : d->parameters.keys()) {
-        writer->writeStartElement("parameter");
-        writer->writeAttribute("name", key);
-        writer->writeAttribute("value", d->parameters.value(key));
+        writer->writeStartElement(QSL("parameter"));
+        writer->writeAttribute(QSL("name"), key);
+        writer->writeAttribute(QSL("value"), d->parameters.value(key));
         writer->writeEndElement();
     }
     writer->writeEndElement();