Introduce QIODevice::skipData()

QIODevice::skip() called a virtual QIODevicePrivate::skip() to
implement an efficient skipping on I/O devices for the internal
subclasses. The user subclasses cannot inherit QIODevicePrivate, so
this functionality was not externally accessible.

This patch replaces QIODevicePrivate::skip() with a virtual protected
QIODevice::skipData(). While the basic implementation simply discards
the data by reading into a dummy buffer, users can reimplement this
function to improve the performance in their subclasses.

[ChangeLog][QtCore][QIODevice] Added virtual protected skipData().
Now, subclasses can implement device-specific skipping of data.

Change-Id: I9522f7f7ab9d03ac06e972a525f8ec2fa909a617
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@gmx.de>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

src/corelib/io/qiodevice.cpp

@@ -1915,7 +1915,7 @@ QByteArray QIODevice::peek(qint64 maxSize)
     For random-access devices, skip() can be used to seek forward from the
     current position. Negative \a maxSize values are not allowed.
 
-    \sa peek(), seek(), read()
+    \sa skipData(), peek(), seek(), read()
 */
 qint64 QIODevice::skip(qint64 maxSize)
 {
@@ -1968,7 +1968,7 @@ qint64 QIODevice::skip(qint64 maxSize)
         }
     }
 
-    const qint64 skipResult = d->skip(maxSize);
+    const qint64 skipResult = skipData(maxSize);
     if (skippedSoFar == 0)
         return skipResult;
 
@@ -2008,14 +2008,23 @@ qint64 QIODevicePrivate::skipByReading(qint64 maxSize)
 }
 
 /*!
-    \internal
+    \since 6.0
+
+    Skips up to \a maxSize bytes from the device. Returns the number of bytes
+    actually skipped, or -1 on error.
+
+    This function is called by QIODevice. Consider reimplementing it
+    when creating a subclass of QIODevice.
+
+    The base implementation discards the data by reading into a dummy buffer.
+    This is slow, but works for all types of devices. Subclasses can
+    reimplement this function to improve on that.
+
+    \sa skip(), peek(), seek(), read()
 */
-qint64 QIODevicePrivate::skip(qint64 maxSize)
+qint64 QIODevice::skipData(qint64 maxSize)
 {
-    // Base implementation discards the data by reading into the dummy buffer.
-    // It's slow, but this works for all types of devices. Subclasses can
-    // reimplement this function to improve on that.
-    return skipByReading(maxSize);
+    return d_func()->skipByReading(maxSize);
 }
 
 /*!

src/corelib/io/qiodevice.h

@@ -167,6 +167,7 @@ protected:
 #endif
     virtual qint64 readData(char *data, qint64 maxlen) = 0;
     virtual qint64 readLineData(char *data, qint64 maxlen);
+    virtual qint64 skipData(qint64 maxSize);
     virtual qint64 writeData(const char *data, qint64 len) = 0;
 
     void setOpenMode(OpenMode openMode);

src/corelib/io/qiodevice_p.h

@@ -175,8 +175,6 @@ public:
     virtual qint64 peek(char *data, qint64 maxSize);
     virtual QByteArray peek(qint64 maxSize);
     qint64 skipByReading(qint64 maxSize);
-    // ### Qt6: consider replacing with a protected virtual QIODevice::skipData().
-    virtual qint64 skip(qint64 maxSize);
 
 #ifdef QT_NO_QOBJECT
     QIODevice *q_ptr;

src/network/socket/qabstractsocket.cpp

@@ -1361,20 +1361,23 @@ void QAbstractSocketPrivate::fetchConnectionParameters()
     emit q->connected();
 }
 
-/*! \internal
+/*! \reimp
 */
-qint64 QAbstractSocketPrivate::skip(qint64 maxSize)
+qint64 QAbstractSocket::skipData(qint64 maxSize)
 {
+    Q_D(const QAbstractSocket);
+
     // if we're not connected, return -1 indicating EOF
-    if (!socketEngine || !socketEngine->isValid() || state != QAbstractSocket::ConnectedState)
+    if (!d->socketEngine || !d->socketEngine->isValid()
+        || d->state != QAbstractSocket::ConnectedState)
         return -1;
 
     // Caller, QIODevice::skip(), has ensured buffer is empty. So, wait
     // for more data in buffered mode.
-    if (isBuffered)
+    if (d->isBuffered)
         return 0;
 
-    return QIODevicePrivate::skip(maxSize);
+    return QIODevice::skipData(maxSize);
 }
 
 void QAbstractSocketPrivate::pauseSocketNotifiers(QAbstractSocket *socket)

src/network/socket/qabstractsocket.h

@@ -216,6 +216,7 @@ Q_SIGNALS:
 protected:
     qint64 readData(char *data, qint64 maxlen) override;
     qint64 readLineData(char *data, qint64 maxlen) override;
+    qint64 skipData(qint64 maxSize) override;
     qint64 writeData(const char *data, qint64 len) override;
 
     void setSocketState(SocketState state);

src/network/socket/qabstractsocket_p.h

@@ -71,9 +71,6 @@ public:
     QAbstractSocketPrivate();
     virtual ~QAbstractSocketPrivate();
 
-    // from QIODevicePrivate
-    qint64 skip(qint64 maxSize) override;
-
     // from QAbstractSocketEngineReceiver
     inline void readNotification() override { canReadNotification(); }
     inline void writeNotification() override { canWriteNotification(); }

src/network/socket/qlocalsocket.cpp

@@ -151,6 +151,11 @@ QT_BEGIN_NAMESPACE
     \reimp
 */
 
+/*!
+    \fn qint64 QLocalSocket::skipData(qint64 maxSize)
+    \reimp
+*/
+
 /*!
     \fn qint64 QLocalSocket::writeData(const char *data, qint64 c)
     \reimp

src/network/socket/qlocalsocket.h

@@ -122,6 +122,7 @@ Q_SIGNALS:
 
 protected:
     virtual qint64 readData(char*, qint64) override;
+    qint64 skipData(qint64 maxSize) override;
     virtual qint64 writeData(const char*, qint64) override;
 
 private:

src/network/socket/qlocalsocket_p.h

@@ -120,7 +120,6 @@ public:
     void init();
 
 #if defined(QT_LOCALSOCKET_TCP)
-    qint64 skip(qint64 maxSize) override;
     QLocalUnixSocket* tcpSocket;
     bool ownsTcpSocket;
     void setSocket(QLocalUnixSocket*);
@@ -139,7 +138,6 @@ public:
     QWindowsPipeReader *pipeReader;
     QLocalSocket::LocalSocketError error;
 #else
-    qint64 skip(qint64 maxSize) override;
     QLocalUnixSocket unixSocket;
     QString generateErrorString(QLocalSocket::LocalSocketError, const QString &function) const;
     void setErrorAndEmit(QLocalSocket::LocalSocketError, const QString &function);

src/network/socket/qlocalsocket_tcp.cpp

@@ -83,11 +83,6 @@ void QLocalSocketPrivate::setSocket(QLocalUnixSocket* socket)
     tcpSocket->setParent(q);
 }
 
-qint64 QLocalSocketPrivate::skip(qint64 maxSize)
-{
-    return tcpSocket->skip(maxSize);
-}
-
 void QLocalSocketPrivate::_q_errorOccurred(QAbstractSocket::SocketError socketError)
 {
     Q_Q(QLocalSocket);
@@ -306,6 +301,11 @@ qint64 QLocalSocket::readData(char *data, qint64 c)
     return d->tcpSocket->read(data, c);
 }
 
+qint64 QLocalSocket::skipData(qint64 maxSize)
+{
+    return d_func()->tcpSocket->skip(maxSize);
+}
+
 qint64 QLocalSocket::writeData(const char *data, qint64 c)
 {
     Q_D(QLocalSocket);

src/network/socket/qlocalsocket_unix.cpp

@@ -87,11 +87,6 @@ void QLocalSocketPrivate::init()
     unixSocket.setParent(q);
 }
 
-qint64 QLocalSocketPrivate::skip(qint64 maxSize)
-{
-    return unixSocket.skip(maxSize);
-}
-
 void QLocalSocketPrivate::_q_errorOccurred(QAbstractSocket::SocketError socketError)
 {
     Q_Q(QLocalSocket);
@@ -398,6 +393,11 @@ qint64 QLocalSocket::readData(char *data, qint64 c)
     return d->unixSocket.read(data, c);
 }
 
+qint64 QLocalSocket::skipData(qint64 maxSize)
+{
+    return d_func()->unixSocket.skip(maxSize);
+}
+
 qint64 QLocalSocket::writeData(const char *data, qint64 c)
 {
     Q_D(QLocalSocket);

src/network/socket/qlocalsocket_win.cpp

@@ -204,6 +204,11 @@ qint64 QLocalSocket::readData(char *data, qint64 maxSize)
     }
 }
 
+qint64 QLocalSocket::skipData(qint64 maxSize)
+{
+    return QIODevice::skipData(maxSize);
+}
+
 qint64 QLocalSocket::writeData(const char *data, qint64 len)
 {
     Q_D(QLocalSocket);

src/network/ssl/qsslsocket.cpp

@@ -2541,17 +2541,19 @@ QByteArray QSslSocketPrivate::peek(qint64 maxSize)
 }
 
 /*!
-    \internal
+    \reimp
 */
-qint64 QSslSocketPrivate::skip(qint64 maxSize)
+qint64 QSslSocket::skipData(qint64 maxSize)
 {
-    if (mode == QSslSocket::UnencryptedMode && !autoStartHandshake)
-        return plainSocket->skip(maxSize);
+    Q_D(QSslSocket);
+
+    if (d->mode == QSslSocket::UnencryptedMode && !d->autoStartHandshake)
+        return d->plainSocket->skip(maxSize);
 
     // In encrypted mode, the SSL backend writes decrypted data directly into the
     // QIODevice's read buffer. As this buffer is always emptied by the caller,
     // we need to wait for more incoming data.
-    return (state == QAbstractSocket::ConnectedState) ? Q_INT64_C(0) : Q_INT64_C(-1);
+    return (d->state == QAbstractSocket::ConnectedState) ? Q_INT64_C(0) : Q_INT64_C(-1);
 }
 
 /*!

src/network/ssl/qsslsocket.h

@@ -186,6 +186,7 @@ Q_SIGNALS:
 
 protected:
     qint64 readData(char *data, qint64 maxlen) override;
+    qint64 skipData(qint64 maxSize) override;
     qint64 writeData(const char *data, qint64 len) override;
 
 private:

src/network/ssl/qsslsocket_p.h

@@ -190,7 +190,6 @@ public:
 
     virtual qint64 peek(char *data, qint64 maxSize) override;
     virtual QByteArray peek(qint64 maxSize) override;
-    qint64 skip(qint64 maxSize) override;
     bool flush() override;
 
     // Platform specific functions