Networkmanager (#134)

* rename ImageLoader* to Network*

* static NetworkManager

* NetworkManager queue arbitrary requests

* modify urlfetch to use NetworkManager

* urlfetchjson in terms of NetworkManager

* fetchurljson fetchurltimeout fetchurljsontimeout

special fetch url functions with various connects and functions to be
called

* operate on fetched data in the correct thread

* operate on fetched resources in correct thread

* networkmanager urlfetch functions

* expose urlfetch functions of networkmanager through util and
util::twitch

* add caller to util functions

* cleanup

* formatting

* urlPut function for NetworkManager and util::twitch

* cleanup worker (no more leak)

* use urlfetch for LazyLoadedImage::loadImage

* Rename NetworkManager methods (#1)

* Rename NetworkManager methods

Remove unused NetworkManager methods
Remove unused NetworkManager includes

Reorder includes in lazyloadedimage.cpp and urlfetch.hpp

* try to simplify code, might break everything

* fixed some more stuff?

src/messages/imageloadermanager.cpp

@@ -1,92 +0,0 @@
-#include "messages/imageloadermanager.hpp"
-#include "emotemanager.hpp"
-#include "messages/lazyloadedimage.hpp"
-#include "windowmanager.hpp"
-
-#include <QApplication>
-#include <QBuffer>
-#include <QImageReader>
-#include <QNetworkAccessManager>
-#include <QNetworkReply>
-#include <QNetworkRequest>
-
-namespace chatterino {
-namespace messages {
-
-ImageLoaderManager::ImageLoaderManager()
-{
-    this->NaM.moveToThread(&this->workerThread);
-    this->workerThread.start();
-}
-
-ImageLoaderManager::~ImageLoaderManager()
-{
-    this->workerThread.quit();
-    this->workerThread.wait();
-}
-
-void ImageLoaderWorker::handleRequest(LazyLoadedImage *lli, QNetworkAccessManager *nam)
-{
-    QNetworkRequest request(QUrl(lli->getUrl()));
-    QNetworkReply *reply = nam->get(request);
-
-    QObject::connect(reply, &QNetworkReply::finished,
-                     [lli, reply, this]() { this->handleLoad(lli, reply); });
-}
-
-void ImageLoaderManager::queue(chatterino::messages::LazyLoadedImage *lli)
-{
-    ImageLoaderRequester requester;
-    ImageLoaderWorker *worker = new ImageLoaderWorker;
-
-    worker->moveToThread(&this->workerThread);
-
-    QObject::connect(&requester, &ImageLoaderRequester::request, worker,
-                     &ImageLoaderWorker::handleRequest);
-    QObject::connect(worker, &ImageLoaderWorker::done, lli,
-                     [lli]() { lli->windowManager.layoutVisibleChatWidgets(); });
-
-    emit requester.request(lli, &this->NaM);
-}
-
-void ImageLoaderWorker::handleLoad(chatterino::messages::LazyLoadedImage *lli, QNetworkReply *reply)
-{
-    QByteArray array = reply->readAll();
-    QBuffer buffer(&array);
-    buffer.open(QIODevice::ReadOnly);
-
-    QImage image;
-    QImageReader reader(&buffer);
-
-    bool first = true;
-
-    for (int index = 0; index < reader.imageCount(); ++index) {
-        if (reader.read(&image)) {
-            auto pixmap = new QPixmap(QPixmap::fromImage(image));
-
-            if (first) {
-                first = false;
-                lli->currentPixmap = pixmap;
-            }
-
-            LazyLoadedImage::FrameData data;
-            data.duration = std::max(20, reader.nextImageDelay());
-            data.image = pixmap;
-
-            lli->allFrames.push_back(data);
-        }
-    }
-
-    if (lli->allFrames.size() > 1) {
-        lli->animated = true;
-    }
-
-    lli->emoteManager.incGeneration();
-
-    reply->deleteLater();
-    emit this->done();
-    delete this;
-}
-
-}  // namespace messages
-}  // namespace chatterino

src/messages/imageloadermanager.hpp

@@ -1,46 +0,0 @@
-#pragma once
-
-#include <QNetworkAccessManager>
-#include <QThread>
-
-namespace chatterino {
-namespace messages {
-
-class LazyLoadedImage;
-
-class ImageLoaderWorker : public QObject
-{
-    Q_OBJECT
-
-public slots:
-    void handleRequest(chatterino::messages::LazyLoadedImage *lli, QNetworkAccessManager *nam);
-    void handleLoad(LazyLoadedImage *lli, QNetworkReply *reply);
-
-signals:
-    void done();
-};
-
-class ImageLoaderRequester : public QObject
-{
-    Q_OBJECT
-
-signals:
-    void request(chatterino::messages::LazyLoadedImage *lli, QNetworkAccessManager *nam);
-};
-
-class ImageLoaderManager : public QObject
-{
-    Q_OBJECT
-
-    QThread workerThread;
-    QNetworkAccessManager NaM;
-
-public:
-    ImageLoaderManager();
-    ~ImageLoaderManager();
-
-    void queue(chatterino::messages::LazyLoadedImage *lli);
-};
-
-}  // namespace messages
-}  // namespace chatterino

src/messages/lazyloadedimage.cpp

@@ -2,7 +2,7 @@
 #include "asyncexec.hpp"
 #include "emotemanager.hpp"
 #include "ircmanager.hpp"
-#include "messages/imageloadermanager.hpp"
+#include "util/networkmanager.hpp"
 #include "util/urlfetch.hpp"
 #include "windowmanager.hpp"
 
@@ -12,9 +12,9 @@
 #include <QNetworkReply>
 #include <QNetworkRequest>
 #include <QTimer>
-#include <thread>
 
 #include <functional>
+#include <thread>
 
 namespace chatterino {
 namespace messages {
@@ -52,8 +52,43 @@ LazyLoadedImage::LazyLoadedImage(EmoteManager &_emoteManager, WindowManager &_wi
 
 void LazyLoadedImage::loadImage()
 {
-    static ImageLoaderManager imageLoader;
-    imageLoader.queue(this);
+    util::NetworkRequest req(this->getUrl());
+    req.setCaller(this);
+    req.get([lli = this](QNetworkReply * reply) {
+        QByteArray array = reply->readAll();
+        QBuffer buffer(&array);
+        buffer.open(QIODevice::ReadOnly);
+
+        QImage image;
+        QImageReader reader(&buffer);
+
+        bool first = true;
+
+        for (int index = 0; index < reader.imageCount(); ++index) {
+            if (reader.read(&image)) {
+                auto pixmap = new QPixmap(QPixmap::fromImage(image));
+
+                if (first) {
+                    first = false;
+                    lli->currentPixmap = pixmap;
+                }
+
+                chatterino::messages::LazyLoadedImage::FrameData data;
+                data.duration = std::max(20, reader.nextImageDelay());
+                data.image = pixmap;
+
+                lli->allFrames.push_back(data);
+            }
+        }
+
+        if (lli->allFrames.size() > 1) {
+            lli->animated = true;
+        }
+
+        lli->emoteManager.incGeneration();
+
+        lli->windowManager.layoutVisibleChatWidgets();
+    });
 
     this->emoteManager.getGifUpdateSignal().connect([=]() {
         this->gifUpdateTimout();

src/messages/lazyloadedimage.hpp

@@ -64,9 +64,6 @@ private:
 
     void loadImage();
     void gifUpdateTimout();
-
-    friend class ImageLoaderWorker;
-    friend class ImageLoaderManager;
 };
 
 }  // namespace messages