Use QObjectPrivate instead of dedicated d-ptr

Change-Id: I3f69a2b0ca81e1e003200bb8e0a337b9532e64a0
Reviewed-by: Kurt Pattyn <pattyn.kurt@gmail.com>

9 files changed, 170 insertions, 178 deletions

diff --git a/src/websockets/qwebsocket.cpp b/src/websockets/qwebsocket.cpp
index b500853..45394e3 100644
--- a/src/websockets/qwebsocket.cpp
+++ b/src/websockets/qwebsocket.cpp
@@ -260,8 +260,7 @@ QT_BEGIN_NAMESPACE
 QWebSocket::QWebSocket(const QString &origin,
                        QWebSocketProtocol::Version version,
                        QObject *parent) :
-    QObject(parent),
-    d_ptr(new QWebSocketPrivate(origin, version, this, this))
+    QObject(*(new QWebSocketPrivate(origin, version, this)), parent)
 {
 }
 
@@ -271,7 +270,6 @@ QWebSocket::QWebSocket(const QString &origin,
  */
 QWebSocket::~QWebSocket()
 {
-    delete d_ptr;
 }
 
 /*!
@@ -301,8 +299,7 @@ QAbstractSocket::SocketError QWebSocket::error() const
  */
 QWebSocket::QWebSocket(QTcpSocket *pTcpSocket,
                        QWebSocketProtocol::Version version, QObject *parent) :
-    QObject(parent),
-    d_ptr(new QWebSocketPrivate(pTcpSocket, version, this, this))
+    QObject(*(new QWebSocketPrivate(pTcpSocket, version, this)), parent)
 {
 }
 
diff --git a/src/websockets/qwebsocket.h b/src/websockets/qwebsocket.h
index 5a8cd1a..7d1e544 100644
--- a/src/websockets/qwebsocket.h
+++ b/src/websockets/qwebsocket.h
@@ -142,7 +142,6 @@ Q_SIGNALS:
 private:
     QWebSocket(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version,
                QObject *parent = Q_NULLPTR);
-    QWebSocketPrivate * const d_ptr;
 };
 
 QT_END_NAMESPACE
diff --git a/src/websockets/qwebsocket_p.cpp b/src/websockets/qwebsocket_p.cpp
index 10597d3..fe4dd8a 100644
--- a/src/websockets/qwebsocket_p.cpp
+++ b/src/websockets/qwebsocket_p.cpp
@@ -87,8 +87,8 @@ QWebSocketConfiguration::QWebSocketConfiguration() :
     \internal
 */
 QWebSocketPrivate::QWebSocketPrivate(const QString &origin, QWebSocketProtocol::Version version,
-                                     QWebSocket *pWebSocket, QObject *parent) :
-    QObject(parent),
+                                     QWebSocket *pWebSocket) :
+    QObjectPrivate(),
     q_ptr(pWebSocket),
     m_pSocket(),
     m_errorString(QWebSocket::tr("Unknown error")),
@@ -118,8 +118,8 @@ QWebSocketPrivate::QWebSocketPrivate(const QString &origin, QWebSocketProtocol::
     \internal
 */
 QWebSocketPrivate::QWebSocketPrivate(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version,
-                                     QWebSocket *pWebSocket, QObject *parent) :
-    QObject(parent),
+                                     QWebSocket *pWebSocket) :
+    QObjectPrivate(),
     q_ptr(pWebSocket),
     m_pSocket(pTcpSocket),
     m_errorString(pTcpSocket->errorString()),
@@ -164,7 +164,7 @@ QWebSocketPrivate::~QWebSocketPrivate()
     if (!m_pSocket)
         return;
     if (state() == QAbstractSocket::ConnectedState)
-        close(QWebSocketProtocol::CloseCodeGoingAway, tr("Connection closed"));
+        close(QWebSocketProtocol::CloseCodeGoingAway, QWebSocket::tr("Connection closed"));
     releaseConnections(m_pSocket.data());
 }
 
@@ -360,11 +360,12 @@ void QWebSocketPrivate::open(const QUrl &url, bool mask)
     #ifndef QT_NO_SSL
         if (url.scheme() == QStringLiteral("wss")) {
             if (!QSslSocket::supportsSsl()) {
-                const QString message = tr("SSL Sockets are not supported on this platform.");
+                const QString message =
+                        QWebSocket::tr("SSL Sockets are not supported on this platform.");
                 setErrorString(message);
                 Q_EMIT q->error(QAbstractSocket::UnsupportedSocketOperationError);
             } else {
-                QSslSocket *sslSocket = new QSslSocket(this);
+                QSslSocket *sslSocket = new QSslSocket(q);
                 m_pSocket.reset(sslSocket);
                 if (Q_LIKELY(m_pSocket)) {
                     m_pSocket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
@@ -373,8 +374,8 @@ void QWebSocketPrivate::open(const QUrl &url, bool mask)
                     m_pSocket->setPauseMode(m_pauseMode);
 
                     makeConnections(m_pSocket.data());
-                    connect(sslSocket, &QSslSocket::encryptedBytesWritten, q,
-                            &QWebSocket::bytesWritten);
+                    QObject::connect(sslSocket, &QSslSocket::encryptedBytesWritten, q,
+                                     &QWebSocket::bytesWritten);
                     setSocketState(QAbstractSocket::ConnectingState);
 
                     sslSocket->setSslConfiguration(m_configuration.m_sslConfiguration);
@@ -387,7 +388,7 @@ void QWebSocketPrivate::open(const QUrl &url, bool mask)
     #endif
                     sslSocket->connectToHostEncrypted(url.host(), url.port(443));
                 } else {
-                    const QString message = tr("Out of memory.");
+                    const QString message = QWebSocket::tr("Out of memory.");
                     setErrorString(message);
                     Q_EMIT q->error(QAbstractSocket::SocketResourceError);
                 }
@@ -395,7 +396,7 @@ void QWebSocketPrivate::open(const QUrl &url, bool mask)
         } else
     #endif
         if (url.scheme() == QStringLiteral("ws")) {
-            m_pSocket.reset(new QTcpSocket(this));
+            m_pSocket.reset(new QTcpSocket(q));
             if (Q_LIKELY(m_pSocket)) {
                 m_pSocket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
                 m_pSocket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
@@ -403,20 +404,21 @@ void QWebSocketPrivate::open(const QUrl &url, bool mask)
                 m_pSocket->setPauseMode(m_pauseMode);
 
                 makeConnections(m_pSocket.data());
-                connect(m_pSocket.data(), &QAbstractSocket::bytesWritten, q,
-                        &QWebSocket::bytesWritten);
+                QObject::connect(m_pSocket.data(), &QAbstractSocket::bytesWritten, q,
+                                 &QWebSocket::bytesWritten);
                 setSocketState(QAbstractSocket::ConnectingState);
     #ifndef QT_NO_NETWORKPROXY
                 m_pSocket->setProxy(m_configuration.m_proxy);
     #endif
                 m_pSocket->connectToHost(url.host(), url.port(80));
             } else {
-                const QString message = tr("Out of memory.");
+                const QString message = QWebSocket::tr("Out of memory.");
                 setErrorString(message);
                 Q_EMIT q->error(QAbstractSocket::SocketResourceError);
             }
         } else {
-            const QString message = tr("Unsupported websockets scheme: %1").arg(url.scheme());
+            const QString message =
+                    QWebSocket::tr("Unsupported websockets scheme: %1").arg(url.scheme());
             setErrorString(message);
             Q_EMIT q->error(QAbstractSocket::UnsupportedSocketOperationError);
         }
@@ -515,40 +517,40 @@ void QWebSocketPrivate::makeConnections(const QTcpSocket *pTcpSocket)
         //pass through signals
         typedef void (QAbstractSocket:: *ASErrorSignal)(QAbstractSocket::SocketError);
         typedef void (QWebSocket:: *WSErrorSignal)(QAbstractSocket::SocketError);
-        connect(pTcpSocket,
-                static_cast<ASErrorSignal>(&QAbstractSocket::error),
-                q, static_cast<WSErrorSignal>(&QWebSocket::error));
-        connect(pTcpSocket, &QAbstractSocket::proxyAuthenticationRequired, q,
-                &QWebSocket::proxyAuthenticationRequired);
-        connect(pTcpSocket, &QAbstractSocket::readChannelFinished, q,
-                &QWebSocket::readChannelFinished);
-        connect(pTcpSocket, &QAbstractSocket::aboutToClose, q, &QWebSocket::aboutToClose);
+        QObject::connect(pTcpSocket,
+                         static_cast<ASErrorSignal>(&QAbstractSocket::error),
+                         q, static_cast<WSErrorSignal>(&QWebSocket::error));
+        QObject::connect(pTcpSocket, &QAbstractSocket::proxyAuthenticationRequired, q,
+                         &QWebSocket::proxyAuthenticationRequired);
+        QObject::connect(pTcpSocket, &QAbstractSocket::readChannelFinished, q,
+                         &QWebSocket::readChannelFinished);
+        QObject::connect(pTcpSocket, &QAbstractSocket::aboutToClose, q, &QWebSocket::aboutToClose);
 
         //catch signals
-        connect(pTcpSocket, &QAbstractSocket::stateChanged, this,
-                &QWebSocketPrivate::processStateChanged);
+        QObjectPrivate::connect(pTcpSocket, &QAbstractSocket::stateChanged, this,
+                                &QWebSocketPrivate::processStateChanged);
         //!!!important to use a QueuedConnection here;
         //with QTcpSocket there is no problem, but with QSslSocket the processing hangs
-        connect(pTcpSocket, &QAbstractSocket::readyRead, this,
-                &QWebSocketPrivate::processData, Qt::QueuedConnection);
+        QObjectPrivate::connect(pTcpSocket, &QAbstractSocket::readyRead, this,
+                                &QWebSocketPrivate::processData, Qt::QueuedConnection);
     }
 
-    connect(&m_dataProcessor, &QWebSocketDataProcessor::textFrameReceived, q,
-            &QWebSocket::textFrameReceived);
-    connect(&m_dataProcessor, &QWebSocketDataProcessor::binaryFrameReceived, q,
-            &QWebSocket::binaryFrameReceived);
-    connect(&m_dataProcessor, &QWebSocketDataProcessor::binaryMessageReceived, q,
-            &QWebSocket::binaryMessageReceived);
-    connect(&m_dataProcessor, &QWebSocketDataProcessor::textMessageReceived, q,
-            &QWebSocket::textMessageReceived);
-    connect(&m_dataProcessor, &QWebSocketDataProcessor::errorEncountered, this,
-            &QWebSocketPrivate::close);
-    connect(&m_dataProcessor, &QWebSocketDataProcessor::pingReceived, this,
-            &QWebSocketPrivate::processPing);
-    connect(&m_dataProcessor, &QWebSocketDataProcessor::pongReceived, this,
-            &QWebSocketPrivate::processPong);
-    connect(&m_dataProcessor, &QWebSocketDataProcessor::closeReceived, this,
-            &QWebSocketPrivate::processClose);
+    QObject::connect(&m_dataProcessor, &QWebSocketDataProcessor::textFrameReceived, q,
+                     &QWebSocket::textFrameReceived);
+    QObject::connect(&m_dataProcessor, &QWebSocketDataProcessor::binaryFrameReceived, q,
+                     &QWebSocket::binaryFrameReceived);
+    QObject::connect(&m_dataProcessor, &QWebSocketDataProcessor::binaryMessageReceived, q,
+                     &QWebSocket::binaryMessageReceived);
+    QObject::connect(&m_dataProcessor, &QWebSocketDataProcessor::textMessageReceived, q,
+                     &QWebSocket::textMessageReceived);
+    QObjectPrivate::connect(&m_dataProcessor, &QWebSocketDataProcessor::errorEncountered, this,
+                            &QWebSocketPrivate::close);
+    QObjectPrivate::connect(&m_dataProcessor, &QWebSocketDataProcessor::pingReceived, this,
+                            &QWebSocketPrivate::processPing);
+    QObjectPrivate::connect(&m_dataProcessor, &QWebSocketDataProcessor::pongReceived, this,
+                            &QWebSocketPrivate::processPong);
+    QObjectPrivate::connect(&m_dataProcessor, &QWebSocketDataProcessor::closeReceived, this,
+                            &QWebSocketPrivate::processClose);
 }
 
 /*!
@@ -557,8 +559,8 @@ void QWebSocketPrivate::makeConnections(const QTcpSocket *pTcpSocket)
 void QWebSocketPrivate::releaseConnections(const QTcpSocket *pTcpSocket)
 {
     if (Q_LIKELY(pTcpSocket))
-        disconnect(pTcpSocket);
-    disconnect(&m_dataProcessor);
+        pTcpSocket->disconnect(pTcpSocket);
+    m_dataProcessor.disconnect(&m_dataProcessor);
 }
 
 /*!
@@ -727,7 +729,7 @@ qint64 QWebSocketPrivate::doWriteFrames(const QByteArray &data, bool isBinary)
                 payloadWritten += written;
             } else {
                 m_pSocket->flush();
-                setErrorString(tr("Error writing bytes to socket: %1.")
+                setErrorString(QWebSocket::tr("Error writing bytes to socket: %1.")
                                .arg(m_pSocket->errorString()));
                 Q_EMIT q->error(QAbstractSocket::NetworkError);
                 break;
@@ -737,7 +739,8 @@ qint64 QWebSocketPrivate::doWriteFrames(const QByteArray &data, bool isBinary)
         bytesLeft -= size;
     }
     if (Q_UNLIKELY(payloadWritten != data.size())) {
-        setErrorString(tr("Bytes written %1 != %2.").arg(payloadWritten).arg(data.size()));
+        setErrorString(QWebSocket::tr("Bytes written %1 != %2.")
+                       .arg(payloadWritten).arg(data.size()));
         Q_EMIT q->error(QAbstractSocket::NetworkError);
     }
     return payloadWritten;
@@ -861,7 +864,7 @@ void QWebSocketPrivate::processHandshake(QTcpSocket *pSocket)
         }
     }
     if (Q_UNLIKELY(!ok)) {
-        errorDescription = tr("Invalid statusline in response: %1.").arg(statusLine);
+        errorDescription = QWebSocket::tr("Invalid statusline in response: %1.").arg(statusLine);
     } else {
         QString headerLine = readLine(pSocket);
         QMap<QString, QString> headers;
@@ -898,11 +901,11 @@ void QWebSocketPrivate::processHandshake(QTcpSocket *pSocket)
                 ok = (accept == acceptKey);
                 if (!ok)
                     errorDescription =
-                      tr("Accept-Key received from server %1 does not match the client key %2.")
+                      QWebSocket::tr("Accept-Key received from server %1 does not match the client key %2.")
                             .arg(acceptKey).arg(accept);
             } else {
                 errorDescription =
-                    tr("QWebSocketPrivate::processHandshake: Invalid statusline in response: %1.")
+                    QWebSocket::tr("QWebSocketPrivate::processHandshake: Invalid statusline in response: %1.")
                         .arg(statusLine);
             }
         } else if (httpStatusCode == 400) {
@@ -914,21 +917,20 @@ void QWebSocketPrivate::processHandshake(QTcpSocket *pSocket)
                     //if needed to switch protocol version, then we are finished here
                     //because we cannot handle other protocols than the RFC one (v13)
                     errorDescription =
-                            tr("Handshake: Server requests a version that we don't support: %1.")
+                            QWebSocket::tr("Handshake: Server requests a version that we don't support: %1.")
                             .arg(versions.join(QStringLiteral(", ")));
                     ok = false;
                 } else {
                     //we tried v13, but something different went wrong
                     errorDescription =
-                        tr("QWebSocketPrivate::processHandshake: Unknown error condition " \
-                           "encountered. Aborting connection.");
+                        QWebSocket::tr("QWebSocketPrivate::processHandshake: Unknown error condition encountered. Aborting connection.");
                     ok = false;
                 }
             }
         } else {
             errorDescription =
-                    tr("QWebSocketPrivate::processHandshake: Unhandled http status code: %1 (%2).")
-                    .arg(httpStatusCode).arg(httpStatusMessage);
+                    QWebSocket::tr("QWebSocketPrivate::processHandshake: Unhandled http status code: %1 (%2).")
+                        .arg(httpStatusCode).arg(httpStatusMessage);
             ok = false;
         }
 
diff --git a/src/websockets/qwebsocket_p.h b/src/websockets/qwebsocket_p.h
index d8c97dd..3bd9918 100644
--- a/src/websockets/qwebsocket_p.h
+++ b/src/websockets/qwebsocket_p.h
@@ -64,6 +64,7 @@
 #include <QtNetwork/QSslSocket>
 #endif
 #include <QtCore/QTime>
+#include <private/qobject_p.h>
 
 #include "qwebsocketprotocol.h"
 #include "qwebsocketdataprocessor_p.h"
@@ -94,17 +95,15 @@ public:
     QTcpSocket *m_pSocket;
 };
 
-class QWebSocketPrivate : public QObject
+class QWebSocketPrivate : public QObjectPrivate
 {
-    Q_OBJECT
     Q_DISABLE_COPY(QWebSocketPrivate)
-    Q_DECLARE_PUBLIC(QWebSocket)
 
 public:
+    Q_DECLARE_PUBLIC(QWebSocket)
     explicit QWebSocketPrivate(const QString &origin,
                                QWebSocketProtocol::Version version,
-                               QWebSocket * const pWebSocket,
-                               QObject *parent = Q_NULLPTR);
+                               QWebSocket * const pWebSocket);
     virtual ~QWebSocketPrivate();
 
     void init();
@@ -143,32 +142,20 @@ public:
 
 #ifndef QT_NO_SSL
     void ignoreSslErrors(const QList<QSslError> &errors);
+    void ignoreSslErrors();
     void setSslConfiguration(const QSslConfiguration &sslConfiguration);
     QSslConfiguration sslConfiguration() const;
 #endif
 
-public Q_SLOTS:
     void close(QWebSocketProtocol::CloseCode closeCode, QString reason);
     void open(const QUrl &url, bool mask);
     void ping(const QByteArray &payload);
 
-#ifndef QT_NO_SSL
-    void ignoreSslErrors();
-#endif
-
-private Q_SLOTS:
-    void processData();
-    void processPing(const QByteArray &data);
-    void processPong(const QByteArray &data);
-    void processClose(QWebSocketProtocol::CloseCode closeCode, QString closeReason);
-    void processHandshake(QTcpSocket *pSocket);
-    void processStateChanged(QAbstractSocket::SocketState socketState);
-
-private:
     QWebSocket * const q_ptr;
 
+private:
     QWebSocketPrivate(QTcpSocket *pTcpSocket, QWebSocketProtocol::Version version,
-                      QWebSocket *pWebSocket, QObject *parent = Q_NULLPTR);
+                      QWebSocket *pWebSocket);
     void setVersion(QWebSocketProtocol::Version version);
     void setResourceName(const QString &resourceName);
     void setRequestUrl(const QUrl &requestUrl);
@@ -179,6 +166,13 @@ private:
     void setSocketState(QAbstractSocket::SocketState state);
     void setErrorString(const QString &errorString);
 
+    void processData();
+    void processPing(const QByteArray &data);
+    void processPong(const QByteArray &data);
+    void processClose(QWebSocketProtocol::CloseCode closeCode, QString closeReason);
+    void processHandshake(QTcpSocket *pSocket);
+    void processStateChanged(QAbstractSocket::SocketState socketState);
+
     qint64 doWriteFrames(const QByteArray &data, bool isBinary) Q_REQUIRED_RESULT;
 
     void makeConnections(const QTcpSocket *pTcpSocket);
diff --git a/src/websockets/qwebsocketserver.cpp b/src/websockets/qwebsocketserver.cpp
index 580e0ce..10ee83e 100644
--- a/src/websockets/qwebsocketserver.cpp
+++ b/src/websockets/qwebsocketserver.cpp
@@ -223,8 +223,7 @@ QT_BEGIN_NAMESPACE
  */
 QWebSocketServer::QWebSocketServer(const QString &serverName, SslMode secureMode,
                                    QObject *parent) :
-    QObject(parent),
-    d_ptr(new QWebSocketServerPrivate(serverName,
+    QObject(*(new QWebSocketServerPrivate(serverName,
                                       #ifndef QT_NO_SSL
                                       (secureMode == SecureMode) ?
                                           QWebSocketServerPrivate::SecureMode :
@@ -232,8 +231,7 @@ QWebSocketServer::QWebSocketServer(const QString &serverName, SslMode secureMode
                                       #else
                                       QWebSocketServerPrivate::NonSecureMode,
                                       #endif
-                                      this,
-                                      this))
+                                      this)), parent)
 {
 #ifdef QT_NO_SSL
     Q_UNUSED(secureMode)
@@ -249,7 +247,6 @@ QWebSocketServer::QWebSocketServer(const QString &serverName, SslMode secureMode
  */
 QWebSocketServer::~QWebSocketServer()
 {
-    delete d_ptr;
 }
 
 /*!
diff --git a/src/websockets/qwebsocketserver.h b/src/websockets/qwebsocketserver.h
index 630a42d..64a7179 100644
--- a/src/websockets/qwebsocketserver.h
+++ b/src/websockets/qwebsocketserver.h
@@ -131,9 +131,6 @@ Q_SIGNALS:
     void sslErrors(const QList<QSslError> &errors);
 #endif
     void closed();
-
-private:
-    QWebSocketServerPrivate * const d_ptr;
 };
 
 QT_END_NAMESPACE
diff --git a/src/websockets/qwebsocketserver_p.cpp b/src/websockets/qwebsocketserver_p.cpp
index af43333..912c66e 100644
--- a/src/websockets/qwebsocketserver_p.cpp
+++ b/src/websockets/qwebsocketserver_p.cpp
@@ -62,9 +62,8 @@ QT_BEGIN_NAMESPACE
  */
 QWebSocketServerPrivate::QWebSocketServerPrivate(const QString &serverName,
                                                  QWebSocketServerPrivate::SslMode secureMode,
-                                                 QWebSocketServer * const pWebSocketServer,
-                                                 QObject *parent) :
-    QObject(parent),
+                                                 QWebSocketServer * const pWebSocketServer) :
+    QObjectPrivate(),
     q_ptr(pWebSocketServer),
     m_pTcpServer(Q_NULLPTR),
     m_serverName(serverName),
@@ -75,29 +74,29 @@ QWebSocketServerPrivate::QWebSocketServerPrivate(const QString &serverName,
 {
     Q_ASSERT(pWebSocketServer);
     if (m_secureMode == NonSecureMode) {
-        m_pTcpServer = new QTcpServer(this);
+        m_pTcpServer = new QTcpServer();
         if (Q_LIKELY(m_pTcpServer))
-            connect(m_pTcpServer, &QTcpServer::newConnection,
-                    this, &QWebSocketServerPrivate::onNewConnection);
+            QObjectPrivate::connect(m_pTcpServer, &QTcpServer::newConnection,
+                                    this, &QWebSocketServerPrivate::onNewConnection);
         else
             qFatal("Could not allocate memory for tcp server.");
     } else {
 #ifndef QT_NO_SSL
-        QSslServer *pSslServer = new QSslServer(this);
+        QSslServer *pSslServer = new QSslServer();
         m_pTcpServer = pSslServer;
         if (Q_LIKELY(m_pTcpServer)) {
-            connect(pSslServer, &QSslServer::newEncryptedConnection,
-                    this, &QWebSocketServerPrivate::onNewConnection);
-            connect(pSslServer, &QSslServer::peerVerifyError,
-                    q_ptr, &QWebSocketServer::peerVerifyError);
-            connect(pSslServer, &QSslServer::sslErrors,
-                    q_ptr, &QWebSocketServer::sslErrors);
+            QObjectPrivate::connect(pSslServer, &QSslServer::newEncryptedConnection,
+                                    this, &QWebSocketServerPrivate::onNewConnection);
+            QObject::connect(pSslServer, &QSslServer::peerVerifyError,
+                             q_ptr, &QWebSocketServer::peerVerifyError);
+            QObject::connect(pSslServer, &QSslServer::sslErrors,
+                             q_ptr, &QWebSocketServer::sslErrors);
         }
 #else
         qFatal("SSL not supported on this platform.");
 #endif
     }
-    connect(m_pTcpServer, &QTcpServer::acceptError, q_ptr, &QWebSocketServer::acceptError);
+    QObject::connect(m_pTcpServer, &QTcpServer::acceptError, q_ptr, &QWebSocketServer::acceptError);
 }
 
 /*!
@@ -118,7 +117,8 @@ void QWebSocketServerPrivate::close()
     m_pTcpServer->close();
     while (!m_pendingConnections.isEmpty()) {
         QWebSocket *pWebSocket = m_pendingConnections.dequeue();
-        pWebSocket->close(QWebSocketProtocol::CloseCodeGoingAway, tr("Server closed."));
+        pWebSocket->close(QWebSocketProtocol::CloseCodeGoingAway,
+                          QWebSocketServer::tr("Server closed."));
         pWebSocket->deleteLater();
     }
     //emit signal via the event queue, so the server gets time
@@ -368,7 +368,8 @@ void QWebSocketServerPrivate::setError(QWebSocketProtocol::CloseCode code, const
 void QWebSocketServerPrivate::onNewConnection()
 {
     QTcpSocket *pTcpSocket = m_pTcpServer->nextPendingConnection();
-    connect(pTcpSocket, &QTcpSocket::readyRead, this, &QWebSocketServerPrivate::handshakeReceived);
+    QObjectPrivate::connect(pTcpSocket, &QTcpSocket::readyRead,
+                            this, &QWebSocketServerPrivate::handshakeReceived);
 }
 
 /*!
@@ -376,9 +377,11 @@ void QWebSocketServerPrivate::onNewConnection()
  */
 void QWebSocketServerPrivate::onCloseConnection()
 {
-    QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(sender());
-    if (Q_LIKELY(pTcpSocket))
-        pTcpSocket->close();
+    if (Q_LIKELY(currentSender)) {
+        QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(currentSender->sender);
+        if (Q_LIKELY(pTcpSocket))
+            pTcpSocket->close();
+    }
 }
 
 /*!
@@ -386,71 +389,76 @@ void QWebSocketServerPrivate::onCloseConnection()
  */
 void QWebSocketServerPrivate::handshakeReceived()
 {
+    if (Q_UNLIKELY(!currentSender)) {
+        qWarning() << QWebSocketServer::tr("Sender is NULL. This is a Qt bug.");
+        return;
+    }
+    QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(currentSender->sender);
+    if (Q_UNLIKELY(!pTcpSocket)) {
+        qWarning() << QWebSocketServer::tr("Sender is not a QTcpSocket. This is a Qt bug!!!");
+        return;
+    }
     Q_Q(QWebSocketServer);
-    QTcpSocket *pTcpSocket = qobject_cast<QTcpSocket*>(sender());
-    if (Q_LIKELY(pTcpSocket)) {
-        bool success = false;
-        bool isSecure = false;
+    bool success = false;
+    bool isSecure = false;
 
-        disconnect(pTcpSocket, &QTcpSocket::readyRead,
-                   this, &QWebSocketServerPrivate::handshakeReceived);
+    disconnect(pTcpSocket, &QTcpSocket::readyRead,
+               this, &QWebSocketServerPrivate::handshakeReceived);
 
-        if (m_pendingConnections.length() >= maxPendingConnections()) {
-            pTcpSocket->close();
-            pTcpSocket->deleteLater();
-            setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
-                     tr("Too many pending connections."));
-            return;
-        }
+    if (m_pendingConnections.length() >= maxPendingConnections()) {
+        pTcpSocket->close();
+        pTcpSocket->deleteLater();
+        qWarning() << QWebSocketServer::tr("Too many pending connections: " \
+                                           "New websocket connection not accepted.");
+        setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
+                 QWebSocketServer::tr("Too many pending connections."));
+        return;
+    }
 
-        QWebSocketHandshakeRequest request(pTcpSocket->peerPort(), isSecure);
-        QTextStream textStream(pTcpSocket);
-        request.readHandshake(textStream);
-
-        if (request.isValid()) {
-            QWebSocketCorsAuthenticator corsAuthenticator(request.origin());
-            Q_EMIT q->originAuthenticationRequired(&corsAuthenticator);
-
-            QWebSocketHandshakeResponse response(request,
-                                                 m_serverName,
-                                                 corsAuthenticator.allowed(),
-                                                 supportedVersions(),
-                                                 supportedProtocols(),
-                                                 supportedExtensions());
-
-            if (response.isValid()) {
-                QTextStream httpStream(pTcpSocket);
-                httpStream << response;
-                httpStream.flush();
-
-                if (response.canUpgrade()) {
-                    QWebSocket *pWebSocket = QWebSocketPrivate::upgradeFrom(pTcpSocket,
-                                                                            request,
-                                                                            response);
-                    if (pWebSocket) {
-                        addPendingConnection(pWebSocket);
-                        Q_EMIT q->newConnection();
-                        success = true;
-                    } else {
-                        setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
-                                 tr("Upgrading to websocket failed."));
-                    }
-                }
-                else {
-                    setError(response.error(), response.errorString());
+    QWebSocketHandshakeRequest request(pTcpSocket->peerPort(), isSecure);
+    QTextStream textStream(pTcpSocket);
+    request.readHandshake(textStream);
+
+    if (request.isValid()) {
+        QWebSocketCorsAuthenticator corsAuthenticator(request.origin());
+        Q_EMIT q->originAuthenticationRequired(&corsAuthenticator);
+
+        QWebSocketHandshakeResponse response(request,
+                                             m_serverName,
+                                             corsAuthenticator.allowed(),
+                                             supportedVersions(),
+                                             supportedProtocols(),
+                                             supportedExtensions());
+
+        if (response.isValid()) {
+            QTextStream httpStream(pTcpSocket);
+            httpStream << response;
+            httpStream.flush();
+
+            if (response.canUpgrade()) {
+                QWebSocket *pWebSocket = QWebSocketPrivate::upgradeFrom(pTcpSocket,
+                                                                        request,
+                                                                        response);
+                if (pWebSocket) {
+                    addPendingConnection(pWebSocket);
+                    Q_EMIT q->newConnection();
+                    success = true;
+                } else {
+                    setError(QWebSocketProtocol::CloseCodeAbnormalDisconnection,
+                             QWebSocketServer::tr("Upgrading to websocket failed."));
                 }
-            } else {
-                setError(QWebSocketProtocol::CloseCodeProtocolError, tr("Invalid response received."));
             }
+            else {
+                setError(response.error(), response.errorString());
+            }
+        } else {
+            setError(QWebSocketProtocol::CloseCodeProtocolError,
+                     QWebSocketServer::tr("Invalid response received."));
         }
-        if (!success) {
-            qWarning() << tr("Closing socket because of invalid or unsupported request.");
-            pTcpSocket->close();
-            pTcpSocket->deleteLater();
-        }
-    } else {
-        qWarning() <<
-            tr("Sender socket is NULL. This should not happen, otherwise it is a Qt bug!!!");
+    }
+    if (!success) {
+        qWarning() << QWebSocketServer::tr("Closing socket because of invalid or unsupported request.");
+        pTcpSocket->close();
     }
 }
 
diff --git a/src/websockets/qwebsocketserver_p.h b/src/websockets/qwebsocketserver_p.h
index 7909b69..a9aa880 100644
--- a/src/websockets/qwebsocketserver_p.h
+++ b/src/websockets/qwebsocketserver_p.h
@@ -56,6 +56,7 @@
 #include <QtCore/QQueue>
 #include <QtCore/QString>
 #include <QtNetwork/QHostAddress>
+#include <private/qobject_p.h>
 #include "qwebsocket.h"
 
 #ifndef QT_NO_SSL
@@ -68,13 +69,12 @@ QT_BEGIN_NAMESPACE
 class QTcpServer;
 class QWebSocketServer;
 
-class QWebSocketServerPrivate : public QObject
+class QWebSocketServerPrivate : public QObjectPrivate
 {
-    Q_OBJECT
     Q_DISABLE_COPY(QWebSocketServerPrivate)
-    Q_DECLARE_PUBLIC(QWebSocketServer)
 
 public:
+    Q_DECLARE_PUBLIC(QWebSocketServer)
     enum SslMode
     {
         SecureMode = true,
@@ -82,8 +82,7 @@ public:
     };
 
     explicit QWebSocketServerPrivate(const QString &serverName, SslMode secureMode,
-                                     QWebSocketServer * const pWebSocketServer,
-                                     QObject *parent = Q_NULLPTR);
+                                     QWebSocketServer * const pWebSocketServer);
     virtual ~QWebSocketServerPrivate();
 
     void close();
@@ -122,14 +121,9 @@ public:
 
     void setError(QWebSocketProtocol::CloseCode code, const QString &errorString);
 
-private Q_SLOTS:
-    void onNewConnection();
-    void onCloseConnection();
-    void handshakeReceived();
-
-private:
     QWebSocketServer * const q_ptr;
 
+private:
     QTcpServer *m_pTcpServer;
     QString m_serverName;
     SslMode m_secureMode;
@@ -140,6 +134,10 @@ private:
     void addPendingConnection(QWebSocket *pWebSocket);
     void setErrorFromSocketError(QAbstractSocket::SocketError error,
                                  const QString &errorDescription);
+
+    void onNewConnection();
+    void onCloseConnection();
+    void handshakeReceived();
 };
 
 QT_END_NAMESPACE
diff --git a/src/websockets/websockets.pro b/src/websockets/websockets.pro
index 792c9ce..04bee8e 100644
--- a/src/websockets/websockets.pro
+++ b/src/websockets/websockets.pro
@@ -1,7 +1,7 @@
 load(qt_build_config)
 TARGET = QtWebSockets
 
-QT = core network
+QT = core network core-private
 
 TEMPLATE = lib