Split InterruptSignalHandler implementations by platform to different files

Too hard to read if it's all in a single file.

Change-Id: I971e83350c04a9f8c75566d18a0f1ec8d6a0fcd0
Reviewed-by: Sami Nurmenniemi <sami.nurmenniemi@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Samuli Piippo <samuli.piippo@qt.io>

4 files changed, 116 insertions, 77 deletions

diff --git a/libqdb/interruptsignalhandler.h b/libqdb/interruptsignalhandler.h
index 01705b6..da28308 100644
--- a/libqdb/interruptsignalhandler.h
+++ b/libqdb/interruptsignalhandler.h
@@ -31,49 +31,22 @@
 
 #include <QtCore/qobject.h>
 
-#ifdef Q_OS_UNIX
-QT_BEGIN_NAMESPACE
-class QSocketNotifier;
-QT_END_NAMESPACE
-
-#include <memory>
-#include <signal.h>
-
-#elif Q_OS_WINDOWS
-#include <windows.h>
-#endif
+class InterruptSignalHandlerPrivate;
 
 class InterruptSignalHandler : public QObject
 {
     Q_OBJECT
 public:
-    explicit InterruptSignalHandler(QObject *parent = 0);
+    explicit InterruptSignalHandler(QObject *parent = nullptr);
     ~InterruptSignalHandler();
 
-#ifdef Q_OS_UNIX
-    static void sigIntHandler(int signalId);
-#elif Q_OS_WINDOWS
-    static BOOL WINAPI consoleHandler(DWORD signal);
-#endif
-
 signals:
     void interrupted();
 
-#ifdef Q_OS_UNIX
-public slots:
-    void handleSigInt();
-#endif
-
 private:
     bool installSigIntHandler();
 
-#ifdef Q_OS_UNIX
-    static int s_socketPair[2];
-    struct sigaction m_oldAction;
-    std::unique_ptr<QSocketNotifier> m_socketNotifier;
-#elif Q_OS_WINDOWS
-    static InterruptSignalHandler* m_handler;
-#endif
+    InterruptSignalHandlerPrivate* d;
 };
 
 #endif // INTERRUPTSIGNALHANDLER_H
diff --git a/libqdb/interruptsignalhandler.cpp b/libqdb/interruptsignalhandler_unix.cpp
index a4530ac..913d6d9 100644
--- a/libqdb/interruptsignalhandler.cpp
+++ b/libqdb/interruptsignalhandler_unix.cpp
@@ -28,7 +28,6 @@
 ****************************************************************************/
 #include "interruptsignalhandler.h"
 
-#ifdef Q_OS_UNIX
 #include "libqdb/make_unique.h"
 
 #include <QtCore/qdebug.h>
@@ -38,88 +37,83 @@
 #include <sys/socket.h>
 #include <unistd.h>
 
-#elif Q_OS_WINDOWS
-#include <windows.h>
-#endif
+class InterruptSignalHandlerPrivate : public QObject
+{
+    Q_OBJECT
+public:
+    InterruptSignalHandlerPrivate(InterruptSignalHandler *owner);
+
+    static void sigIntHandler(int signalId);
+
+public slots:
+    void handleSigInt();
 
-#ifdef Q_OS_UNIX
-int InterruptSignalHandler::s_socketPair[2] = {0, 0};
-#elif Q_OS_WINDOWS
-InterruptSignalHandler* InterruptSignalHandler::m_handler = nullptr;
-#endif
+public:
+    static int s_socketPair[2];
+    struct sigaction oldAction;
+    std::unique_ptr<QSocketNotifier> socketNotifier = nullptr;
+
+private:
+    InterruptSignalHandler *q;
+};
+
+int InterruptSignalHandlerPrivate::s_socketPair[2] = {0, 0};
 
 InterruptSignalHandler::InterruptSignalHandler(QObject *parent)
-    : QObject(parent)
+    : QObject{parent}, d{new InterruptSignalHandlerPrivate{this}}
 {
-#ifdef Q_OS_UNIX
-    m_socketNotifier = nullptr;
-    if (socketpair(AF_UNIX, SOCK_STREAM, 0, s_socketPair))
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, d->s_socketPair))
         qFatal("Could not create socketpair for signal handling in InterruptSignalHandler");
 
-    m_socketNotifier = make_unique<QSocketNotifier>(s_socketPair[1], QSocketNotifier::Read);
-    connect(m_socketNotifier.get(), SIGNAL(activated(int)), this, SLOT(handleSigInt()));
-#endif
+    d->socketNotifier = make_unique<QSocketNotifier>(d->s_socketPair[1], QSocketNotifier::Read);
+    connect(d->socketNotifier.get(), &QSocketNotifier::activated, d, &InterruptSignalHandlerPrivate::handleSigInt);
 
     if (!installSigIntHandler())
         qFatal("Could not install signal handler in InterruptSignalHandler");
 }
 
-InterruptSignalHandler::~InterruptSignalHandler() {
-#ifdef Q_OS_WINDOWS
-    SetConsoleCtrlHandler(&InterruptSignalHandler::consoleHandler, FALSE);
-#endif
+InterruptSignalHandler::~InterruptSignalHandler()
+{
+    delete d;
 }
 
 bool InterruptSignalHandler::installSigIntHandler()
 {
-#ifdef Q_OS_UNIX
     struct sigaction action;
-    action.sa_handler = &InterruptSignalHandler::sigIntHandler;
+    action.sa_handler = &InterruptSignalHandlerPrivate::sigIntHandler;
     sigemptyset(&action.sa_mask);
     action.sa_flags = 0;
     action.sa_flags |= SA_RESTART;
 
-    if (sigaction(SIGINT, &action, &m_oldAction))
-       return false;
-#elif Q_OS_WINDOWS
-    m_handler = this;
-    if (!SetConsoleCtrlHandler(&InterruptSignalHandler::consoleHandler, TRUE))
+    if (sigaction(SIGINT, &action, &d->oldAction))
         return false;
-#endif
 
     return true;
 }
 
-#ifdef Q_OS_UNIX
-void InterruptSignalHandler::sigIntHandler(int signalId)
+InterruptSignalHandlerPrivate::InterruptSignalHandlerPrivate(InterruptSignalHandler *owner)
+    : q{owner}
+{
+
+}
+
+void InterruptSignalHandlerPrivate::sigIntHandler(int signalId)
 {
     Q_UNUSED(signalId);
 
     char a = 1;
     write(s_socketPair[0], &a, sizeof(a));
 }
-#endif
 
-#ifdef Q_OS_UNIX
-void InterruptSignalHandler::handleSigInt()
+void InterruptSignalHandlerPrivate::handleSigInt()
 {
     char tmp;
     read(s_socketPair[1], &tmp, sizeof(tmp));
 
     // Reset signal action to allow a second Control-C to interrupt hanging qdb
-    sigaction(SIGINT, &m_oldAction, nullptr);
+    sigaction(SIGINT, &oldAction, nullptr);
 
-    emit interrupted();
+    emit q->interrupted();
 }
-#endif
 
-#ifdef Q_OS_WINDOWS
-BOOL WINAPI InterruptSignalHandler::consoleHandler(DWORD signal)
-{
-    if (signal == CTRL_C_EVENT || signal == CTRL_CLOSE_EVENT) {
-        emit m_handler->interrupted();
-        return true;
-    }
-    return false;
-}
-#endif
+#include "interruptsignalhandler_unix.moc"
diff --git a/libqdb/interruptsignalhandler_win.cpp b/libqdb/interruptsignalhandler_win.cpp
new file mode 100644
index 0000000..5ab4323
--- /dev/null
+++ b/libqdb/interruptsignalhandler_win.cpp
@@ -0,0 +1,67 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt Debug Bridge.
+**
+** $QT_BEGIN_LICENSE:GPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 or (at your option) any later version
+** approved by the KDE Free Qt Foundation. The licenses are as published by
+** the Free Software Foundation and appearing in the file LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "interruptsignalhandler.h"
+
+#include <windows.h>
+
+class InterruptSignalHandlerPrivate
+{
+public:
+    static BOOL WINAPI consoleHandler(DWORD signal);
+    static InterruptSignalHandler* s_handler;
+};
+
+InterruptSignalHandler* InterruptSignalHandlerPrivate::s_handler = nullptr;
+
+InterruptSignalHandler::InterruptSignalHandler(QObject *parent)
+    : QObject(parent)
+{
+    if (!installSigIntHandler())
+        qFatal("Could not install signal handler in InterruptSignalHandler");
+}
+
+InterruptSignalHandler::~InterruptSignalHandler()
+{
+    SetConsoleCtrlHandler(&InterruptSignalHandlerPrivate::consoleHandler, FALSE);
+}
+
+bool InterruptSignalHandler::installSigIntHandler()
+{
+    d->s_handler = this;
+    return SetConsoleCtrlHandler(&InterruptSignalHandlerPrivate::consoleHandler, TRUE);
+}
+
+BOOL WINAPI InterruptSignalHandlerPrivate::consoleHandler(DWORD signal)
+{
+    if (signal == CTRL_C_EVENT || signal == CTRL_CLOSE_EVENT) {
+        emit s_handler->interrupted();
+        return true;
+    }
+    return false;
+}
diff --git a/libqdb/libqdb.pro b/libqdb/libqdb.pro
index b2df392..042a621 100644
--- a/libqdb/libqdb.pro
+++ b/libqdb/libqdb.pro
@@ -6,12 +6,17 @@ CONFIG += staticlib
 
 SOURCES += \
     abstractconnection.cpp \
-    interruptsignalhandler.cpp \
     protocol/qdbmessage.cpp \
     protocol/qdbtransport.cpp \
     stream.cpp \
     streampacket.cpp \
 
+win32 {
+    SOURCES += interruptsignalhandler_win.cpp
+} else {
+    SOURCES += interruptsignalhandler_unix.cpp
+}
+
 HEADERS += \
     abstractconnection.h \
     interruptsignalhandler.h \