Reformat code

src/app/qtlocalpeer/qtlocalpeer.cpp

@@ -90,49 +90,49 @@ namespace QtLP_Private
 #endif
 }
 
-const char* QtLocalPeer::ack = "ack";
+const char ACK[] = "ack";
 
 QtLocalPeer::QtLocalPeer(const QString &path, QObject *parent)
     : QObject(parent)
-    , socketName(path + QLatin1String("/ipc-socket"))
-    , server(new QLocalServer(this))
+    , m_socketName(path + QLatin1String("/ipc-socket"))
+    , m_server(new QLocalServer(this))
 {
-    server->setSocketOptions(QLocalServer::UserAccessOption);
+    m_server->setSocketOptions(QLocalServer::UserAccessOption);
 
-    lockFile.setFileName(path + QLatin1String("/lockfile"));
-    lockFile.open(QIODevice::ReadWrite);
+    m_lockFile.setFileName(path + QLatin1String("/lockfile"));
+    m_lockFile.open(QIODevice::ReadWrite);
 }
 
 QtLocalPeer::~QtLocalPeer()
 {
     if (!isClient())
     {
-        lockFile.unlock();
-        lockFile.remove();
+        m_lockFile.unlock();
+        m_lockFile.remove();
     }
 }
 
 bool QtLocalPeer::isClient()
 {
-    if (lockFile.isLocked())
+    if (m_lockFile.isLocked())
         return false;
 
-    if (!lockFile.lock(QtLP_Private::QtLockedFile::WriteLock, false))
+    if (!m_lockFile.lock(QtLP_Private::QtLockedFile::WriteLock, false))
         return true;
 
-    bool res = server->listen(socketName);
+    bool res = m_server->listen(m_socketName);
 #if defined(Q_OS_UNIX)
     // ### Workaround
-    if (!res && server->serverError() == QAbstractSocket::AddressInUseError)
+    if (!res && m_server->serverError() == QAbstractSocket::AddressInUseError)
     {
-        QFile::remove(socketName);
-        res = server->listen(socketName);
+        QFile::remove(m_socketName);
+        res = m_server->listen(m_socketName);
     }
 #endif
     if (!res)
-        qWarning("QtSingleCoreApplication: listen on local socket failed, %s", qPrintable(server->errorString()));
+        qWarning("QtSingleCoreApplication: listen on local socket failed, %s", qUtf8Printable(m_server->errorString()));
 
-    connect(server, &QLocalServer::newConnection, this, &QtLocalPeer::receiveConnection);
+    connect(m_server, &QLocalServer::newConnection, this, &QtLocalPeer::receiveConnection);
     return false;
 }
 
@@ -146,7 +146,7 @@ bool QtLocalPeer::sendMessage(const QString &message, const int timeout)
     for(int i = 0; i < 2; i++)
     {
         // Try twice, in case the other instance is just starting up
-        socket.connectToServer(socketName);
+        socket.connectToServer(m_socketName);
         connOk = socket.waitForConnected(timeout/2);
         if (connOk || i)
             break;
@@ -169,14 +169,14 @@ bool QtLocalPeer::sendMessage(const QString &message, const int timeout)
     {
         res &= socket.waitForReadyRead(timeout);   // wait for ack
         if (res)
-            res &= (socket.read(qstrlen(ack)) == ack);
+            res &= (socket.read(qstrlen(ACK)) == ACK);
     }
     return res;
 }
 
 void QtLocalPeer::receiveConnection()
 {
-    QLocalSocket* socket = server->nextPendingConnection();
+    QLocalSocket *socket = m_server->nextPendingConnection();
     if (!socket)
         return;
 
@@ -220,7 +220,7 @@ void QtLocalPeer::receiveConnection()
         return;
     }
     QString message(QString::fromUtf8(uMsg));
-    socket->write(ack, qstrlen(ack));
+    socket->write(ACK, qstrlen(ACK));
     socket->waitForBytesWritten(1000);
     socket->waitForDisconnected(1000); // make sure client reads ack
     delete socket;

src/app/qtlocalpeer/qtlocalpeer.h

@@ -89,15 +89,11 @@ public:
 signals:
     void messageReceived(const QString &message);
 
-protected slots:
+private slots:
     void receiveConnection();
 
-protected:
-    QString id;
-    QString socketName;
-    QLocalServer *server = nullptr;
-    QtLP_Private::QtLockedFile lockFile;
-
 private:
-    static const char* ack;
+    QString m_socketName;
+    QLocalServer *m_server = nullptr;
+    QtLP_Private::QtLockedFile m_lockFile;
 };

src/app/qtlocalpeer/qtlockedfile.cpp

@@ -108,11 +108,7 @@
 
     \sa QFile::QFile()
 */
-QtLockedFile::QtLockedFile()
-    : QFile()
-{
-    m_lock_mode = NoLock;
-}
+QtLockedFile::QtLockedFile() = default;
 
 /*!
     Constructs an unlocked QtLockedFile object with file \a name. This
@@ -124,7 +120,6 @@ QtLockedFile::QtLockedFile()
 QtLockedFile::QtLockedFile(const QString &name)
     : QFile(name)
 {
-    m_lock_mode = NoLock;
 }
 
 /*!
@@ -142,7 +137,8 @@ QtLockedFile::QtLockedFile(const QString &name)
 */
 bool QtLockedFile::open(const OpenMode mode)
 {
-    if (mode & QIODevice::Truncate) {
+    if (mode & QIODevice::Truncate)
+    {
         qWarning("QtLockedFile::open(): Truncate mode not allowed.");
         return false;
     }
@@ -157,7 +153,7 @@ bool QtLockedFile::open(const OpenMode mode)
 */
 bool QtLockedFile::isLocked() const
 {
-    return m_lock_mode != NoLock;
+    return m_lockMode != NoLock;
 }
 
 /*!
@@ -168,7 +164,7 @@ bool QtLockedFile::isLocked() const
 */
 QtLockedFile::LockMode QtLockedFile::lockMode() const
 {
-    return m_lock_mode;
+    return m_lockMode;
 }
 
 /*!

src/app/qtlocalpeer/qtlockedfile.h

@@ -101,14 +101,14 @@ namespace QtLP_Private
     private:
 #ifdef Q_OS_WIN
         Qt::HANDLE getMutexHandle(int idx, bool doCreate);
-        bool waitMutex(Qt::HANDLE mutex, bool doBlock);
+        bool waitMutex(Qt::HANDLE mutex, bool doBlock) const;
 
-        Qt::HANDLE wmutex = nullptr;
-        Qt::HANDLE rmutex = nullptr;
-        QVector<Qt::HANDLE> rmutexes;
-        QString mutexname;
+        Qt::HANDLE m_writeMutex = nullptr;
+        Qt::HANDLE m_readMutex = nullptr;
+        QVector<Qt::HANDLE> m_readMutexes;
+        QString m_mutexName;
 #endif
 
-        LockMode m_lock_mode;
+        LockMode m_lockMode = NoLock;
     };
 }

src/app/qtlocalpeer/qtlockedfile_unix.cpp

@@ -73,9 +73,10 @@
 #include <string.h>
 #include <unistd.h>
 
-bool QtLockedFile::lock(LockMode mode, bool block)
+bool QtLockedFile::lock(const LockMode mode, const bool block)
 {
-    if (!isOpen()) {
+    if (!isOpen())
+    {
         qWarning("QtLockedFile::lock(): file is not opened");
         return false;
     }
@@ -83,10 +84,10 @@ bool QtLockedFile::lock(LockMode mode, bool block)
     if (mode == NoLock)
         return unlock();
 
-    if (mode == m_lock_mode)
+    if (mode == m_lockMode)
         return true;
 
-    if (m_lock_mode != NoLock)
+    if (m_lockMode != NoLock)
         unlock();
 
     struct flock fl;
@@ -97,19 +98,21 @@ bool QtLockedFile::lock(LockMode mode, bool block)
     int cmd = block ? F_SETLKW : F_SETLK;
     int ret = fcntl(handle(), cmd, &fl);
 
-    if (ret == -1) {
+    if (ret == -1)
+    {
         if (errno != EINTR && errno != EAGAIN)
             qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno));
         return false;
     }
 
-    m_lock_mode = mode;
+    m_lockMode = mode;
     return true;
 }
 
 bool QtLockedFile::unlock()
 {
-    if (!isOpen()) {
+    if (!isOpen())
+    {
         qWarning("QtLockedFile::unlock(): file is not opened");
         return false;
     }
@@ -124,12 +127,13 @@ bool QtLockedFile::unlock()
     fl.l_type = F_UNLCK;
     int ret = fcntl(handle(), F_SETLKW, &fl);
 
-    if (ret == -1) {
+    if (ret == -1)
+    {
         qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno));
         return false;
     }
 
-    m_lock_mode = NoLock;
+    m_lockMode = NoLock;
     return true;
 }
 

src/app/qtlocalpeer/qtlockedfile_win.cpp

@@ -70,64 +70,73 @@
 
 #include <QFileInfo>
 
-#define MUTEX_PREFIX "QtLockedFile mutex "
+#include "base/global.h"
+
 // Maximum number of concurrent read locks. Must not be greater than MAXIMUM_WAIT_OBJECTS
-#define MAX_READERS MAXIMUM_WAIT_OBJECTS
+const int MAX_READERS = MAXIMUM_WAIT_OBJECTS;
 
-#define QT_WA(unicode, ansi) unicode
-
-Qt::HANDLE QtLockedFile::getMutexHandle(int idx, bool doCreate)
+Qt::HANDLE QtLockedFile::getMutexHandle(const int idx, const bool doCreate)
 {
-    if (mutexname.isEmpty()) {
+    if (m_mutexName.isEmpty())
+    {
         QFileInfo fi(*this);
-        mutexname = QString::fromLatin1(MUTEX_PREFIX)
-                    + fi.absoluteFilePath().toLower();
+        m_mutexName = QString::fromLatin1("QtLockedFile mutex ") + fi.absoluteFilePath().toLower();
     }
-    QString mname(mutexname);
+
+    QString mname = m_mutexName;
     if (idx >= 0)
         mname += QString::number(idx);
 
-    Qt::HANDLE mutex;
-    if (doCreate) {
-        QT_WA( { mutex = CreateMutexW(NULL, FALSE, reinterpret_cast<const TCHAR *>(mname.utf16())); },
-               { mutex = CreateMutexA(NULL, FALSE, mname.toLocal8Bit().constData()); } );
-        if (!mutex) {
+    if (doCreate)
+    {
+        const Qt::HANDLE mutex = ::CreateMutexW(NULL, FALSE, reinterpret_cast<const TCHAR *>(mname.utf16()));
+        if (!mutex)
+        {
             qErrnoWarning("QtLockedFile::lock(): CreateMutex failed");
-            return 0;
+            return nullptr;
         }
+
+        return mutex;
     }
-    else {
-        QT_WA( { mutex = OpenMutexW(SYNCHRONIZE | MUTEX_MODIFY_STATE, FALSE, reinterpret_cast<const TCHAR *>(mname.utf16())); },
-               { mutex = OpenMutexA(SYNCHRONIZE | MUTEX_MODIFY_STATE, FALSE, mname.toLocal8Bit().constData()); } );
-        if (!mutex) {
+    else
+    {
+        const Qt::HANDLE mutex = ::OpenMutexW((SYNCHRONIZE | MUTEX_MODIFY_STATE), FALSE, reinterpret_cast<const TCHAR *>(mname.utf16()));
+        if (!mutex)
+        {
             if (GetLastError() != ERROR_FILE_NOT_FOUND)
                 qErrnoWarning("QtLockedFile::lock(): OpenMutex failed");
-            return 0;
+            return nullptr;
         }
+
+        return mutex;
     }
-    return mutex;
+
+    return nullptr;
 }
 
-bool QtLockedFile::waitMutex(Qt::HANDLE mutex, bool doBlock)
+bool QtLockedFile::waitMutex(const Qt::HANDLE mutex, const bool doBlock) const
 {
     Q_ASSERT(mutex);
-    DWORD res = WaitForSingleObject(mutex, doBlock ? INFINITE : 0);
-    switch (res) {
+
+    const DWORD res = ::WaitForSingleObject(mutex, (doBlock ? INFINITE : 0));
+    switch (res)
+    {
     case WAIT_OBJECT_0:
     case WAIT_ABANDONED:
         return true;
-        break;
     case WAIT_TIMEOUT:
-        break;
+        return false;
     default:
         qErrnoWarning("QtLockedFile::lock(): WaitForSingleObject failed");
+        break;
     }
     return false;
 }
 
-bool QtLockedFile::lock(LockMode mode, bool block)
+bool QtLockedFile::lock(const LockMode mode, const bool block)
 {
-    if (!isOpen()) {
+    if (!isOpen())
+    {
         qWarning("QtLockedFile::lock(): file is not opened");
         return false;
     }
@@ -135,72 +144,85 @@ bool QtLockedFile::lock(LockMode mode, bool block)
     if (mode == NoLock)
         return unlock();
 
-    if (mode == m_lock_mode)
+    if (mode == m_lockMode)
         return true;
 
-    if (m_lock_mode != NoLock)
+    if (m_lockMode != NoLock)
         unlock();
 
-    if (!wmutex && !(wmutex = getMutexHandle(-1, true)))
+    if (!m_writeMutex && !(m_writeMutex = getMutexHandle(-1, true)))
         return false;
 
-    if (!waitMutex(wmutex, block))
+    if (!waitMutex(m_writeMutex, block))
         return false;
 
-    if (mode == ReadLock) {
+    if (mode == ReadLock)
+    {
         int idx = 0;
-        for (; idx < MAX_READERS; idx++) {
-            rmutex = getMutexHandle(idx, false);
-            if (!rmutex || waitMutex(rmutex, false))
+        for (; idx < MAX_READERS; ++idx)
+        {
+            m_readMutex = getMutexHandle(idx, false);
+            if (!m_readMutex || waitMutex(m_readMutex, false))
                 break;
-            CloseHandle(rmutex);
+            ::CloseHandle(m_readMutex);
         }
+
         bool ok = true;
-        if (idx >= MAX_READERS) {
+        if (idx >= MAX_READERS)
+        {
             qWarning("QtLockedFile::lock(): too many readers");
-            rmutex = 0;
+            m_readMutex = nullptr;
             ok = false;
         }
-        else if (!rmutex) {
-            rmutex = getMutexHandle(idx, true);
-            if (!rmutex || !waitMutex(rmutex, false))
+        else if (!m_readMutex)
+        {
+            m_readMutex = getMutexHandle(idx, true);
+            if (!m_readMutex || !waitMutex(m_readMutex, false))
                 ok = false;
         }
-        if (!ok && rmutex) {
-            CloseHandle(rmutex);
-            rmutex = 0;
+
+        if (!ok && m_readMutex)
+        {
+            ::CloseHandle(m_readMutex);
+            m_readMutex = nullptr;
         }
-        ReleaseMutex(wmutex);
+
+        ::ReleaseMutex(m_writeMutex);
         if (!ok)
             return false;
     }
-    else {
-        Q_ASSERT(rmutexes.isEmpty());
-        for (int i = 0; i < MAX_READERS; i++) {
-            Qt::HANDLE mutex = getMutexHandle(i, false);
+    else
+    {
+        Q_ASSERT(m_readMutexes.isEmpty());
+        for (int i = 0; i < MAX_READERS; ++i)
+        {
+            const Qt::HANDLE mutex = getMutexHandle(i, false);
             if (mutex)
-                rmutexes.append(mutex);
+                m_readMutexes.append(mutex);
         }
-        if (rmutexes.size()) {
-            DWORD res = WaitForMultipleObjects(rmutexes.size(), rmutexes.constData(),
-                                               TRUE, block ? INFINITE : 0);
-            if (res != WAIT_OBJECT_0 && res != WAIT_ABANDONED) {
+        if (m_readMutexes.size())
+        {
+            const DWORD res = ::WaitForMultipleObjects(m_readMutexes.size(), m_readMutexes.constData(),
+                TRUE, (block ? INFINITE : 0));
+            if ((res != WAIT_OBJECT_0) && (res != WAIT_ABANDONED))
+            {
                 if (res != WAIT_TIMEOUT)
                     qErrnoWarning("QtLockedFile::lock(): WaitForMultipleObjects failed");
-                m_lock_mode = WriteLock;  // trick unlock() to clean up - semiyucky
+                m_lockMode = WriteLock;  // trick unlock() to clean up - semiyucky
                 unlock();
                 return false;
             }
         }
     }
 
-    m_lock_mode = mode;
+    m_lockMode = mode;
     return true;
 }
 
 bool QtLockedFile::unlock()
 {
-    if (!isOpen()) {
+    if (!isOpen())
+    {
         qWarning("QtLockedFile::unlock(): file is not opened");
         return false;
     }
@@ -208,21 +230,24 @@ bool QtLockedFile::unlock()
     if (!isLocked())
         return true;
 
-    if (m_lock_mode == ReadLock) {
-        ReleaseMutex(rmutex);
-        CloseHandle(rmutex);
-        rmutex = 0;
+    if (m_lockMode == ReadLock)
+    {
+        ::ReleaseMutex(m_readMutex);
+        ::CloseHandle(m_readMutex);
+        m_readMutex = nullptr;
     }
-    else {
-        foreach(Qt::HANDLE mutex, rmutexes) {
-            ReleaseMutex(mutex);
-            CloseHandle(mutex);
+    else
+    {
+        for (const Qt::HANDLE &mutex : asConst(m_readMutexes))
+        {
+            ::ReleaseMutex(mutex);
+            ::CloseHandle(mutex);
         }
-        rmutexes.clear();
-        ReleaseMutex(wmutex);
+        m_readMutexes.clear();
+        ::ReleaseMutex(m_writeMutex);
     }
 
-    m_lock_mode = QtLockedFile::NoLock;
+    m_lockMode = QtLockedFile::NoLock;
     return true;
 }
 
@@ -230,6 +255,6 @@ QtLockedFile::~QtLockedFile()
 {
     if (isOpen())
         unlock();
-    if (wmutex)
-        CloseHandle(wmutex);
+    if (m_writeMutex)
+        ::CloseHandle(m_writeMutex);
 }

src/base/bittorrent/torrentimpl.cpp

@@ -33,10 +33,6 @@
 #include <memory>
 #include <type_traits>
 
-#ifdef Q_OS_WIN
-#include <Windows.h>
-#endif
-
 #include <libtorrent/address.hpp>
 #include <libtorrent/alert_types.hpp>
 #include <libtorrent/magnet_uri.hpp>

src/base/utils/misc.cpp

@@ -133,18 +133,18 @@ void Utils::Misc::shutdownComputer(const ShutdownDialogAction &action)
 
     if (action == ShutdownDialogAction::Suspend)
     {
-        ::SetSuspendState(false, false, false);
+        ::SetSuspendState(FALSE, FALSE, FALSE);
     }
     else if (action == ShutdownDialogAction::Hibernate)
     {
-        ::SetSuspendState(true, false, false);
+        ::SetSuspendState(TRUE, FALSE, FALSE);
     }
     else
     {
         const QString msg = QCoreApplication::translate("misc", "qBittorrent will shutdown the computer now because all downloads are complete.");
         auto msgWchar = std::make_unique<wchar_t[]>(msg.length() + 1);
         msg.toWCharArray(msgWchar.get());
-        ::InitiateSystemShutdownW(nullptr, msgWchar.get(), 10, true, false);
+        ::InitiateSystemShutdownW(nullptr, msgWchar.get(), 10, TRUE, FALSE);
     }
 
     // Disable shutdown privilege.