Merge pull request #500 from flowln/net_refactor

Refactor a little the code in `launcher/net/` files

27 files changed, 1397 insertions, 838 deletions

diff --git a/launcher/InstanceImportTask.cpp b/launcher/InstanceImportTask.cpp
index 8f68b95f..4bad7251 100644
--- a/launcher/InstanceImportTask.cpp
+++ b/launcher/InstanceImportTask.cpp
@@ -41,6 +41,7 @@
 #include "FileSystem.h"
 #include "MMCZip.h"
 #include "NullInstance.h"
+#include "icons/IconList.h"
 #include "icons/IconUtils.h"
 #include "settings/INISettingsObject.h"
 
diff --git a/launcher/minecraft/AssetsUtils.cpp b/launcher/minecraft/AssetsUtils.cpp
index 7290aeb4..15062c2b 100644
--- a/launcher/minecraft/AssetsUtils.cpp
+++ b/launcher/minecraft/AssetsUtils.cpp
@@ -1,16 +1,36 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *          http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
  */
 
 #include <QFileInfo>
@@ -297,7 +317,7 @@ NetAction::Ptr AssetObject::getDownloadAction()
             auto rawHash = QByteArray::fromHex(hash.toLatin1());
             objectDL->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, rawHash));
         }
-        objectDL->m_total_progress = size;
+        objectDL->setProgress(objectDL->getProgress(), size);
         return objectDL;
     }
     return nullptr;
diff --git a/launcher/net/ByteArraySink.h b/launcher/net/ByteArraySink.h
index 20e6764c..501318a1 100644
--- a/launcher/net/ByteArraySink.h
+++ b/launcher/net/ByteArraySink.h
@@ -1,62 +1,89 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
+
 #pragma once
 
 #include "Sink.h"
 
 namespace Net {
+
 /*
  * Sink object for downloads that uses an external QByteArray it doesn't own as a target.
+ * FIXME: It is possible that the QByteArray is freed while we're doing some operation on it,
+ * causing a segmentation fault.
  */
-class ByteArraySink : public Sink
-{
-public:
-    ByteArraySink(QByteArray *output)
-        :m_output(output)
-    {
-        // nil
-    };
+class ByteArraySink : public Sink {
+   public:
+    ByteArraySink(QByteArray* output) : m_output(output){};
 
-    virtual ~ByteArraySink()
-    {
-        // nil
-    }
+    virtual ~ByteArraySink() = default;
 
-public:
-    JobStatus init(QNetworkRequest & request) override
+   public:
+    auto init(QNetworkRequest& request) -> Task::State override
     {
         m_output->clear();
-        if(initAllValidators(request))
-            return Job_InProgress;
-        return Job_Failed;
+        if (initAllValidators(request))
+            return Task::State::Running;
+        return Task::State::Failed;
     };
 
-    JobStatus write(QByteArray & data) override
+    auto write(QByteArray& data) -> Task::State override
     {
         m_output->append(data);
-        if(writeAllValidators(data))
-            return Job_InProgress;
-        return Job_Failed;
+        if (writeAllValidators(data))
+            return Task::State::Running;
+        return Task::State::Failed;
     }
 
-    JobStatus abort() override
+    auto abort() -> Task::State override
     {
         m_output->clear();
         failAllValidators();
-        return Job_Failed;
+        return Task::State::Failed;
     }
 
-    JobStatus finalize(QNetworkReply &reply) override
+    auto finalize(QNetworkReply& reply) -> Task::State override
     {
-        if(finalizeAllValidators(reply))
-            return Job_Finished;
-        return Job_Failed;
+        if (finalizeAllValidators(reply))
+            return Task::State::Succeeded;
+        return Task::State::Failed;
     }
 
-    bool hasLocalData() override
-    {
-        return false;
-    }
+    auto hasLocalData() -> bool override { return false; }
 
-private:
-    QByteArray * m_output;
+   private:
+    QByteArray* m_output;
 };
-}
+}  // namespace Net
diff --git a/launcher/net/ChecksumValidator.h b/launcher/net/ChecksumValidator.h
index 0d6b19c2..a2ca2c7a 100644
--- a/launcher/net/ChecksumValidator.h
+++ b/launcher/net/ChecksumValidator.h
@@ -1,55 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
+
 #pragma once
 
 #include "Validator.h"
+
 #include <QCryptographicHash>
-#include <memory>
 #include <QFile>
 
 namespace Net {
-class ChecksumValidator: public Validator
-{
-public: /* con/des */
+class ChecksumValidator : public Validator {
+   public:
     ChecksumValidator(QCryptographicHash::Algorithm algorithm, QByteArray expected = QByteArray())
-        :m_checksum(algorithm), m_expected(expected)
-    {
-    };
-    virtual ~ChecksumValidator() {};
+        : m_checksum(algorithm), m_expected(expected){};
+    virtual ~ChecksumValidator() = default;
 
-public: /* methods */
-    bool init(QNetworkRequest &) override
+   public:
+    auto init(QNetworkRequest&) -> bool override
     {
         m_checksum.reset();
         return true;
     }
-    bool write(QByteArray & data) override
+
+    auto write(QByteArray& data) -> bool override
     {
         m_checksum.addData(data);
         return true;
     }
-    bool abort() override
-    {
-        return true;
-    }
-    bool validate(QNetworkReply &) override
+
+    auto abort() -> bool override { return true; }
+
+    auto validate(QNetworkReply&) -> bool override
     {
-        if(m_expected.size() && m_expected != hash())
-        {
+        if (m_expected.size() && m_expected != hash()) {
             qWarning() << "Checksum mismatch, download is bad.";
             return false;
         }
         return true;
     }
-    QByteArray hash()
-    {
-        return m_checksum.result();
-    }
-    void setExpected(QByteArray expected)
-    {
-        m_expected = expected;
-    }
 
-private: /* data */
+    auto hash() -> QByteArray { return m_checksum.result(); }
+
+    void setExpected(QByteArray expected) { m_expected = expected; }
+
+   private:
     QCryptographicHash m_checksum;
     QByteArray m_expected;
 };
-}
\ No newline at end of file
+}  // namespace Net
diff --git a/launcher/net/Download.cpp b/launcher/net/Download.cpp
index 7a401609..966d4126 100644
--- a/launcher/net/Download.cpp
+++ b/launcher/net/Download.cpp
@@ -1,22 +1,41 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
  */
 
 #include "Download.h"
 
 #include <QDateTime>
-#include <QDebug>
 #include <QFileInfo>
 
 #include "ByteArraySink.h"
@@ -31,33 +50,32 @@ namespace Net {
 
 Download::Download() : NetAction()
 {
-    m_status = Job_NotStarted;
+    m_state = State::Inactive;
 }
 
-Download::Ptr Download::makeCached(QUrl url, MetaEntryPtr entry, Options options)
+auto Download::makeCached(QUrl url, MetaEntryPtr entry, Options options) -> Download::Ptr
 {
-    Download* dl = new Download();
+    auto* dl = new Download();
     dl->m_url = url;
     dl->m_options = options;
     auto md5Node = new ChecksumValidator(QCryptographicHash::Md5);
     auto cachedNode = new MetaCacheSink(entry, md5Node);
     dl->m_sink.reset(cachedNode);
-    dl->m_target_path = entry->getFullPath();
     return dl;
 }
 
-Download::Ptr Download::makeByteArray(QUrl url, QByteArray* output, Options options)
+auto Download::makeByteArray(QUrl url, QByteArray* output, Options options) -> Download::Ptr
 {
-    Download* dl = new Download();
+    auto* dl = new Download();
     dl->m_url = url;
     dl->m_options = options;
     dl->m_sink.reset(new ByteArraySink(output));
     return dl;
 }
 
-Download::Ptr Download::makeFile(QUrl url, QString path, Options options)
+auto Download::makeFile(QUrl url, QString path, Options options) -> Download::Ptr
 {
-    Download* dl = new Download();
+    auto* dl = new Download();
     dl->m_url = url;
     dl->m_options = options;
     dl->m_sink.reset(new FileSink(path));
@@ -69,29 +87,32 @@ void Download::addValidator(Validator* v)
     m_sink->addValidator(v);
 }
 
-void Download::startImpl()
+void Download::executeTask()
 {
-    if (m_status == Job_Aborted) {
+    setStatus(tr("Downloading %1").arg(m_url.toString()));
+
+    if (getState() == Task::State::AbortedByUser) {
         qWarning() << "Attempt to start an aborted Download:" << m_url.toString();
-        emit aborted(m_index_within_job);
+        emitAborted();
         return;
     }
+
     QNetworkRequest request(m_url);
-    m_status = m_sink->init(request);
-    switch (m_status) {
-        case Job_Finished:
-            emit succeeded(m_index_within_job);
+    m_state = m_sink->init(request);
+    switch (m_state) {
+        case State::Succeeded:
+            emit succeeded();
             qDebug() << "Download cache hit " << m_url.toString();
             return;
-        case Job_InProgress:
+        case State::Running:
             qDebug() << "Downloading " << m_url.toString();
             break;
-        case Job_Failed_Proceed:  // this is meaningless in this context. We do need a sink.
-        case Job_NotStarted:
-        case Job_Failed:
-            emit failed(m_index_within_job);
+        case State::Inactive:
+        case State::Failed:
+            emitFailed();
             return;
-        case Job_Aborted:
+        case State::AbortedByUser:
+            emitAborted();
             return;
     }
 
@@ -103,8 +124,8 @@ void Download::startImpl()
     QNetworkReply* rep = m_network->get(request);
 
     m_reply.reset(rep);
-    connect(rep, SIGNAL(downloadProgress(qint64, qint64)), SLOT(downloadProgress(qint64, qint64)));
-    connect(rep, SIGNAL(finished()), SLOT(downloadFinished()));
+    connect(rep, &QNetworkReply::downloadProgress, this, &Download::downloadProgress);
+    connect(rep, &QNetworkReply::finished, this, &Download::downloadFinished);
     connect(rep, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(downloadError(QNetworkReply::NetworkError)));
     connect(rep, &QNetworkReply::sslErrors, this, &Download::sslErrors);
     connect(rep, &QNetworkReply::readyRead, this, &Download::downloadReadyRead);
@@ -112,26 +133,24 @@ void Download::startImpl()
 
 void Download::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
 {
-    m_total_progress = bytesTotal;
-    m_progress = bytesReceived;
-    emit netActionProgress(m_index_within_job, bytesReceived, bytesTotal);
+    setProgress(bytesReceived, bytesTotal);
 }
 
 void Download::downloadError(QNetworkReply::NetworkError error)
 {
     if (error == QNetworkReply::OperationCanceledError) {
         qCritical() << "Aborted " << m_url.toString();
-        m_status = Job_Aborted;
+        m_state = State::AbortedByUser;
     } else {
         if (m_options & Option::AcceptLocalFiles) {
             if (m_sink->hasLocalData()) {
-                m_status = Job_Failed_Proceed;
+                m_state = State::Succeeded;
                 return;
             }
         }
         // error happened during download.
         qCritical() << "Failed " << m_url.toString() << " with reason " << error;
-        m_status = Job_Failed;
+        m_state = State::Failed;
     }
 }
 
@@ -146,7 +165,7 @@ void Download::sslErrors(const QList<QSslError>& errors)
     }
 }
 
-bool Download::handleRedirect()
+auto Download::handleRedirect() -> bool
 {
     QUrl redirect = m_reply->header(QNetworkRequest::LocationHeader).toUrl();
     if (!redirect.isValid()) {
@@ -195,7 +214,8 @@ bool Download::handleRedirect()
 
     m_url = QUrl(redirect.toString());
     qDebug() << "Following redirect to " << m_url.toString();
-    start(m_network);
+    startAction(m_network);
+
     return true;
 }
 
@@ -208,74 +228,71 @@ void Download::downloadFinished()
     }
 
     // if the download failed before this point ...
-    if (m_status == Job_Failed_Proceed) {
+    if (m_state == State::Succeeded)  // pretend to succeed so we continue processing :)
+    {
         qDebug() << "Download failed but we are allowed to proceed:" << m_url.toString();
         m_sink->abort();
         m_reply.reset();
-        emit succeeded(m_index_within_job);
+        emit succeeded();
         return;
-    } else if (m_status == Job_Failed) {
+    } else if (m_state == State::Failed) {
         qDebug() << "Download failed in previous step:" << m_url.toString();
         m_sink->abort();
         m_reply.reset();
-        emit failed(m_index_within_job);
+        emit failed("");
         return;
-    } else if (m_status == Job_Aborted) {
+    } else if (m_state == State::AbortedByUser) {
         qDebug() << "Download aborted in previous step:" << m_url.toString();
         m_sink->abort();
         m_reply.reset();
-        emit aborted(m_index_within_job);
+        emit aborted();
         return;
     }
 
     // make sure we got all the remaining data, if any
     auto data = m_reply->readAll();
     if (data.size()) {
-        qDebug() << "Writing extra" << data.size() << "bytes to" << m_target_path;
-        m_status = m_sink->write(data);
+        qDebug() << "Writing extra" << data.size() << "bytes";
+        m_state = m_sink->write(data);
     }
 
     // otherwise, finalize the whole graph
-    m_status = m_sink->finalize(*m_reply.get());
-    if (m_status != Job_Finished) {
+    m_state = m_sink->finalize(*m_reply.get());
+    if (m_state != State::Succeeded) {
         qDebug() << "Download failed to finalize:" << m_url.toString();
         m_sink->abort();
         m_reply.reset();
-        emit failed(m_index_within_job);
+        emit failed("");
         return;
     }
+
     m_reply.reset();
     qDebug() << "Download succeeded:" << m_url.toString();
-    emit succeeded(m_index_within_job);
+    emit succeeded();
 }
 
 void Download::downloadReadyRead()
 {
-    if (m_status == Job_InProgress) {
+    if (m_state == State::Running) {
         auto data = m_reply->readAll();
-        m_status = m_sink->write(data);
-        if (m_status == Job_Failed) {
-            qCritical() << "Failed to process response chunk for " << m_target_path;
+        m_state = m_sink->write(data);
+        if (m_state == State::Failed) {
+            qCritical() << "Failed to process response chunk";
         }
         // qDebug() << "Download" << m_url.toString() << "gained" << data.size() << "bytes";
     } else {
-        qCritical() << "Cannot write to " << m_target_path << ", illegal status" << m_status;
+        qCritical() << "Cannot write download data! illegal status " << m_status;
     }
 }
 
 }  // namespace Net
 
-bool Net::Download::abort()
+auto Net::Download::abort() -> bool
 {
     if (m_reply) {
         m_reply->abort();
     } else {
-        m_status = Job_Aborted;
+        m_state = State::AbortedByUser;
     }
     return true;
 }
-
-bool Net::Download::canAbort()
-{
-    return true;
-}
diff --git a/launcher/net/Download.h b/launcher/net/Download.h
index 0f9bfe7f..20932944 100644
--- a/launcher/net/Download.h
+++ b/launcher/net/Download.h
@@ -1,77 +1,88 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
  */
 
 #pragma once
 
-#include "NetAction.h"
 #include "HttpMetaCache.h"
-#include "Validator.h"
+#include "NetAction.h"
 #include "Sink.h"
+#include "Validator.h"
 
 #include "QObjectPtr.h"
 
 namespace Net {
-class Download : public NetAction
-{
+class Download : public NetAction {
     Q_OBJECT
 
-public: /* types */
-    typedef shared_qobject_ptr<class Download> Ptr;
-    enum class Option
-    {
-        NoOptions = 0,
-        AcceptLocalFiles = 1
-    };
+   public:
+    using Ptr = shared_qobject_ptr<class Download>;
+    enum class Option { NoOptions = 0, AcceptLocalFiles = 1 };
     Q_DECLARE_FLAGS(Options, Option)
 
-protected: /* con/des */
+   protected:
     explicit Download();
-public:
-    virtual ~Download(){};
-    static Download::Ptr makeCached(QUrl url, MetaEntryPtr entry, Options options = Option::NoOptions);
-    static Download::Ptr makeByteArray(QUrl url, QByteArray *output, Options options = Option::NoOptions);
-    static Download::Ptr makeFile(QUrl url, QString path, Options options = Option::NoOptions);
 
-public: /* methods */
-    QString getTargetFilepath()
-    {
-        return m_target_path;
-    }
-    void addValidator(Validator * v);
-    bool abort() override;
-    bool canAbort() override;
+   public:
+    ~Download() override = default;
+
+    static auto makeCached(QUrl url, MetaEntryPtr entry, Options options = Option::NoOptions) -> Download::Ptr;
+    static auto makeByteArray(QUrl url, QByteArray* output, Options options = Option::NoOptions) -> Download::Ptr;
+    static auto makeFile(QUrl url, QString path, Options options = Option::NoOptions) -> Download::Ptr;
+
+   public:
+    void addValidator(Validator* v);
+    auto abort() -> bool override;
+    auto canAbort() const -> bool override { return true; };
 
-private: /* methods */
-    bool handleRedirect();
+   private:
+    auto handleRedirect() -> bool;
 
-protected slots:
+   protected slots:
     void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) override;
     void downloadError(QNetworkReply::NetworkError error) override;
-    void sslErrors(const QList<QSslError> & errors);
+    void sslErrors(const QList<QSslError>& errors);
     void downloadFinished() override;
     void downloadReadyRead() override;
 
-public slots:
-    void startImpl() override;
+   public slots:
+    void executeTask() override;
 
-private: /* data */
-    // FIXME: remove this, it has no business being here.
-    QString m_target_path;
+   private:
     std::unique_ptr<Sink> m_sink;
     Options m_options;
 };
-}
+}  // namespace Net
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Net::Download::Options)
diff --git a/launcher/net/FileSink.cpp b/launcher/net/FileSink.cpp
index 7e9b8929..ba0caf6c 100644
--- a/launcher/net/FileSink.cpp
+++ b/launcher/net/FileSink.cpp
@@ -1,109 +1,131 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.