Merge pull request #295 from marcdeop/140_impose_coding_standard

140 impose coding standard

11 files changed, 674 insertions, 740 deletions

diff --git a/lib/jobs/basejob.cpp b/lib/jobs/basejob.cpp
index b3cfc527..a6471ece 100644
--- a/lib/jobs/basejob.cpp
+++ b/lib/jobs/basejob.cpp
@@ -13,7 +13,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #include "basejob.h"
@@ -21,19 +21,18 @@
 #include "connectiondata.h"
 #include "util.h"
 
+#include <QtCore/QJsonObject>
+#include <QtCore/QRegularExpression>
+#include <QtCore/QTimer>
 #include <QtNetwork/QNetworkAccessManager>
-#include <QtNetwork/QNetworkRequest>
 #include <QtNetwork/QNetworkReply>
-#include <QtCore/QTimer>
-#include <QtCore/QRegularExpression>
-#include <QtCore/QJsonObject>
+#include <QtNetwork/QNetworkRequest>
 
 #include <array>
 
 using namespace QMatrixClient;
 
-struct NetworkReplyDeleter : public QScopedPointerDeleteLater
-{
+struct NetworkReplyDeleter : public QScopedPointerDeleteLater {
     static inline void cleanup(QNetworkReply* reply)
     {
         if (reply && reply->isRunning())
@@ -42,54 +41,58 @@ struct NetworkReplyDeleter : public QScopedPointerDeleteLater
     }
 };
 
-class BaseJob::Private
-{
-    public:
-        // Using an idiom from clang-tidy:
-        // http://clang.llvm.org/extra/clang-tidy/checks/modernize-pass-by-value.html
-        Private(HttpVerb v, QString endpoint, const QUrlQuery& q,
-                Data&& data, bool nt)
-            : verb(v), apiEndpoint(std::move(endpoint)), requestQuery(q)
-            , requestData(std::move(data)), needsToken(nt)
-        { }
-        
-        void sendRequest(bool inBackground);
-        const JobTimeoutConfig& getCurrentTimeoutConfig() const;
-
-        const ConnectionData* connection = nullptr;
-
-        // Contents for the network request
-        HttpVerb verb;
-        QString apiEndpoint;
-        QHash<QByteArray, QByteArray> requestHeaders;
-        QUrlQuery requestQuery;
-        Data requestData;
-        bool needsToken;
-
-        // There's no use of QMimeType here because we don't want to match
-        // content types against the known MIME type hierarchy; and at the same
-        // type QMimeType is of little help with MIME type globs (`text/*` etc.)
-        QByteArrayList expectedContentTypes;
-
-        QScopedPointer<QNetworkReply, NetworkReplyDeleter> reply;
-        Status status = Pending;
-        QByteArray rawResponse;
-        QUrl errorUrl; //< May contain a URL to help with some errors
-
-        QTimer timer;
-        QTimer retryTimer;
-
-        QVector<JobTimeoutConfig> errorStrategy =
-            { { 90, 5 }, { 90, 10 }, { 120, 30 } };
-        int maxRetries = errorStrategy.size();
-        int retriesTaken = 0;
-
-        LoggingCategory logCat = JOBS;
+class BaseJob::Private {
+public:
+    // Using an idiom from clang-tidy:
+    // http://clang.llvm.org/extra/clang-tidy/checks/modernize-pass-by-value.html
+    Private(HttpVerb v, QString endpoint, const QUrlQuery& q, Data&& data,
+            bool nt)
+        : verb(v)
+        , apiEndpoint(std::move(endpoint))
+        , requestQuery(q)
+        , requestData(std::move(data))
+        , needsToken(nt)
+    {}
+
+    void sendRequest(bool inBackground);
+    const JobTimeoutConfig& getCurrentTimeoutConfig() const;
+
+    const ConnectionData* connection = nullptr;
+
+    // Contents for the network request
+    HttpVerb verb;
+    QString apiEndpoint;
+    QHash<QByteArray, QByteArray> requestHeaders;
+    QUrlQuery requestQuery;
+    Data requestData;
+    bool needsToken;
+
+    // There's no use of QMimeType here because we don't want to match
+    // content types against the known MIME type hierarchy; and at the same
+    // type QMimeType is of little help with MIME type globs (`text/*` etc.)
+    QByteArrayList expectedContentTypes;
+
+    QScopedPointer<QNetworkReply, NetworkReplyDeleter> reply;
+    Status status = Pending;
+    QByteArray rawResponse;
+    QUrl errorUrl; //< May contain a URL to help with some errors
+
+    QTimer timer;
+    QTimer retryTimer;
+
+    QVector<JobTimeoutConfig> errorStrategy = { { 90, 5 },
+                                                { 90, 10 },
+                                                { 120, 30 } };
+    int maxRetries = errorStrategy.size();
+    int retriesTaken = 0;
+
+    LoggingCategory logCat = JOBS;
 };
 
-BaseJob::BaseJob(HttpVerb verb, const QString& name, const QString& endpoint, bool needsToken)
-    : BaseJob(verb, name, endpoint, Query { }, Data { }, needsToken)
-{ }
+BaseJob::BaseJob(HttpVerb verb, const QString& name, const QString& endpoint,
+                 bool needsToken)
+    : BaseJob(verb, name, endpoint, Query {}, Data {}, needsToken)
+{}
 
 BaseJob::BaseJob(HttpVerb verb, const QString& name, const QString& endpoint,
                  const Query& query, Data&& data, bool needsToken)
@@ -98,7 +101,7 @@ BaseJob::BaseJob(HttpVerb verb, const QString& name, const QString& endpoint,
     setObjectName(name);
     setExpectedContentTypes({ "application/json" });
     d->timer.setSingleShot(true);
-    connect (&d->timer, &QTimer::timeout, this, &BaseJob::timeout);
+    connect(&d->timer, &QTimer::timeout, this, &BaseJob::timeout);
 }
 
 BaseJob::~BaseJob()
@@ -114,21 +117,20 @@ QUrl BaseJob::requestUrl() const
 
 bool BaseJob::isBackground() const
 {
-    return d->reply && d->reply->request().attribute(
-                        QNetworkRequest::BackgroundRequestAttribute).toBool();
+    return d->reply
+           && d->reply->request()
+                  .attribute(QNetworkRequest::BackgroundRequestAttribute)
+                  .toBool();
 }
 
-const QString& BaseJob::apiEndpoint() const
-{
-    return d->apiEndpoint;
-}
+const QString& BaseJob::apiEndpoint() const { return d->apiEndpoint; }
 
 void BaseJob::setApiEndpoint(const QString& apiEndpoint)
 {
     d->apiEndpoint = apiEndpoint;
 }
 
-const BaseJob::headers_t&BaseJob::requestHeaders() const
+const BaseJob::headers_t& BaseJob::requestHeaders() const
 {
     return d->requestHeaders;
 }
@@ -144,25 +146,16 @@ void BaseJob::setRequestHeaders(const BaseJob::headers_t& headers)
     d->requestHeaders = headers;
 }
 
-const QUrlQuery& BaseJob::query() const
-{
-    return d->requestQuery;
-}
+const QUrlQuery& BaseJob::query() const { return d->requestQuery; }
 
 void BaseJob::setRequestQuery(const QUrlQuery& query)
 {
     d->requestQuery = query;
 }
 
-const BaseJob::Data& BaseJob::requestData() const
-{
-    return d->requestData;
-}
+const BaseJob::Data& BaseJob::requestData() const { return d->requestData; }
 
-void BaseJob::setRequestData(Data&& data)
-{
-    std::swap(d->requestData, data);
-}
+void BaseJob::setRequestData(Data&& data) { std::swap(d->requestData, data); }
 
 const QByteArrayList& BaseJob::expectedContentTypes() const
 {
@@ -179,8 +172,8 @@ void BaseJob::setExpectedContentTypes(const QByteArrayList& contentTypes)
     d->expectedContentTypes = contentTypes;
 }
 
-QUrl BaseJob::makeRequestUrl(QUrl baseUrl,
-                             const QString& path, const QUrlQuery& query)
+QUrl BaseJob::makeRequestUrl(QUrl baseUrl, const QString& path,
+                             const QUrlQuery& query)
 {
     auto pathBase = baseUrl.path();
     if (!pathBase.endsWith('/') && !path.startsWith('/'))
@@ -193,8 +186,8 @@ QUrl BaseJob::makeRequestUrl(QUrl baseUrl,
 
 void BaseJob::Private::sendRequest(bool inBackground)
 {
-    QNetworkRequest req
-        { makeRequestUrl(connection->baseUrl(), apiEndpoint, requestQuery) };
+    QNetworkRequest req { makeRequestUrl(connection->baseUrl(), apiEndpoint,
+                                         requestQuery) };
     if (!requestHeaders.contains("Content-Type"))
         req.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
     req.setRawHeader("Authorization",
@@ -211,38 +204,34 @@ void BaseJob::Private::sendRequest(bool inBackground)
 #endif
     for (auto it = requestHeaders.cbegin(); it != requestHeaders.cend(); ++it)
         req.setRawHeader(it.key(), it.value());
-    switch( verb )
-    {
-        case HttpVerb::Get:
-            reply.reset( connection->nam()->get(req) );
-            break;
-        case HttpVerb::Post:
-            reply.reset( connection->nam()->post(req, requestData.source()) );
-            break;
-        case HttpVerb::Put:
-            reply.reset( connection->nam()->put(req, requestData.source()) );
-            break;
-        case HttpVerb::Delete:
-            reply.reset( connection->nam()->deleteResource(req) );
-            break;
+    switch (verb) {
+    case HttpVerb::Get:
+        reply.reset(connection->nam()->get(req));
+        break;
+    case HttpVerb::Post:
+        reply.reset(connection->nam()->post(req, requestData.source()));
+        break;
+    case HttpVerb::Put:
+        reply.reset(connection->nam()->put(req, requestData.source()));
+        break;
+    case HttpVerb::Delete:
+        reply.reset(connection->nam()->deleteResource(req));
+        break;
     }
 }
 
-void BaseJob::beforeStart(const ConnectionData*)
-{ }
+void BaseJob::beforeStart(const ConnectionData*) {}
 
-void BaseJob::afterStart(const ConnectionData*, QNetworkReply*)
-{ }
+void BaseJob::afterStart(const ConnectionData*, QNetworkReply*) {}
 
-void BaseJob::beforeAbandon(QNetworkReply*)
-{ }
+void BaseJob::beforeAbandon(QNetworkReply*) {}
 
 void BaseJob::start(const ConnectionData* connData, bool inBackground)
 {
     d->connection = connData;
     d->retryTimer.setSingleShot(true);
-    connect (&d->retryTimer, &QTimer::timeout,
-             this, [this,inBackground] { sendRequest(inBackground); });
+    connect(&d->retryTimer, &QTimer::timeout, this,
+            [this, inBackground] { sendRequest(inBackground); });
 
     beforeStart(connData);
     if (status().good())
@@ -261,27 +250,22 @@ void BaseJob::sendRequest(bool inBackground)
     if (!d->requestQuery.isEmpty())
         qCDebug(d->logCat) << "  query:" << d->requestQuery.toString();
     d->sendRequest(inBackground);
-    connect( d->reply.data(), &QNetworkReply::finished, this, &BaseJob::gotReply );
-    if (d->reply->isRunning())
-    {
-        connect( d->reply.data(), &QNetworkReply::metaDataChanged,
-                 this, &BaseJob::checkReply);
-        connect( d->reply.data(), &QNetworkReply::uploadProgress,
-                 this, &BaseJob::uploadProgress);
-        connect( d->reply.data(), &QNetworkReply::downloadProgress,
-                 this, &BaseJob::downloadProgress);
+    connect(d->reply.data(), &QNetworkReply::finished, this, &BaseJob::gotReply);
+    if (d->reply->isRunning()) {
+        connect(d->reply.data(), &QNetworkReply::metaDataChanged, this,
+                &BaseJob::checkReply);
+        connect(d->reply.data(), &QNetworkReply::uploadProgress, this,
+                &BaseJob::uploadProgress);
+        connect(d->reply.data(), &QNetworkReply::downloadProgress, this,
+                &BaseJob::downloadProgress);
         d->timer.start(getCurrentTimeout());
         qCDebug(d->logCat) << this << "request has been sent";
         emit started();
-    }
-    else
+    } else
         qCWarning(d->logCat) << this << "request could not start";
 }
 
-void BaseJob::checkReply()
-{
-    setStatus(doCheckReply(d->reply.data()));
-}
+void BaseJob::checkReply() { setStatus(doCheckReply(d->reply.data())); }
 
 void BaseJob::gotReply()
 {
@@ -290,8 +274,8 @@ void BaseJob::gotReply()
         setStatus(parseReply(d->reply.data()));
     else {
         d->rawResponse = d->reply->readAll();
-        const auto jsonBody =
-            d->reply->rawHeader("Content-Type") == "application/json";
+        const auto jsonBody = d->reply->rawHeader("Content-Type")
+                              == "application/json";
         qCDebug(d->logCat).noquote()
             << "Error body (truncated if long):" << d->rawResponse.left(500);
         if (jsonBody)
@@ -316,18 +300,18 @@ bool checkContentType(const QByteArray& type, const QByteArrayList& patterns)
     // ignore possible appendixes of the content type
     const auto ctype = type.split(';').front();
 
-    for (const auto& pattern: patterns)
-    {
+    for (const auto& pattern : patterns) {
         if (pattern.startsWith('*') || ctype == pattern) // Fast lane
             return true;
 
         auto patternParts = pattern.split('/');
         Q_ASSERT_X(patternParts.size() <= 2, __FUNCTION__,
-            "BaseJob: Expected content type should have up to two"
-            " /-separated parts; violating pattern: " + pattern);
+                   "BaseJob: Expected content type should have up to two"
+                   " /-separated parts; violating pattern: "
+                       + pattern);
 
-        if (ctype.split('/').front() == patternParts.front() &&
-                patternParts.back() == "*")
+        if (ctype.split('/').front() == patternParts.front()
+            && patternParts.back() == "*")
             return true; // Exact match already went on fast lane
     }
 
@@ -341,15 +325,15 @@ BaseJob::Status BaseJob::doCheckReply(QNetworkReply* reply) const
     // so check genuine HTTP codes. The below processing is based on
     // https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
     const auto httpCodeHeader =
-            reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
-    if (!httpCodeHeader.isValid())
-    {
+        reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
+    if (!httpCodeHeader.isValid()) {
         qCWarning(d->logCat) << this << "didn't get valid HTTP headers";
         return { NetworkError, reply->errorString() };
     }
 
-    const QString replyState = reply->isRunning() ?
-                QStringLiteral("(tentative)") : QStringLiteral("(final)");
+    const QString replyState = reply->isRunning()
+                                   ? QStringLiteral("(tentative)")
+                                   : QStringLiteral("(final)");
     const auto urlString = '|' + d->reply->url().toDisplayString();
     const auto httpCode = httpCodeHeader.toInt();
     const auto reason =
@@ -359,7 +343,7 @@ BaseJob::Status BaseJob::doCheckReply(QNetworkReply* reply) const
         qCDebug(d->logCat).noquote().nospace() << this << urlString;
         qCDebug(d->logCat).noquote() << "  " << httpCode << reason << replyState;
         if (!checkContentType(reply->rawHeader("Content-Type"),
-                             d->expectedContentTypes))
+                              d->expectedContentTypes))
             return { UnexpectedResponseTypeWarning,
                      "Unexpected content type of the response" };
         return NoError;
@@ -368,29 +352,37 @@ BaseJob::Status BaseJob::doCheckReply(QNetworkReply* reply) const
     qCWarning(d->logCat).noquote().nospace() << this << urlString;
     qCWarning(d->logCat).noquote() << "  " << httpCode << reason << replyState;
     return { [httpCode]() -> StatusCode {
-            if (httpCode / 10 == 41)
-                return httpCode == 410 ? IncorrectRequestError : NotFoundError;
-            switch (httpCode)
-            {
-                case 401: case 403: case 407:
+                if (httpCode / 10 == 41)
+                    return httpCode == 410 ? IncorrectRequestError
+                                           : NotFoundError;
+                switch (httpCode) {
+                case 401:
+                case 403:
+                case 407:
                     return ContentAccessError;
                 case 404:
                     return NotFoundError;
-                case 400: case 405: case 406: case 426: case 428:
+                case 400:
+                case 405:
+                case 406:
+                case 426:
+                case 428:
                 case 505:
                 case 494: // Unofficial nginx "Request header too large"
                 case 497: // Unofficial nginx "HTTP request sent to HTTPS port"
                     return IncorrectRequestError;
                 case 429:
                     return TooManyRequestsError;
-                case 501: case 510:
+                case 501:
+                case 510:
                     return RequestNotImplementedError;
                 case 511:
                     return NetworkAuthRequiredError;
                 default:
                     return NetworkError;
-            }
-        }(), reply->errorString() };
+                }
+            }(),
+             reply->errorString() };
 }
 
 BaseJob::Status BaseJob::parseReply(QNetworkReply* reply)
@@ -398,16 +390,13 @@ BaseJob::Status BaseJob::parseReply(QNetworkReply* reply)
     d->rawResponse = reply->readAll();
     QJsonParseError error { 0, QJsonParseError::MissingObject };
     const auto& json = QJsonDocument::fromJson(d->rawResponse, &error);
-    if( error.error == QJsonParseError::NoError )
+    if (error.error == QJsonParseError::NoError)
         return parseJson(json);
 
     return { IncorrectResponseError, error.errorString() };
 }
 
-BaseJob::Status BaseJob::parseJson(const QJsonDocument&)
-{
-    return Success;
-}
+BaseJob::Status BaseJob::parseJson(const QJsonDocument&) { return Success; }
 
 BaseJob::Status BaseJob::parseError(QNetworkReply* reply,
                                     const QJsonObject& errorJson)
@@ -450,16 +439,14 @@ void BaseJob::stop()
     // This method is used to semi-finalise the job before retrying; so
     // stop the timeout timer but keep the retry timer running.
     d->timer.stop();
-    if (d->reply)
-    {
+    if (d->reply) {
         d->reply->disconnect(this); // Ignore whatever comes from the reply
-        if (d->reply->isRunning())
-        {
-            qCWarning(d->logCat) << this << "stopped without ready network reply";
+        if (d->reply->isRunning()) {
+            qCWarning(d->logCat)
+                << this << "stopped without ready network reply";
             d->reply->abort();
         }
-    }
-    else
+    } else
         qCWarning(d->logCat) << this << "stopped with empty network reply";
 }
 
@@ -467,16 +454,16 @@ void BaseJob::finishJob()
 {
     stop();
     if ((error() == NetworkError || error() == TimeoutError)
-            && d->retriesTaken < d->maxRetries)
-    {
+        && d->retriesTaken < d->maxRetries) {
         // TODO: The whole retrying thing should be put to ConnectionManager
         // otherwise independently retrying jobs make a bit of notification
         // storm towards the UI.
-        const auto retryInterval =
-                error() == TimeoutError ? 0 : getNextRetryInterval();
+        const auto retryInterval = error() == TimeoutError
+                                       ? 0
+                                       : getNextRetryInterval();
         ++d->retriesTaken;
         qCWarning(d->logCat).nospace() << this << ": retry #" << d->retriesTaken
-                   << " in " << retryInterval/1000 << " s";
+                                       << " in " << retryInterval / 1000 << " s";
         d->retryTimer.start(retryInterval);
         emit retryScheduled(d->retriesTaken, retryInterval);
         return;
@@ -514,25 +501,20 @@ BaseJob::duration_t BaseJob::millisToRetry() const
     return d->retryTimer.isActive() ? d->retryTimer.remainingTime() : 0;
 }
 
-int BaseJob::maxRetries() const
-{
-    return d->maxRetries;
-}
+int BaseJob::maxRetries() const { return d->maxRetries; }
 
 void BaseJob::setMaxRetries(int newMaxRetries)
 {
     d->maxRetries = newMaxRetries;
 }
 
-BaseJob::Status BaseJob::status() const
-{
-    return d->status;
-}
+BaseJob::Status BaseJob::status() const { return d->status; }
 
 QByteArray BaseJob::rawData(int bytesAtMost) const
 {
     return bytesAtMost > 0 && d->rawResponse.size() > bytesAtMost
-            ? d->rawResponse.left(bytesAtMost) : d->rawResponse;
+               ? d->rawResponse.left(bytesAtMost)
+               : d->rawResponse;
 }
 
 QString BaseJob::rawDataSample(int bytesAtMost) const
@@ -540,65 +522,56 @@ QString BaseJob::rawDataSample(int bytesAtMost) const
     auto data = rawData(bytesAtMost);
     Q_ASSERT(data.size() <= d->rawResponse.size());
     return data.size() == d->rawResponse.size()
-            ? data : data + tr("...(truncated, %Ln bytes in total)",
-                               "Comes after trimmed raw network response",
-                               d->rawResponse.size());
-
+               ? data
+               : data
+                     + tr("...(truncated, %Ln bytes in total)",
+                          "Comes after trimmed raw network response",
+                          d->rawResponse.size());
 }
 
 QString BaseJob::statusCaption() const
 {
-    switch (d->status.code)
-    {
-        case Success:
-            return tr("Success");
-        case Pending:
-            return tr("Request still pending response");
-        case UnexpectedResponseTypeWarning:
-            return tr("Warning: Unexpected response type");
-        case Abandoned:
-            return tr("Request was abandoned");
-        case NetworkError:
-            return tr("Network problems");
-        case TimeoutError:
-            return tr("Request timed out");
-        case ContentAccessError:
-            return tr("Access error");
-        case NotFoundError:
-            return tr("Not found");
-        case IncorrectRequestError:
-            return tr("Invalid request");
-        case IncorrectResponseError:
-            return tr("Response could not be parsed");
-        case TooManyRequestsError:
-            return tr("Too many requests");
-        case RequestNotImplementedError:
-            return tr("Function not implemented by the server");
-        case NetworkAuthRequiredError:
-            return tr("Network authentication required");
-        case UserConsentRequiredError:
-            return tr("User consent required");
-        case UnsupportedRoomVersionError:
-            return tr("The server does not support the needed room version");
-        default:
-            return tr("Request failed");
+    switch (d->status.code) {
+    case Success:
+        return tr("Success");
+    case Pending:
+        return tr("Request still pending response");
+    case UnexpectedResponseTypeWarning:
+        return tr("Warning: Unexpected response type");
+    case Abandoned:
+        return tr("Request was abandoned");
+    case NetworkError:
+        return tr("Network problems");
+    case TimeoutError:
+        return tr("Request timed out");
+    case ContentAccessError:
+        return tr("Access error");
+    case NotFoundError:
+        return tr("Not found");
+    case IncorrectRequestError:
+        return tr("Invalid request");
+    case IncorrectResponseError:
+        return tr("Response could not be parsed");
+    case TooManyRequestsError:
+        return tr("Too many requests");
+    case RequestNotImplementedError:
+        return tr("Function not implemented by the server");
+    case NetworkAuthRequiredError:
+        return tr("Network authentication required");
+    case UserConsentRequiredError:
+        return tr("User consent required");
+    case UnsupportedRoomVersionError:
+        return tr("The server does not support the needed room version");
+    default:
+        return tr("Request failed");
     }
 }
 
-int BaseJob::error() const
-{
-    return d->status.code;
-}
+int BaseJob::error() const { return d->status.code; }
 
-QString BaseJob::errorString() const
-{
-    return d->status.message;
-}
+QString BaseJob::errorString() const { return d->status.message; }
 
-QUrl BaseJob::errorUrl() const
-{
-    return d->errorUrl;
-}
+QUrl BaseJob::errorUrl() const { return d->errorUrl; }
 
 void BaseJob::setStatus(Status s)
 {
@@ -619,8 +592,8 @@ void BaseJob::setStatus(Status s)
     if (d->status == s)
         return;
 
-    if (!s.message.isEmpty()
-            && d->connection && !d->connection->accessToken().isEmpty())
+    if (!s.message.isEmpty() && d->connection
+        && !d->connection->accessToken().isEmpty())
         s.message.replace(d->connection->accessToken(), "(REDACTED)");
     if (!s.good())
         qCWarning(d->logCat) << this << "status" << s;
@@ -646,11 +619,8 @@ void BaseJob::abandon()
 
 void BaseJob::timeout()
 {
-    setStatus( TimeoutError, "The job has timed out" );
+    setStatus(TimeoutError, "The job has timed out");
     finishJob();
 }
 
-void BaseJob::setLoggingCategory(LoggingCategory lcf)
-{
-    d->logCat = lcf;
-}
+void BaseJob::setLoggingCategory(LoggingCategory lcf) { d->logCat = lcf; }
diff --git a/lib/jobs/basejob.h b/lib/jobs/basejob.h
index d435749a..c85d2d90 100644
--- a/lib/jobs/basejob.h
+++ b/lib/jobs/basejob.h
@@ -13,7 +13,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #pragma once
@@ -21,349 +21,347 @@
 #include "../logging.h"
 #include "requestdata.h"
 
+#include <QtCore/QJsonDocument>
 #include <QtCore/QObject>
 #include <QtCore/QUrlQuery>
-#include <QtCore/QJsonDocument>
 
 class QNetworkReply;
 class QSslError;
 
-namespace QMatrixClient
-{
-    class ConnectionData;
-
-    enum class HttpVerb { Get, Put, Post, Delete };
+namespace QMatrixClient {
+class ConnectionData;
+
+enum class HttpVerb { Get, Put, Post, Delete };
+
+struct JobTimeoutConfig {
+    int jobTimeout;
+    int nextRetryInterval;
+};
+
+class BaseJob : public QObject {
+    Q_OBJECT
+    Q_PROPERTY(QUrl requestUrl READ requestUrl CONSTANT)
+    Q_PROPERTY(int maxRetries READ maxRetries WRITE setMaxRetries)
+public:
+    enum StatusCode {
+        NoError = 0 // To be compatible with Qt conventions
+        ,
+        Success = 0,
+        Pending = 1,
+        WarningLevel = 20,
+        UnexpectedResponseType = 21,
+        UnexpectedResponseTypeWarning = UnexpectedResponseType,
+        Abandoned = 50 //< A tiny period between abandoning and object deletion
+        ,
+        ErrorLevel = 100 //< Errors have codes starting from this
+        ,
+        NetworkError = 100,
+        Timeout,
+        TimeoutError = Timeout,
+        ContentAccessError,
+        NotFoundError,
+        IncorrectRequest,
+        IncorrectRequestError = IncorrectRequest,
+        IncorrectResponse,
+        IncorrectResponseError = IncorrectResponse,
+        JsonParseError //< deprecated; Use IncorrectResponse instead
+        = IncorrectResponse,
+        TooManyRequests,
+        TooManyRequestsError = TooManyRequests,
+        RequestNotImplemented,
+        RequestNotImplementedError = RequestNotImplemented,
+        UnsupportedRoomVersion,
+        UnsupportedRoomVersionError = UnsupportedRoomVersion,
+        NetworkAuthRequired,
+        NetworkAuthRequiredError = NetworkAuthRequired,
+        UserConsentRequired,
+        UserConsentRequiredError = UserConsentRequired,
+        UserDefinedError = 256
+    };
 
-    struct JobTimeoutConfig
-    {
-        int jobTimeout;
-        int nextRetryInterval;
+    /**
+     * A simple wrapper around QUrlQuery that allows its creation from
+     * a list of string pairs
+     */
+    class Query : public QUrlQuery {
+    public:
+        using QUrlQuery::QUrlQuery;
+        Query() = default;
+        Query(const std::initializer_list<QPair<QString, QString>>& l)
+        {
+            setQueryItems(l);
+        }
     };
 
-    class BaseJob: public QObject
-    {
-            Q_OBJECT
-            Q_PROPERTY(QUrl requestUrl READ requestUrl CONSTANT)
-            Q_PROPERTY(int maxRetries READ maxRetries WRITE setMaxRetries)
-        public:
-            enum StatusCode { NoError = 0 // To be compatible with Qt conventions
-                , Success = 0
-                , Pending = 1
-                , WarningLevel = 20
-                , UnexpectedResponseType = 21
-                , UnexpectedResponseTypeWarning = UnexpectedResponseType
-                , Abandoned = 50 //< A very brief period between abandoning and object deletion
-                , ErrorLevel = 100 //< Errors have codes starting from this
-                , NetworkError = 100
-                , Timeout
-                , TimeoutError = Timeout
-                , ContentAccessError
-                , NotFoundError
-                , IncorrectRequest
-                , IncorrectRequestError = IncorrectRequest
-                , IncorrectResponse
-                , IncorrectResponseError = IncorrectResponse
-                , JsonParseError  //< deprecated; Use IncorrectResponse instead
-                  = IncorrectResponse
-                , TooManyRequests
-                , TooManyRequestsError = TooManyRequests
-                , RequestNotImplemented
-                , RequestNotImplementedError = RequestNotImplemented
-                , UnsupportedRoomVersion
-                , UnsupportedRoomVersionError = UnsupportedRoomVersion
-                , NetworkAuthRequired
-                , NetworkAuthRequiredError = NetworkAuthRequired
-                , UserConsentRequired
-                , UserConsentRequiredError = UserConsentRequired
-                , UserDefinedError = 256
-            };
-
-            /**
-             * A simple wrapper around QUrlQuery that allows its creation from
-             * a list of string pairs
-             */
-            class Query : public QUrlQuery
-            {
-                public:
-                    using QUrlQuery::QUrlQuery;
-                    Query() = default;
-                    Query(const std::initializer_list< QPair<QString, QString> >& l)
-                    {
-                        setQueryItems(l);
-                    }
-            };
-
-            using Data = RequestData;
-
-            /**
-             * This structure stores the status of a server call job. The status consists
-             * of a code, that is described (but not delimited) by the respective enum,
-             * and a freeform message.
-             *
-             * To extend the list of error codes, define an (anonymous) enum
-             * along the lines of StatusCode, with additional values
-             * starting at UserDefinedError
-             */
-            class Status
-            {
-                public:
-                    Status(StatusCode c) : code(c) { }
-                    Status(int c, QString m) : code(c), message(std::move(m)) { }
-
-                    bool good() const { return code < ErrorLevel; }
-                    friend QDebug operator<<(QDebug dbg, const Status& s)
-                    {
-                        QDebugStateSaver _s(dbg);
-                        return dbg.noquote().nospace()
-                                << s.code << ": " << s.message;
-                    }
-
-                    bool operator==(const Status& other) const
-                    {
-                        return code == other.code && message == other.message;
-                    }
-                    bool operator!=(const Status& other) const
-                    {
-                        return !operator==(other);
-                    }
-
-                    int code;
-                    QString message;
-            };
-
-            using duration_t = int; // milliseconds
-
-        public:
-            BaseJob(HttpVerb verb, const QString& name, const QString& endpoint,
-                    bool needsToken = true);
-            BaseJob(HttpVerb verb, const QString& name, const QString& endpoint,
-                    const Query& query, Data&& data = {},
-                    bool needsToken = true);
-
-            QUrl requestUrl() const;
-            bool isBackground() const;
-
-            /** Current status of the job */
-            Status status() const;
-            /** Short human-friendly message on the job status */
-            QString statusCaption() const;
-            /** Get raw response body as received from the server
-             * \param bytesAtMost return this number of leftmost bytes, or -1
-             *                    to return the entire response
-             */
-            QByteArray rawData(int bytesAtMost = -1) const;
-            /** Get UI-friendly sample of raw data
-             *
-             * This is almost the same as rawData but appends the "truncated"
-             * suffix if not all data fit in bytesAtMost. This call is
-             * recommended to present a sample of raw data as "details" next to
-             * error messages. Note that the default \p bytesAtMost value is
-             * also tailored to UI cases.
-             */
-            QString rawDataSample(int bytesAtMost = 65535) const;
-
-            /** Error (more generally, status) code
-             * Equivalent to status().code
-             * \sa status
-             */
-            int error() const;
-            /** Error-specific message, as returned by the server */
-            virtual QString errorString() const;
-            /** A URL to help/clarify the error, if provided by the server */
-            QUrl errorUrl() const;
-
-            int maxRetries() const;
-            void setMaxRetries(int newMaxRetries);
-
-            Q_INVOKABLE duration_t getCurrentTimeout() const;
-            Q_INVOKABLE duration_t getNextRetryInterval() const;
-            Q_INVOKABLE duration_t millisToRetry() const;
-
-            friend QDebug operator<<(QDebug dbg, const BaseJob* j)
-            {
-                return dbg << j->objectName();
-            }
-
-        public slots:
-            void start(const ConnectionData* connData,
-                       bool inBackground = false);
-
-            /**
-             * Abandons the result of this job, arrived or unarrived.
-             *
-             * This aborts waiting for a reply from the server (if there was
-             * any pending) and deletes the job object. No result signals
-             * (result, success, failure) are emitted.
-             */
-            void abandon();
-
-        signals:
-            /** The job is about to send a network request */
-            void aboutToStart();
-
-            /** The job has sent a network request */
-            void started();
-
-            /** The job has changed its status */
-            void statusChanged(Status newStatus);
-
-            /**
-             * The previous network request has failed; the next attempt will
-             * be done in the specified time
-             * @param nextAttempt the 1-based number of attempt (will always be more than 1)
-             * @param inMilliseconds the interval after which the next attempt will be taken
-             */
-            void retryScheduled(int nextAttempt, int inMilliseconds);
-
-            /**
-             * Emitted when the job is finished, in any case. It is used to notify
-             * observers that the job is terminated and that progress can be hidden.
-             *
-             * This should not be emitted directly by subclasses;
-             * use finishJob() instead.
-             *
-             * In general, to be notified of a job's completion, client code
-             * should connect to result(), success(), or failure()
-             * rather than finished(). However if you need to track the job's
-             * lifecycle you should connect to this instead of result();
-             * in particular, only this signal will be emitted on abandoning.
-             *
-             * @param job the job that emitted this signal
-             *
-             * @see result, success, failure
-             */
-            void finished(BaseJob* job);
-
-            /**
-             * Emitted when the job is finished (except when abandoned).
-             *
-             * Use error() to know if the job was finished with error.
-             *
-             * @param job the job that emitted this signal
-             *
-             * @see success, failure
-             */
-            void result(BaseJob* job);
-
-            /**
-             * Emitted together with result() in case there's no error.
-             *
-             * @see result, failure
-             */
-            void success(BaseJob*);
-
-            /**
-             * Emitted together with result() if there's an error.
-             * Similar to result(), this won't be emitted in case of abandon().
-             *
-             * @see result, success
-             */
-            void failure(BaseJob*);
-
-            void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
-            void uploadProgress(qint64 bytesSent, qint64 bytesTotal);
-
-        protected:
-            using headers_t = QHash<QByteArray, QByteArray>;
-
-            const QString& apiEndpoint() const;
-            void setApiEndpoint(const QString& apiEndpoint);
-            const headers_t& requestHeaders() const;
-            void setRequestHeader(const headers_t::key_type& headerName,
-                                  const headers_t::mapped_type& headerValue);
-            void setRequestHeaders(const headers_t& headers);
-            const QUrlQuery& query() const;
-            void setRequestQuery(const QUrlQuery& query);
-            const Data& requestData() const;
-            void setRequestData(Data&& data);
-            const QByteArrayList& expectedContentTypes() const;
-            void addExpectedContentType(const QByteArray& contentType);
-            void setExpectedContentTypes(const QByteArrayList& contentTypes);
-
-            /** Construct a URL out of baseUrl, path and query
-             * The function automatically adds '/' between baseUrl's path and
-             * \p path if necessary. The query component of \p baseUrl
-             * is ignored.
-             */
-            static QUrl makeRequestUrl(QUrl baseUrl, const QString& path,
-                                       const QUrlQuery& query = {});
-
-            virtual void beforeStart(const ConnectionData* connData);
-            virtual void afterStart(const ConnectionData* connData,
-                                    QNetworkReply* reply);
-            virtual void beforeAbandon(QNetworkReply*);
-
-            /**
-             * Used by gotReply() to check the received reply for general
-             * issues such as network errors or access denial.
-             * Returning anything except NoError/Success prevents
-             * further parseReply()/parseJson() invocation.
-             *
-             * @param reply the reply received from the server
-             * @return the result of checking the reply
-             *
-             * @see gotReply
-             */
-            virtual Status doCheckReply(QNetworkReply* reply) const;
-
-            /**
-             * Processes the reply. By default, parses the reply into
-             * a QJsonDocument and calls parseJson() if it's a valid JSON.
-             *
-             * @param reply raw contents of a HTTP reply from the server
-             *
-             * @see gotReply, parseJson
-             */
-            virtual Status parseReply(QNetworkReply* reply);
-
-            /**
-             * Processes the JSON document received from the Matrix server.
-             * By default returns successful status without analysing the JSON.
-             *
-             * @param json valid JSON document received from the server
-             *
-             * @see parseReply
-             */
-            virtual Status parseJson(const QJsonDocument&);
-
-            /**
-             * Processes the reply in case of unsuccessful HTTP code.
-             * The body is already loaded from the reply object to errorJson.
-             * @param reply the HTTP reply from the server
-             * @param errorJson the JSON payload describing the error
-             */
-            virtual Status parseError(QNetworkReply* reply,
-                                      const QJsonObject& errorJson);
-
-            void setStatus(Status s);
-            void setStatus(int code, QString message);
-
-            // Q_DECLARE_LOGGING_CATEGORY return different function types
-            // in different versions
-            using LoggingCategory = decltype(JOBS)*;
-            void setLoggingCategory(LoggingCategory lcf);
-
-            // Job objects should only be deleted via QObject::deleteLater
-            ~BaseJob() override;
-
-        protected slots:
-            void timeout();
-
-        private slots:
-            void sendRequest(bool inBackground);
-            void checkReply();
-            void gotReply();
-
-        private:
-            void stop();
-            void finishJob();
-
-            class Private;
-            QScopedPointer<Private> d;
+    using Data = RequestData;
+
+    /**
+     * This structure stores the status of a server call job. The status
+     * consists of a code, that is described (but not delimited) by the
+     * respective enum, and a freeform message.
+     *
+     * To extend the list of error codes, define an (anonymous) enum
+     * along the lines of StatusCode, with additional values
+     * starting at UserDefinedError
+     */
+    class Status {
+    public:
+        Status(StatusCode c) : code(c) {}
+        Status(int c, QString m) : code(c), message(std::move(m)) {}
+
+        bool good() const { return code < ErrorLevel; }
+        friend QDebug operator<<(QDebug dbg, const Status& s)
+        {
+            QDebugStateSaver _s(dbg);
+            return dbg.noquote().nospace() << s.code << ": " << s.message;
+        }
+
+        bool operator==(const Status& other) const
+        {
+            return code == other.code && message == other.message;
+        }
+        bool operator!=(const Status& other) const
+        {
+            return !operator==(other);
+        }
+
+        int code;
+        QString message;
     };
 
-    inline bool isJobRunning(BaseJob* job)
+    using duration_t = int; // milliseconds
+
+public:
+    BaseJob(HttpVerb verb, const QString& name, const QString& endpoint,
+            bool needsToken = true);
+    BaseJob(HttpVerb verb, const QString& name, const QString& endpoint,
+            const Query& query, Data&& data = {}, bool needsToken = true);
+
+    QUrl requestUrl() const;
+    bool isBackground() const;
+
+    /** Current status of the job */
+    Status status() const;
+    /** Short human-friendly message on the job status */
+    QString statusCaption() const;
+    /** Get raw response body as received from the server
+     * \param bytesAtMost return this number of leftmost bytes, or -1
+     *                    to return the entire response
+     */
+    QByteArray rawData(int bytesAtMost = -1) const;
+    /** Get UI-friendly sample of raw data
+     *
+     * This is almost the same as rawData but appends the "truncated"
+     * suffix if not all data fit in bytesAtMost. This call is
+     * recommended to present a sample of raw data as "details" next to
+     * error messages. Note that the default \p bytesAtMost value is
+     * also tailored to UI cases.
+     */
+    QString rawDataSample(int bytesAtMost = 65535) const;
+
+    /** Error (more generally, status) code
+     * Equivalent to status().code
+     * \sa status
+     */
+    int error() const;
+    /** Error-specific message, as returned by the server */
+    virtual QString errorString() const;
+    /** A URL to help/clarify the error, if provided by the server */
+    QUrl errorUrl() const;
+
+    int maxRetries() const;
+    void setMaxRetries(int newMaxRetries);
+
+    Q_INVOKABLE duration_t getCurrentTimeout() const;
+    Q_INVOKABLE duration_t getNextRetryInterval() const;
+    Q_INVOKABLE duration_t millisToRetry() const;
+
+    friend QDebug operator<<(QDebug dbg, const BaseJob* j)
     {
-        return job && job->error() == BaseJob::Pending;
+        return dbg << j->objectName();
     }
-}  // namespace QMatrixClient
+
+public slots:
+    void start(const ConnectionData* connData, bool inBackground = false);
+
+    /**
+     * Abandons the result of this job, arrived or unarrived.
+     *
+     * This aborts waiting for a reply from the server (if there was
+     * any pending) and deletes the job object. No result signals
+     * (result, success, failure) are emitted.
+     */
+    void abandon();
+
+signals:
+    /** The job is about to send a network request */
+    void aboutToStart();
+
+    /** The job has sent a network request */
+    void started();
+
+    /** The job has changed its status */
+    void statusChanged(Status newStatus);
+
+    /**
+     * The previous network request has failed; the next attempt will
+     * be done in the specified time
+     * @param nextAttempt the 1-based number of attempt (will always be more
+     * than 1)
+     * @param inMilliseconds the interval after which the next attempt will be
+     * taken
+     */
+    void retryScheduled(int nextAttempt, int inMilliseconds);
+
+    /**
+     * Emitted when the job is finished, in any case. It is used to notify
+     * observers that the job is terminated and that progress can be hidden.
+     *
+     * This should not be emitted directly by subclasses;
+     * use finishJob() instead.
+     *
+     * In general, to be notified of a job's completion, client code
+     * should connect to result(), success(), or failure()
+     * rather than finished(). However if you need to track the job's
+     * lifecycle you should connect to this instead of result();
+     * in particular, only this signal will be emitted on abandoning.
+     *
+     * @param job the job that emitted this signal
+     *
+     * @see result, success, failure
+     */
+    void finished(BaseJob* job);
+
+    /**
+     * Emitted when the job is finished (except when abandoned).
+     *
+     * Use error() to know if the job was finished with error.
+     *
+     * @param job the job that emitted this signal
+     *
+     * @see success, failure
+     */
+    void result(BaseJob* job);
+
+    /**
+     * Emitted together with result() in case there's no error.
+     *
+     * @see result, failure
+     */
+    void success(BaseJob*);
+
+    /**
+     * Emitted together with result() if there's an error.
+     * Similar to result(), this won't be emitted in case of abandon().
+     *
+     * @see result, success
+     */
+    void failure(BaseJob*);
+
+    void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
+    void uploadProgress(qint64 bytesSent, qint64 bytesTotal);
+
+protected:
+    using headers_t = QHash<QByteArray, QByteArray>;
+
+    const QString& apiEndpoint() const;
+    void setApiEndpoint(const QString& apiEndpoint);
+    const headers_t& requestHeaders() const;
+    void setRequestHeader(const headers_t::key_type& headerName,
+                          const headers_t::mapped_type& headerValue);
+    void setRequestHeaders(const headers_t& headers);
+    const QUrlQuery& query() const;
+    void setRequestQuery(const QUrlQuery& query);
+    const Data& requestData() const;
+    void setRequestData(Data&& data);
+    const QByteArrayList& expectedContentTypes() const;
+    void addExpectedContentType(const QByteArray& contentType);
+    void setExpectedContentTypes(const QByteArrayList& contentTypes);
+
+    /** Construct a URL out of baseUrl, path and query
+     * The function automatically adds '/' between baseUrl's path and
+     * \p path if necessary. The query component of \p baseUrl
+     * is ignored.
+     */
+    static QUrl makeRequestUrl(QUrl baseUrl, const QString& path,
+                               const QUrlQuery& query = {});
+
+    virtual void beforeStart(const ConnectionData* connData);
+    virtual void afterStart(const ConnectionData* connData,
+                            QNetworkReply* reply);
+    virtual void beforeAbandon(QNetworkReply*);
+
+    /**
+     * Used by gotReply() to check the received reply for general
+     * issues such as network errors or access denial.
+     * Returning anything except NoError/Success prevents
+     * further parseReply()/parseJson() invocation.
+     *
+     * @param reply the reply received from the server
+     * @return the result of checking the reply
+     *
+     * @see gotReply
+     */
+    virtual Status doCheckReply(QNetworkReply* reply) const;
+
+    /**
+     * Processes the reply. By default, parses the reply into
+     * a QJsonDocument and calls parseJson() if it's a valid JSON.
+     *
+     * @param reply raw contents of a HTTP reply from the server
+     *
+     * @see gotReply, parseJson
+     */
+    virtual Status parseReply(QNetworkReply* reply);
+
+    /**
+     * Processes the JSON document received from the Matrix server.
+     * By default returns successful status without analysing the JSON.
+     *
+     * @param json valid JSON document received from the server
+     *
+     * @see parseReply
+     */
+    virtual Status parseJson(const QJsonDocument&);
+
+    /**
+     * Processes the reply in case of unsuccessful HTTP code.
+     * The body is already loaded from the reply object to errorJson.
+     * @param reply the HTTP reply from the server
+     * @param errorJson the JSON payload describing the error
+     */
+    virtual Status parseError(QNetworkReply* reply,
+                              const QJsonObject& errorJson);
+
+    void setStatus(Status s);
+    void setStatus(int code, QString message);
+
+    // Q_DECLARE_LOGGING_CATEGORY return different function types
+    // in different versions
+    using LoggingCategory = decltype(JOBS)*;
+    void setLoggingCategory(LoggingCategory lcf);
+
+    // Job objects should only be deleted via QObject::deleteLater
+    ~BaseJob() override;
+
+protected slots:
+    void timeout();
+
+private slots:
+    void sendRequest(bool inBackground);
+    void checkReply();
+    void gotReply();
+
+private:
+    void stop();
+    void finishJob();
+
+    class Private;
+    QScopedPointer<Private> d;
+};
+
+inline bool isJobRunning(BaseJob* job)
+{
+    return job && job->error() == BaseJob::Pending;
+}
+} // namespace QMatrixClient
diff --git a/lib/jobs/downloadfilejob.cpp b/lib/jobs/downloadfilejob.cpp
index 672a7b2d..9722186c 100644
--- a/lib/jobs/downloadfilejob.cpp
+++ b/lib/jobs/downloadfilejob.cpp
@@ -1,29 +1,28 @@
 #include "downloadfilejob.h"
 
-#include <QtNetwork/QNetworkReply>
 #include <QtCore/QFile>
 #include <QtCore/QTemporaryFile>
+#include <QtNetwork/QNetworkReply>
 
 using namespace QMatrixClient;
 
-class DownloadFileJob::Private
-{
-    public:
-        Private() : tempFile(new QTemporaryFile()) { }
+class DownloadFileJob::Private {
+public:
+    Private() : tempFile(new QTemporaryFile()) {}
 
-        explicit Private(const QString& localFilename)
-            : targetFile(new QFile(localFilename))
-            , tempFile(new QFile(targetFile->fileName() + ".qmcdownload"))
-        { }
+    explicit Private(const QString& localFilename)
+        : targetFile(new QFile(localFilename))
+        , tempFile(new QFile(targetFile->fileName() + ".qmcdownload"))
+    {}
 
-        QScopedPointer<QFile> targetFile;
-        QScopedPointer<QFile> tempFile;
+    QScopedPointer<QFile> targetFile;
+    QScopedPointer<QFile> tempFile;
 };
 
 QUrl DownloadFileJob::makeRequestUrl(QUrl baseUrl, const QUrl& mxcUri)
 {
-    return makeRequestUrl(
-                std::move(baseUrl), mxcUri.authority(), mxcUri.path().mid(1));
+    return makeRequestUrl(std::move(baseUrl), mxcUri.authority(),
+                          mxcUri.path().mid(1));
 }
 
 DownloadFileJob::DownloadFileJob(const QString& serverName,
@@ -42,16 +41,14 @@ QString DownloadFileJob::targetFileName() const
 
 void DownloadFileJob::beforeStart(const ConnectionData*)
 {
-    if (d->targetFile && !d->targetFile->isReadable() &&
-            !d->targetFile->open(QIODevice::WriteOnly))
-    {
-        qCWarning(JOBS) << "Couldn't open the file"
-                        << d->targetFile->fileName() << "for writing";
+    if (d->targetFile && !d->targetFile->isReadable()
+        && !d->targetFile->open(QIODevice::WriteOnly)) {
+        qCWarning(JOBS) << "Couldn't open the file" << d->targetFile->fileName()
+                        << "for writing";
         setStatus(FileError, "Could not open the target file for writing");
         return;
     }
-    if (!d->tempFile->isReadable() && !d->tempFile->open(QIODevice::WriteOnly))
-    {
+    if (!d->tempFile->isReadable() && !d->tempFile->open(QIODevice::WriteOnly)) {
         qCWarning(JOBS) << "Couldn't open the temporary file"
                         << d->tempFile->fileName() << "for writing";
         setStatus(FileError, "Could not open the temporary download file");
@@ -62,16 +59,14 @@ void DownloadFileJob::beforeStart(const ConnectionData*)
 
 void DownloadFileJob::afterStart(const ConnectionData*, QNetworkReply* reply)
 {
-    connect(reply, &QNetworkReply::metaDataChanged, this, [this,reply] {
+    connect(reply, &QNetworkReply::metaDataChanged, this, [this, reply] {
         if (!status().good())
             return;
         auto sizeHeader = reply->header(QNetworkRequest::ContentLengthHeader);
-        if (sizeHeader.isValid())
-        {
+        if (sizeHeader.isValid()) {
             auto targetSize = sizeHeader.value<qint64>();
             if (targetSize != -1)
-                if (!d->tempFile->resize(targetSize))
-                {
+                if (!d->tempFile->resize(targetSize)) {
                     qCWarning(JOBS) << "Failed to allocate" << targetSize
                                     << "bytes for" << d->tempFile->fileName();
                     setStatus(FileError,
@@ -79,16 +74,15 @@ void DownloadFileJob::afterStart(const ConnectionData*, QNetworkReply* reply)
                 }
         }
     });
-    connect(reply, &QIODevice::readyRead, this, [this,reply] {
+    connect(reply, &QIODevice::readyRead, this, [this, reply] {
         if (!status().good())
             return;
         auto bytes = reply->read(reply->bytesAvailable());
         if (!bytes.isEmpty())
             d->tempFile->write(bytes);
         else
-            qCWarning(JOBS)
-                    << "Unexpected empty chunk when downloading from"
-                    << reply->url() << "to" << d->tempFile->fileName();
+            qCWarning(JOBS) << "Unexpected empty chunk when downloading from"
+                            << reply->url() << "to" << d->tempFile->fileName();
     });
 }
 
@@ -101,22 +95,18 @@ void DownloadFileJob::beforeAbandon(QNetworkReply*)
 
 BaseJob::Status DownloadFileJob::parseReply(QNetworkReply*)
 {
-    if (d->targetFile)
-    {
+    if (d->targetFile) {
         d->targetFile->close();
-        if (!d->targetFile->remove())
-        {
+        if (!d->targetFile->remove()) {
             qCWarning(JOBS) << "Failed to remove the target file placeholder";
             return { FileError, "Couldn't finalise the download" };
         }
-        if (!d->tempFile->rename(d->targetFile->fileName()))
-        {
+        if (!d->tempFile->rename(d->targetFile->fileName())) {
             qCWarning(JOBS) << "Failed to rename" << d->tempFile->fileName()
                             << "to" << d->targetFile->fileName();
             return { FileError, "Couldn't finalise the download" };
         }
-    }
-    else
+    } else
         d->tempFile->close();
     qCDebug(JOBS) << "Saved a file as" << targetFileName();
     return Success;
diff --git a/lib/jobs/downloadfilejob.h b/lib/jobs/downloadfilejob.h
index ce47ab1c..ebfe5a0d 100644
--- a/lib/jobs/downloadfilejob.h
+++ b/lib/jobs/downloadfilejob.h
@@ -2,29 +2,26 @@
 
 #include "csapi/content-repo.h"
 
-namespace QMatrixClient
-{
-    class DownloadFileJob : public GetContentJob
-    {
-        public:
-            enum { FileError = BaseJob::UserDefinedError + 1 };
+namespace QMatrixClient {
+class DownloadFileJob : public GetContentJob {
+public:
+    enum { FileError = BaseJob::UserDefinedError + 1 };
 
-            using GetContentJob::makeRequestUrl;
-            static QUrl makeRequestUrl(QUrl baseUrl, const QUrl& mxcUri);
+    using GetContentJob::makeRequestUrl;
+    static QUrl makeRequestUrl(QUrl baseUrl, const QUrl& mxcUri);
 
-            DownloadFileJob(const QString& serverName, const QString& mediaId,
-                            const QString& localFilename = {});
+    DownloadFileJob(const QString& serverName, const QString& mediaId,
+                    const QString& localFilename = {});
 
-            QString targetFileName() const;
+    QString targetFileName() const;
 
-        private:
-            class Private;
-            QScopedPointer<Private> d;
+private:
+    class Private;
+    QScopedPointer<Private> d;
 
-            void beforeStart(const ConnectionData*) override;
-            void afterStart(const ConnectionData*,
-                            QNetworkReply* reply) override;
-            void beforeAbandon(QNetworkReply*) override;
-            Status parseReply(QNetworkReply*) override;
-    };
-}
+    void beforeStart(const ConnectionData*) override;
+    void afterStart(const ConnectionData*, QNetworkReply* reply) override;
+    void beforeAbandon(QNetworkReply*) override;
+    Status parseReply(QNetworkReply*) override;
+};
+} // namespace QMatrixClient
diff --git a/lib/jobs/mediathumbnailjob.cpp b/lib/jobs/mediathumbnailjob.cpp
index edb9b156..db2bbc13 100644
--- a/lib/jobs/mediathumbnailjob.cpp
+++ b/lib/jobs/mediathumbnailjob.cpp
@@ -13,41 +13,39 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #include "mediathumbnailjob.h"
 
 using namespace QMatrixClient;
 
-QUrl MediaThumbnailJob::makeRequestUrl(QUrl baseUrl,
-                                       const QUrl& mxcUri, QSize requestedSize)
+QUrl MediaThumbnailJob::makeRequestUrl(QUrl baseUrl, const QUrl& mxcUri,
+                                       QSize requestedSize)
 {
-    return makeRequestUrl(std::move(baseUrl),
-                          mxcUri.authority(), mxcUri.path().mid(1),
-                          requestedSize.width(), requestedSize.height());
+    return makeRequestUrl(std::move(baseUrl), mxcUri.authority(),
+                          mxcUri.path().mid(1), requestedSize.width(),
+                          requestedSize.height());
 }
 
 MediaThumbnailJob::MediaThumbnailJob(const QString& serverName,
                                      const QString& mediaId, QSize requestedSize)
-    : GetContentThumbnailJob(serverName, mediaId,
-                             requestedSize.width(), requestedSize.height())
-{ }
+    : GetContentThumbnailJob(serverName, mediaId, requestedSize.width(),
+                             requestedSize.height())
+{}
 
 MediaThumbnailJob::MediaThumbnailJob(const QUrl& mxcUri, QSize requestedSize)
-    : MediaThumbnailJob(mxcUri.authority(), mxcUri.path().mid(1), // sans leading '/'
+    : MediaThumbnailJob(mxcUri.authority(),
+                        mxcUri.path().mid(1), // sans leading '/'
                         requestedSize)
-{ }
+{}
 
-QImage MediaThumbnailJob::thumbnail() const
-{
-    return _thumbnail;
-}
+QImage MediaThumbnailJob::thumbnail() const { return _thumbnail; }
 
 QImage MediaThumbnailJob::scaledThumbnail(QSize toSize) const
 {
-    return _thumbnail.scaled(toSize,
-                             Qt::KeepAspectRatio, Qt::SmoothTransformation);
+    return _thumbnail.scaled(toSize, Qt::KeepAspectRatio,
+                             Qt::SmoothTransformation);
 }
 
 BaseJob::Status MediaThumbnailJob::parseReply(QNetworkReply* reply)
@@ -56,8 +54,9 @@ BaseJob::Status MediaThumbnailJob::parseReply(QNetworkReply* reply)
     if (!result.good())
         return result;
 
-    if( _thumbnail.loadFromData(data()->readAll()) )
+    if (_thumbnail.loadFromData(data()->readAll()))
         return Success;
 
-    return { IncorrectResponseError, QStringLiteral("Could not read image data") };
+    return { IncorrectResponseError,
+             QStringLiteral("Could not read image data") };
 }
diff --git a/lib/jobs/mediathumbnailjob.h b/lib/jobs/mediathumbnailjob.h
index 7963796e..df0a7f31 100644
--- a/lib/jobs/mediathumbnailjob.h
+++ b/lib/jobs/mediathumbnailjob.h
@@ -13,7 +13,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #pragma once
@@ -22,26 +22,24 @@
 
 #include <QtGui/QPixmap>
 
-namespace QMatrixClient
-{
-    class MediaThumbnailJob: public GetContentThumbnailJob
-    {
-        public:
-            using GetContentThumbnailJob::makeRequestUrl;
-            static QUrl makeRequestUrl(QUrl baseUrl,
-                                       const QUrl& mxcUri, QSize requestedSize);
-
-            MediaThumbnailJob(const QString& serverName, const QString& mediaId,
-                              QSize requestedSize);
-            MediaThumbnailJob(const QUrl& mxcUri, QSize requestedSize);
-
-            QImage thumbnail() const;
-            QImage scaledThumbnail(QSize toSize) const;
-
-        protected:
-            Status parseReply(QNetworkReply* reply) override;
-
-        private:
-            QImage _thumbnail;
-    };
-}  // namespace QMatrixClient
+namespace QMatrixClient {
+class MediaThumbnailJob : public GetContentThumbnailJob {
+public:
+    using GetContentThumbnailJob::makeRequestUrl;
+    static QUrl makeRequestUrl(QUrl baseUrl, const QUrl& mxcUri,
+                               QSize requestedSize);
+
+    MediaThumbnailJob(const QString& serverName, const QString& mediaId,
+                      QSize requestedSize);
+    MediaThumbnailJob(const QUrl& mxcUri, QSize requestedSize);
+
+    QImage thumbnail() const;
+    QImage scaledThumbnail(QSize toSize) const;
+
+protected:
+    Status parseReply(QNetworkReply* reply) override;
+
+private:
+    QImage _thumbnail;
+};
+} // namespace QMatrixClient
diff --git a/lib/jobs/postreadmarkersjob.h b/lib/jobs/postreadmarkersjob.h
index 63a8e1d0..cf482a9a 100644
--- a/lib/jobs/postreadmarkersjob.h
+++ b/lib/jobs/postreadmarkersjob.h
@@ -13,7 +13,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #pragma once
@@ -24,16 +24,15 @@
 
 using namespace QMatrixClient;
 
-class PostReadMarkersJob : public BaseJob
-{
-    public:
-        explicit PostReadMarkersJob(const QString& roomId,
-                                    const QString& readUpToEventId)
-            : BaseJob(HttpVerb::Post, "PostReadMarkersJob",
-                      QStringLiteral("_matrix/client/r0/rooms/%1/read_markers")
-                      .arg(roomId))
-        {
-            setRequestData(QJsonObject {{
-                QStringLiteral("m.fully_read"), readUpToEventId }});
-        }
+class PostReadMarkersJob : public BaseJob {
+public:
+    explicit PostReadMarkersJob(const QString& roomId,
+                                const QString& readUpToEventId)
+        : BaseJob(
+            HttpVerb::Post, "PostReadMarkersJob",
+            QStringLiteral("_matrix/client/r0/rooms/%1/read_markers").arg(roomId))
+    {
+        setRequestData(
+            QJsonObject { { QStringLiteral("m.fully_read"), readUpToEventId } });
+    }
 };
diff --git a/lib/jobs/requestdata.cpp b/lib/jobs/requestdata.cpp
index 5cb62221..6ad7c007 100644
--- a/lib/jobs/requestdata.cpp
+++ b/lib/jobs/requestdata.cpp
@@ -1,10 +1,10 @@
 #include "requestdata.h"
 
+#include <QtCore/QBuffer>
 #include <QtCore/QByteArray>
-#include <QtCore/QJsonObject>
 #include <QtCore/QJsonArray>
 #include <QtCore/QJsonDocument>
-#include <QtCore/QBuffer>
+#include <QtCore/QJsonObject>
 
 using namespace QMatrixClient;
 
@@ -23,16 +23,10 @@ inline auto fromJson(const JsonDataT& jdata)
     return fromData(QJsonDocument(jdata).toJson(QJsonDocument::Compact));
 }
 
-RequestData::RequestData(const QByteArray& a)
-    : _source(fromData(a))
-{ }
+RequestData::RequestData(const QByteArray& a) : _source(fromData(a)) {}
 
-RequestData::RequestData(const QJsonObject& jo)
-    : _source(fromJson(jo))
-{ }
+RequestData::RequestData(const QJsonObject& jo) : _source(fromJson(jo)) {}
 
-RequestData::RequestData(const QJsonArray& ja)
-    : _source(fromJson(ja))
-{ }
+RequestData::RequestData(const QJsonArray& ja) : _source(fromJson(ja)) {}
 
 RequestData::~RequestData() = default;
diff --git a/lib/jobs/requestdata.h b/lib/jobs/requestdata.h
index db011b61..55987a3b 100644
--- a/lib/jobs/requestdata.h
+++ b/lib/jobs/requestdata.h
@@ -13,7 +13,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #pragma once
@@ -26,36 +26,30 @@ class QJsonArray;
 class QJsonDocument;
 class QIODevice;
 
-namespace QMatrixClient
-{
-    /**
-     * A simple wrapper that represents the request body.
-     * Provides a unified interface to dump an unstructured byte stream
-     * as well as JSON (and possibly other structures in the future) to
-     * a QByteArray consumed by QNetworkAccessManager request methods.
-     */
-    class RequestData
-    {
-        public:
-            RequestData() = default;
-            RequestData(const QByteArray& a);
-            RequestData(const QJsonObject& jo);
-            RequestData(const QJsonArray& ja);
-            RequestData(QIODevice* source)
-                : _source(std::unique_ptr<QIODevice>(source))
-            { }
-            RequestData(const RequestData&) = delete;
-            RequestData& operator=(const RequestData&) = delete;
-            RequestData(RequestData&&) = default;
-            RequestData& operator=(RequestData&&) = default;
-            ~RequestData();
+namespace QMatrixClient {
+/**
+ * A simple wrapper that represents the request body.
+ * Provides a unified interface to dump an unstructured byte stream
+ * as well as JSON (and possibly other structures in the future) to
+ * a QByteArray consumed by QNetworkAccessManager request methods.
+ */
+class RequestData {
+public:
+    RequestData() = default;
+    RequestData(const QByteArray& a);
+    RequestData(const QJsonObject& jo);
+    RequestData(const QJsonArray& ja);
+    RequestData(QIODevice* source) : _source(std::unique_ptr<QIODevice>(source))
+    {}
+    RequestData(const RequestData&) = delete;
+    RequestData& operator=(const RequestData&) = delete;
+    RequestData(RequestData&&) = default;
+    RequestData& operator=(RequestData&&) = default;
+    ~RequestData();
 
-            QIODevice* source() const
-            {
-                return _source.get();
-            }
+    QIODevice* source() const { return _source.get(); }
 
-        private:
-            std::unique_ptr<QIODevice> _source;
-    };
+private:
+    std::unique_ptr<QIODevice> _source;
+};
 } // namespace QMatrixClient
diff --git a/lib/jobs/syncjob.cpp b/lib/jobs/syncjob.cpp
index 84385b55..f660e1b6 100644
--- a/lib/jobs/syncjob.cpp
+++ b/lib/jobs/syncjob.cpp
@@ -13,7 +13,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #include "syncjob.h"
@@ -29,25 +29,25 @@ SyncJob::SyncJob(const QString& since, const QString& filter, int timeout,
 {
     setLoggingCategory(SYNCJOB);
     QUrlQuery query;
-    if( !filter.isEmpty() )
+    if (!filter.isEmpty())
         query.addQueryItem(QStringLiteral("filter"), filter);
-    if( !presence.isEmpty() )
+    if (!presence.isEmpty())
         query.addQueryItem(QStringLiteral("set_presence"), presence);
-    if( timeout >= 0 )
+    if (timeout >= 0)
         query.addQueryItem(QStringLiteral("timeout"), QString::number(timeout));
-    if( !since.isEmpty() )
+    if (!since.isEmpty())
         query.addQueryItem(QStringLiteral("since"), since);
     setRequestQuery(query);
 
     setMaxRetries(std::numeric_limits<int>::max());
 }
 
-SyncJob::SyncJob(const QString& since, const Filter& filter,
-                 int timeout, const QString& presence)
+SyncJob::SyncJob(const QString& since, const Filter& filter, int timeout,
+                 const QString& presence)
     : SyncJob(since,
               QJsonDocument(toJson(filter)).toJson(QJsonDocument::Compact),
               timeout, presence)
-{ }
+{}
 
 BaseJob::Status SyncJob::parseJson(const QJsonDocument& data)
 {
@@ -59,4 +59,3 @@ BaseJob::Status SyncJob::parseJson(const QJsonDocument& data)
                                << d.unresolvedRooms().join(',');
     return BaseJob::IncorrectResponseError;
 }
-
diff --git a/lib/jobs/syncjob.h b/lib/jobs/syncjob.h
index 036b25d0..8f925414 100644
--- a/lib/jobs/syncjob.h
+++ b/lib/jobs/syncjob.h
@@ -13,33 +13,29 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
 #pragma once
 
-#include "basejob.h"
-
-#include "../syncdata.h"
 #include "../csapi/definitions/sync_filter.h"
+#include "../syncdata.h"
+#include "basejob.h"
 
-namespace QMatrixClient
-{
-    class SyncJob: public BaseJob
-    {
-        public:
-            explicit SyncJob(const QString& since = {},
-                             const QString& filter = {},
-                             int timeout = -1, const QString& presence = {});
-            explicit SyncJob(const QString& since, const Filter& filter,
-                             int timeout = -1, const QString& presence = {});
+namespace QMatrixClient {
+class SyncJob : public BaseJob {
+public:
+    explicit SyncJob(const QString& since = {}, const QString& filter = {},
+                     int timeout = -1, const QString& presence = {});
+    explicit SyncJob(const QString& since, const Filter& filter,
+                     int timeout = -1, const QString& presence = {});
 
-            SyncData &&takeData() { return std::move(d); }
+    SyncData&& takeData() { return std::move(d); }
 
-        protected:
-            Status parseJson(const QJsonDocument& data) override;
+protected:
+    Status parseJson(const QJsonDocument& data) override;
 
-        private:
-            SyncData d;
-    };
-}  // namespace QMatrixClient
+private:
+    SyncData d;
+};
+} // namespace QMatrixClient