Using signals/slots for update checker.

Author: dchapyshev

source/client/ui/client_window.cc

@@ -133,8 +133,11 @@ ClientWindow::ClientWindow(QWidget* parent)
         update_checker_->setUpdateServer(settings.updateServer());
         update_checker_->setPackageName("client");
 
+        connect(update_checker_.get(), &common::UpdateChecker::sig_checkedFinished,
+                this, &ClientWindow::onUpdateCheckedFinished);
+
         LOG(LS_INFO) << "Start update checker";
-        update_checker_->start(Application::uiTaskRunner(), this);
+        update_checker_->start();
     }
 #else
     ui.action_check_for_updates->setVisible(false);

source/client/ui/client_window.h

@@ -30,9 +30,7 @@
 
 namespace client {
 
-class ClientWindow final
-    : public QMainWindow,
-      public common::UpdateChecker::Delegate
+class ClientWindow final : public QMainWindow
 {
     Q_OBJECT
 
@@ -44,10 +42,8 @@ class ClientWindow final
     // QMainWindow implementation.
     void closeEvent(QCloseEvent* event) final;
 
-    // common::UpdateChecker::Delegate implementation.
-    void onUpdateCheckedFinished(const QByteArray& result) final;
-
 private slots:
+    void onUpdateCheckedFinished(const QByteArray& result);
     void onLanguageChanged(QAction* action);
     void onSettings();
     void onHelp();

source/common/http_file_downloader.cc

@@ -24,78 +24,9 @@
 
 namespace common {
 
-class HttpFileDownloader::Runner : public std::enable_shared_from_this<Runner>
-{
-public:
-    Runner(std::shared_ptr<base::TaskRunner> owner_task_runner, Delegate* delegate)
-        : owner_task_runner_(std::move(owner_task_runner)),
-          delegate_(delegate)
-    {
-        DCHECK(owner_task_runner_);
-        DCHECK(delegate_);
-    }
-
-    ~Runner()
-    {
-        dettach();
-    }
-
-    void dettach()
-    {
-        delegate_ = nullptr;
-    }
-
-    void onError(int error_code)
-    {
-        if (!owner_task_runner_->belongsToCurrentThread())
-        {
-            owner_task_runner_->postTask(std::bind(&Runner::onError, shared_from_this(), error_code));
-            return;
-        }
-
-        if (delegate_)
-        {
-            delegate_->onFileDownloaderError(error_code);
-            delegate_ = nullptr;
-        }
-    }
-
-    void onCompleted()
-    {
-        if (!owner_task_runner_->belongsToCurrentThread())
-        {
-            owner_task_runner_->postTask(std::bind(&Runner::onCompleted, shared_from_this()));
-            return;
-        }
-
-        if (delegate_)
-        {
-            delegate_->onFileDownloaderCompleted();
-            delegate_ = nullptr;
-        }
-    }
-
-    void onProgress(int percentage)
-    {
-        if (!owner_task_runner_->belongsToCurrentThread())
-        {
-            owner_task_runner_->postTask(std::bind(&Runner::onProgress, shared_from_this(), percentage));
-            return;
-        }
-
-        if (delegate_)
-            delegate_->onFileDownloaderProgress(percentage);
-    }
-
-private:
-    std::shared_ptr<base::TaskRunner> owner_task_runner_;
-    Delegate* delegate_ = nullptr;
-
-    DISALLOW_COPY_AND_ASSIGN(Runner);
-};
-
 //--------------------------------------------------------------------------------------------------
-HttpFileDownloader::HttpFileDownloader()
+HttpFileDownloader::HttpFileDownloader(QObject* parent)
+    : QThread(parent)
 {
     LOG(LS_INFO) << "Ctor";
 }
@@ -104,24 +35,20 @@ HttpFileDownloader::HttpFileDownloader()
 HttpFileDownloader::~HttpFileDownloader()
 {
     LOG(LS_INFO) << "Dtor";
-
-    if (runner_)
-    {
-        runner_->dettach();
-        runner_.reset();
-    }
-    thread_.stop();
+    interrupted_.store(true, std::memory_order_relaxed);
+    wait();
 }
 
 //--------------------------------------------------------------------------------------------------
-void HttpFileDownloader::start(const QString& url,
-                               std::shared_ptr<base::TaskRunner> owner_task_runner,
-                               Delegate* delegate)
+void HttpFileDownloader::setUrl(const QString& url)
 {
-    LOG(LS_INFO) << "Starting http file downloader";
     url_ = url;
-    runner_ = std::make_shared<Runner>(std::move(owner_task_runner), delegate);
-    thread_.start(std::bind(&HttpFileDownloader::run, this));
+}
+
+//--------------------------------------------------------------------------------------------------
+const QByteArray& HttpFileDownloader::data() const
+{
+    return data_;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -153,7 +80,8 @@ static int debugFunc(
 //--------------------------------------------------------------------------------------------------
 void HttpFileDownloader::run()
 {
-    LOG(LS_INFO) << "run BEGIN";
+    LOG(LS_INFO) << "Starting http file downloader:" << url_;
+    interrupted_.store(false, std::memory_order_relaxed);
 
     base::ScopedCURL curl;
 
@@ -201,7 +129,7 @@ void HttpFileDownloader::run()
             break;
         }
 
-        if (thread_.isStopping())
+        if (interrupted_.load(std::memory_order_relaxed))
         {
             LOG(LS_INFO) << "Downloading canceled";
             break;
@@ -211,18 +139,16 @@ void HttpFileDownloader::run()
 
     curl_multi_remove_handle(multi_curl.get(), curl.get());
 
-    if (!thread_.isStopping())
+    if (!interrupted_.load(std::memory_order_relaxed))
     {
         if (error_code != CURLM_OK)
         {
-            if (runner_)
-                runner_->onError(error_code);
+            emit sig_downloadError(error_code);
         }
         else
         {
             LOG(LS_INFO) << "Download is finished: " << data_.size() << " bytes";
-            if (runner_)
-                runner_->onCompleted();
+            emit sig_downloadCompleted();
         }
     }
 
@@ -238,7 +164,7 @@ size_t HttpFileDownloader::writeDataCallback(
 
     if (self)
     {
-        if (self->thread_.isStopping())
+        if (self->interrupted_.load(std::memory_order_relaxed))
         {
             LOG(LS_INFO) << "Interrupted by user";
             return 0;
@@ -256,14 +182,13 @@ size_t HttpFileDownloader::writeDataCallback(
 int HttpFileDownloader::progressCallback(
     HttpFileDownloader* self, double dltotal, double dlnow, double /* ultotal */, double /* ulnow */)
 {
-    if (self && !self->thread_.isStopping())
+    if (self && !self->interrupted_.load(std::memory_order_relaxed))
     {
         int percentage = 0;
         if (dltotal > 0)
             percentage = static_cast<int>((dlnow * 100) / dltotal);
 
-        if (self->runner_)
-            self->runner_->onProgress(percentage);
+        emit self->sig_downloadProgress(percentage);
     }
 
     return 0;

source/common/http_file_downloader.h

@@ -20,47 +20,38 @@
 #define COMMON_HTTP_FILE_DOWNLOADER_H
 
 #include "base/macros_magic.h"
-#include "base/task_runner.h"
-#include "base/threading/simple_thread.h"
 
 #include <QByteArray>
-#include <QString>
+#include <QThread>
 
 namespace common {
 
-class HttpFileDownloader
+class HttpFileDownloader final : public QThread
 {
+    Q_OBJECT
+
 public:
-    HttpFileDownloader();
+    explicit HttpFileDownloader(QObject* parent = nullptr);
     ~HttpFileDownloader();
 
-    class Delegate
-    {
-    public:
-        virtual ~Delegate() = default;
+    void setUrl(const QString& url);
+    const QByteArray& data() const;
 
-        virtual void onFileDownloaderError(int error_code) = 0;
-        virtual void onFileDownloaderCompleted() = 0;
-        virtual void onFileDownloaderProgress(int percentage) = 0;
-    };
+signals:
+    void sig_downloadError(int error_code);
+    void sig_downloadCompleted();
+    void sig_downloadProgress(int percentage);
 
-    void start(const QString& url,
-               std::shared_ptr<base::TaskRunner> owner_task_runner,
-               Delegate* delegate);
-    const QByteArray& data() const { return data_; }
+protected:
+    // QThread implementation.
+    void run() final;
 
 private:
-    void run();
-
     static size_t writeDataCallback(void* ptr, size_t size, size_t nmemb, HttpFileDownloader* self);
     static int progressCallback(
         HttpFileDownloader* self, double dltotal, double dlnow, double ultotal, double ulnow);
 
-    base::SimpleThread thread_;
-
-    class Runner;
-    std::shared_ptr<Runner> runner_;
-
+    std::atomic_bool interrupted_;
     QString url_;
     QByteArray data_;
 

source/common/ui/download_dialog.cc

@@ -19,7 +19,6 @@
 #include "common/ui/download_dialog.h"
 
 #include "base/logging.h"
-#include "qt_base/application.h"
 
 #include <QAbstractButton>
 #include <QFile>
@@ -48,7 +47,15 @@ DownloadDialog::DownloadDialog(const QString& url, QFile& file, QWidget* parent)
         close();
     });
 
-    downloader_->start(url, qt_base::Application::uiTaskRunner(), this);
+    connect(downloader_.get(), &HttpFileDownloader::sig_downloadError,
+            this, &DownloadDialog::onFileDownloaderError);
+    connect(downloader_.get(), &HttpFileDownloader::sig_downloadCompleted,
+            this, &DownloadDialog::onFileDownloaderCompleted);
+    connect(downloader_.get(), &HttpFileDownloader::sig_downloadProgress,
+            this, &DownloadDialog::onFileDownloaderProgress);
+
+    downloader_->setUrl(url);
+    downloader_->start();
 }
 
 //--------------------------------------------------------------------------------------------------

source/common/ui/download_dialog.h

@@ -29,21 +29,18 @@
 
 namespace common {
 
-class DownloadDialog final
-    : public QDialog,
-      public HttpFileDownloader::Delegate
+class DownloadDialog final : public QDialog
 {
     Q_OBJECT
 
 public:
     DownloadDialog(const QString& url, QFile& file, QWidget* parent = nullptr);
     ~DownloadDialog() final;
 
-protected:
-    // HttpFileDownloader::Delegate implementation.
-    void onFileDownloaderError(int error_code) final;
-    void onFileDownloaderCompleted() final;
-    void onFileDownloaderProgress(int percentage) final;
+private slots:
+    void onFileDownloaderError(int error_code);
+    void onFileDownloaderCompleted();
+    void onFileDownloaderProgress(int percentage);
 
 private:
     Ui::DownloadDialog ui;