Fix log files unlocking when closing chat

src/common/Channel.cpp

@@ -3,9 +3,6 @@
 #include "Application.hpp"
 #include "messages/Message.hpp"
 #include "messages/MessageBuilder.hpp"
-#include "providers/irc/IrcChannel2.hpp"
-#include "providers/irc/IrcServer.hpp"
-#include "providers/twitch/IrcMessageHandler.hpp"
 #include "singletons/Emotes.hpp"
 #include "singletons/Logging.hpp"
 #include "singletons/Settings.hpp"
@@ -32,6 +29,13 @@ Channel::Channel(const QString &name, Type type)
     , messages_(getSettings()->scrollbackSplitLimit)
     , type_(type)
 {
+    this->logFolderName_ = [this]() -> QString {
+        if (this->isTwitchChannel())
+        {
+            return "twitch";
+        }
+        return "other";
+    }();
 }
 
 Channel::~Channel()
@@ -74,6 +78,11 @@ bool Channel::hasMessages() const
     return !this->messages_.empty();
 }
 
+QString &Channel::logFolderName()
+{
+    return this->logFolderName_;
+}
+
 LimitedQueueSnapshot<MessagePtr> Channel::getMessageSnapshot()
 {
     return this->messages_.getSnapshot();
@@ -82,26 +91,18 @@ LimitedQueueSnapshot<MessagePtr> Channel::getMessageSnapshot()
 void Channel::addMessage(MessagePtr message,
                          std::optional<MessageFlags> overridingFlags)
 {
-    auto app = getApp();
     MessagePtr deleted;
 
     if (!overridingFlags || !overridingFlags->has(MessageFlag::DoNotLog))
     {
-        QString channelPlatform("other");
-        if (this->type_ == Type::Irc)
+        if (!this->isLogInitialized_)
         {
-            auto *irc = dynamic_cast<IrcChannel *>(this);
-            if (irc != nullptr)
-            {
-                channelPlatform = QString("irc-%1").arg(
-                    irc->server()->userFriendlyIdentifier());
-            }
+            getApp()->logging->addChannel(this->name_, this->logFolderName());
+            this->isLogInitialized_ = true;
         }
-        else if (this->isTwitchChannel())
-        {
-            channelPlatform = "twitch";
-        }
-        app->logging->addMessage(this->name_, message, channelPlatform);
+
+        getApp()->logging->addMessage(this->name_, message,
+                                      this->logFolderName());
     }
 
     if (this->messages_.pushBack(message, deleted))

src/common/Channel.hpp

@@ -104,6 +104,7 @@ class Channel : public std::enable_shared_from_this<Channel>
     virtual bool shouldIgnoreHighlights() const;
     virtual bool canReconnect() const;
     virtual void reconnect();
+    virtual QString &logFolderName();
 
     static std::shared_ptr<Channel> getEmpty();
 
@@ -118,6 +119,8 @@ class Channel : public std::enable_shared_from_this<Channel>
     const QString name_;
     LimitedQueue<MessagePtr> messages_;
     Type type_;
+    bool isLogInitialized_{false};
+    QString logFolderName_;
     QTimer clearCompletionModelTimer_;
 };
 

src/providers/irc/IrcChannel2.cpp

@@ -1,12 +1,14 @@
 #include "IrcChannel2.hpp"
 
+#include "Application.hpp"
 #include "debug/AssertInGuiThread.hpp"
 #include "messages/Message.hpp"
 #include "messages/MessageBuilder.hpp"
 #include "messages/MessageElement.hpp"
 #include "providers/irc/IrcCommands.hpp"
 #include "providers/irc/IrcMessageBuilder.hpp"
 #include "providers/irc/IrcServer.hpp"
+#include "singletons/Logging.hpp"
 #include "util/Helpers.hpp"
 
 namespace chatterino {
@@ -15,9 +17,15 @@ IrcChannel::IrcChannel(const QString &name, IrcServer *server)
     : Channel(name, Channel::Type::Irc)
     , ChannelChatters(*static_cast<Channel *>(this))
     , server_(server)
+    , logFolderName_(QString("irc-%1").arg(server->userFriendlyIdentifier()))
 {
 }
 
+IrcChannel::~IrcChannel()
+{
+    getApp()->logging->removeChannel(this->getName(), this->logFolderName());
+}
+
 void IrcChannel::sendMessage(const QString &message)
 {
     assertInGuiThread();
@@ -97,6 +105,11 @@ bool IrcChannel::canReconnect() const
     return true;
 }
 
+QString &IrcChannel::logFolderName()
+{
+    return this->logFolderName_;
+}
+
 void IrcChannel::reconnect()
 {
     if (this->server())

src/providers/irc/IrcChannel2.hpp

@@ -12,6 +12,7 @@ class IrcChannel final : public Channel, public ChannelChatters
 {
 public:
     explicit IrcChannel(const QString &name, IrcServer *server);
+    ~IrcChannel();
 
     void sendMessage(const QString &message) override;
 
@@ -20,12 +21,14 @@ class IrcChannel final : public Channel, public ChannelChatters
 
     // Channel methods
     bool canReconnect() const override;
+    QString &logFolderName() override;
     void reconnect() override;
 
 private:
     void setServer(IrcServer *server);
 
     IrcServer *server_;
+    QString logFolderName_;
 
     friend class Irc;
 };

src/providers/twitch/TwitchChannel.cpp

@@ -32,6 +32,7 @@
 #include "providers/twitch/TwitchIrcServer.hpp"
 #include "providers/twitch/TwitchMessageBuilder.hpp"
 #include "singletons/Emotes.hpp"
+#include "singletons/Logging.hpp"
 #include "singletons/Settings.hpp"
 #include "singletons/Toasts.hpp"
 #include "singletons/WindowManager.hpp"
@@ -237,6 +238,7 @@ TwitchChannel::~TwitchChannel()
         getApp()->twitch->seventvEventAPI->unsubscribeTwitchChannel(
             this->roomId());
     }
+    getApp()->logging->removeChannel(this->getName(), this->logFolderName());
 }
 
 void TwitchChannel::initialize()
@@ -1251,8 +1253,8 @@ void TwitchChannel::addReplyThread(const std::shared_ptr<MessageThread> &thread)
     this->threads_[thread->rootId()] = thread;
 }
 
-const std::unordered_map<QString, std::weak_ptr<MessageThread>>
-    &TwitchChannel::threads() const
+const std::unordered_map<QString, std::weak_ptr<MessageThread>> &
+    TwitchChannel::threads() const
 {
     return this->threads_;
 }

src/singletons/Logging.cpp

@@ -4,9 +4,6 @@
 #include "singletons/Paths.hpp"
 #include "singletons/Settings.hpp"
 
-#include <QDir>
-#include <QStandardPaths>
-
 #include <memory>
 #include <utility>
 
@@ -49,27 +46,36 @@ void Logging::addMessage(const QString &channelName, MessagePtr message,
         }
     }
 
-    auto platIt = this->loggingChannels_.find(platformName);
-    if (platIt == this->loggingChannels_.end())
+    this->loggingChannels_.at(platformName)
+        .at(channelName)
+        ->addMessage(message);
+}
+
+void Logging::addChannel(const QString &channelName,
+                         const QString &platformName)
+{
+    if (!this->loggingChannels_.contains(platformName))
     {
-        auto channel = new LoggingChannel(channelName, platformName);
-        channel->addMessage(message);
-        auto map = std::map<QString, std::unique_ptr<LoggingChannel>>();
-        this->loggingChannels_[platformName] = std::move(map);
-        auto &ref = this->loggingChannels_.at(platformName);
-        ref.emplace(channelName, std::move(channel));
-        return;
+        this->loggingChannels_.emplace(
+            platformName,
+            std::unordered_map<ChannelName, std::unique_ptr<LoggingChannel>>());
     }
-    auto chanIt = platIt->second.find(channelName);
-    if (chanIt == platIt->second.end())
+
+    if (!this->loggingChannels_.at(platformName).contains(channelName))
     {
         auto channel = new LoggingChannel(channelName, platformName);
-        channel->addMessage(message);
-        platIt->second.emplace(channelName, std::move(channel));
+        this->loggingChannels_.at(platformName)
+            .emplace(channelName,
+                     std::unique_ptr<LoggingChannel>(std::move(channel)));
     }
-    else
+}
+
+void Logging::removeChannel(const QString &channelName,
+                            const QString &platformName)
+{
+    if (this->loggingChannels_.contains(platformName))
     {
-        chanIt->second->addMessage(message);
+        this->loggingChannels_.at(platformName).erase(channelName);
     }
 }
 

src/singletons/Logging.hpp

@@ -6,8 +6,8 @@
 
 #include <QString>
 
-#include <map>
 #include <memory>
+#include <unordered_map>
 #include <unordered_set>
 
 namespace chatterino {
@@ -28,12 +28,15 @@ class Logging : public Singleton
 
     void addMessage(const QString &channelName, MessagePtr message,
                     const QString &platformName);
+    void addChannel(const QString &channelName, const QString &platformName);
+    void removeChannel(const QString &channelName, const QString &platformName);
 
 private:
     using PlatformName = QString;
     using ChannelName = QString;
-    std::map<PlatformName,
-             std::map<ChannelName, std::unique_ptr<LoggingChannel>>>
+    std::unordered_map<
+        PlatformName,
+        std::unordered_map<ChannelName, std::unique_ptr<LoggingChannel>>>
         loggingChannels_;
 
     // Keeps the value of the `loggedChannels` settings