adding debugging messages to QtCore

Author: tamaskenezlego

src/corelib/io/qnoncontiguousbytedevice.cpp

@@ -99,6 +99,7 @@ QNonContiguousByteDevice::QNonContiguousByteDevice() : QObject((QObject*)nullptr
 
 QNonContiguousByteDevice::~QNonContiguousByteDevice()
 {
+    printf("~QNonContiguousByteDevice %p (%s)\n", (void*)this, typeid(*this).name());
 }
 
 QNonContiguousByteDeviceByteArrayImpl::QNonContiguousByteDeviceByteArrayImpl(QByteArray ba)

src/network/access/qhttp2connection.cpp

@@ -15,6 +15,7 @@
 
 #include <algorithm>
 #include <memory>
+#include <thread>
 
 QT_BEGIN_NAMESPACE
 
@@ -43,6 +44,7 @@ QHttp2Stream::QHttp2Stream(QHttp2Connection *connection, quint32 streamID) noexc
 }
 
 QHttp2Stream::~QHttp2Stream() noexcept {
+    printf("~QHttp2Stream\n");
     if (auto *connection = getConnection()) {
         if (m_state == State::Open || m_state == State::HalfClosedRemote) {
             qCDebug(qHttp2ConnectionLog, "[%p] stream %u, destroyed while still open", connection,
@@ -290,6 +292,7 @@ bool QHttp2Stream::sendDATA(const QByteArray &payload, bool endStream)
     auto *byteDevice = QNonContiguousByteDeviceFactory::create(payload);
     m_owningByteDevice = true;
     byteDevice->setParent(this);
+    printf("QHttp2Stream::sendDATA, byteDevice = %p\n", (void*)byteDevice);
     return sendDATA(byteDevice, endStream);
 }
 
@@ -310,6 +313,7 @@ bool QHttp2Stream::sendDATA(const QByteArray &payload, bool endStream)
 */
 bool QHttp2Stream::sendDATA(QIODevice *device, bool endStream)
 {
+    printf("QHttp2Stream::sendDATA(QIODevice *%p, bool %d)\n", (void*)device, endStream);
     Q_ASSERT(!m_uploadDevice);
     Q_ASSERT(!m_uploadByteDevice);
     Q_ASSERT(device);
@@ -326,6 +330,7 @@ bool QHttp2Stream::sendDATA(QIODevice *device, bool endStream)
     m_owningByteDevice = true;
     byteDevice->setParent(this);
     m_uploadDevice = device;
+    printf("QHttp2Stream::sendDATA, m_uploadDevice = %p, byteDevice = %p\n", (void*)device, (void*)byteDevice);
     return sendDATA(byteDevice, endStream);
 }
 
@@ -346,6 +351,7 @@ bool QHttp2Stream::sendDATA(QIODevice *device, bool endStream)
 */
 bool QHttp2Stream::sendDATA(QNonContiguousByteDevice *device, bool endStream)
 {
+    printf("QHttp2Stream::sendDATA(QNonContiguousByteDevice *%p, bool %d)\n", (void*)device, endStream);
     Q_ASSERT(!m_uploadByteDevice);
     Q_ASSERT(device);
     if (m_state != State::Open && m_state != State::HalfClosedRemote) {
@@ -359,8 +365,11 @@ bool QHttp2Stream::sendDATA(QNonContiguousByteDevice *device, bool endStream)
             getConnection(), m_streamID, device);
     m_uploadByteDevice = device;
     m_endStreamAfterDATA = endStream;
+    printf("QHttp2Stream::sendDATA, m_uploadByteDevice = %p\n", (void*)device);
     connect(m_uploadByteDevice, &QNonContiguousByteDevice::readyRead, this,
             &QHttp2Stream::maybeResumeUpload);
+    auto functor = [p=m_uploadByteDevice](QObject*o){printf("m_uploadByteDevice %p destroyed %p\n",(void*)p, (void*)o);};
+    QObject::connect(m_uploadByteDevice, &QObject::destroyed, m_uploadByteDevice, functor);
     connect(m_uploadByteDevice, &QObject::destroyed, this, &QHttp2Stream::uploadDeviceDestroyed);
 
     internalSendDATA();
@@ -396,17 +405,22 @@ void QHttp2Stream::internalSendDATA()
     };
 
     bool sentEND_STREAM = false;
+    bool enteredFirstWhile = false;
+    bool enteredSecondWhile = false;
     while (remainingWindowSize && deviceCanRead()) {
+        enteredFirstWhile = true;
         quint32 bytesWritten = 0;
         qint32 remainingBytesInFrame = qint32(connection->maxFrameSize);
         frameWriter.start(FrameType::DATA, FrameFlag::EMPTY, streamID());
 
         while (remainingWindowSize && deviceCanRead() && remainingBytesInFrame) {
+            enteredSecondWhile = true;
             const qint32 maxToWrite = std::min(remainingWindowSize, remainingBytesInFrame);
 
             qint64 outBytesAvail = 0;
             const char *readPointer = m_uploadByteDevice->readPointer(maxToWrite, outBytesAvail);
             if (!readPointer || outBytesAvail <= 0) {
+                printf("not writing, readPointer: %s, outBytesAvail: %d\n", readPointer?"notnull":"null", (int)outBytesAvail);
                 qCDebug(qHttp2ConnectionLog,
                         "[%p] stream %u, cannot write data, device (%p) has %lld bytes available",
                         connection, m_streamID, m_uploadByteDevice, outBytesAvail);
@@ -417,6 +431,7 @@ void QHttp2Stream::internalSendDATA()
             m_uploadByteDevice->advanceReadPointer(bytesToWrite);
 
             bytesWritten += bytesToWrite;
+            printf("bytesWritten: %d\n", (int)bytesWritten);
 
             m_sendWindow -= bytesToWrite;
             Q_ASSERT(m_sendWindow >= 0);
@@ -435,26 +450,47 @@ void QHttp2Stream::internalSendDATA()
             frameWriter.addFlag(FrameFlag::END_STREAM);
         }
         if (!frameWriter.write(*socket)) {
+            printf("failed to write to socket\n");
             qCDebug(qHttp2ConnectionLog, "[%p] stream %u, failed to write to socket", connection,
                     m_streamID);
             return finishWithError(INTERNAL_ERROR, "failed to write to socket"_L1);
         }
 
         totalBytesWritten += bytesWritten;
     }
+    if(!enteredFirstWhile){
+        printf("Did not enter first while, remainingWindowSize: %d, deviceCanRead(): %d\n", (int)remainingWindowSize, deviceCanRead());
+    } else if(!enteredSecondWhile) {
+        printf("Did not enter second while, remainingWindowSize: %d, deviceCanRead(): %d, remainingBytesInFrame: %d\n", (int)remainingWindowSize, deviceCanRead(), int(connection->maxFrameSize));
+    }
 
     qCDebug(qHttp2ConnectionLog,
             "[%p] stream %u, wrote %lld bytes total, if the device is not exhausted, we'll write "
             "more later. Remaining window size: %d",
             connection, m_streamID, totalBytesWritten, remainingWindowSize);
 
+    printf("emit totalBytesWritten(%d)\n", (int)totalBytesWritten);
     emit bytesWritten(totalBytesWritten);
-    if (sentEND_STREAM || (!deviceCanRead() && m_uploadByteDevice->atEnd())) {
-        qCDebug(qHttp2ConnectionLog,
-                "[%p] stream %u, exhausted device %p, sent END_STREAM? %d, %ssending end stream "
-                "after DATA",
-                connection, m_streamID, m_uploadByteDevice, sentEND_STREAM,
-                m_endStreamAfterDATA ? "" : "not ");
+    printf("sentEND_STREAM: %d\n", sentEND_STREAM);
+    bool dcr;
+    bool ae;
+    if(!sentEND_STREAM) {
+        dcr = deviceCanRead();
+        printf("deviceCanRead(): %d\n", dcr);
+        if(!dcr) {
+            ae = m_uploadByteDevice->atEnd();
+            printf("m_uploadByteDevice->atEnd(): %d\n", ae);
+        }
+    }
+    if (sentEND_STREAM || (!dcr && ae)) {
+        //qDebug(qHttp2ConnectionLog,
+        //        "[%p] stream %u, exhausted device %p, sent END_STREAM? %d, %ssending end stream "
+        //        "after DATA",
+        //        connection, m_streamID, m_uploadByteDevice, sentEND_STREAM,
+        //        m_endStreamAfterDATA ? "" : "not ");
+        if(!sentEND_STREAM) {
+            printf("m_endStreamAfterDATA: %d\n", m_endStreamAfterDATA);
+        }
         if (!sentEND_STREAM && m_endStreamAfterDATA) {
             // We need to send an empty DATA frame with END_STREAM since we
             // have exhausted the device, but we haven't sent END_STREAM yet.
@@ -465,13 +501,17 @@ void QHttp2Stream::internalSendDATA()
         }
         finishSendDATA();
     } else if (isUploadBlocked()) {
-        qCDebug(qHttp2ConnectionLog, "[%p] stream %u, upload blocked", connection, m_streamID);
+        printf("Upload is blocked\n");
+        //qDebug(qHttp2ConnectionLog, "[%p] stream %u, upload blocked", connection, m_streamID);
         emit uploadBlocked();
+    } else {
+        printf("Upload is not blocked\n");
     }
 }
 
 void QHttp2Stream::finishSendDATA()
 {
+    printf("QHttp2Stream::finishSendDATA()\n");
     if (m_endStreamAfterDATA)
         transitionState(StateTransition::CloseLocal);
 
@@ -593,7 +633,9 @@ void QHttp2Stream::sendWINDOW_UPDATE(quint32 delta)
 
 void QHttp2Stream::uploadDeviceDestroyed()
 {
+    printf("uploadDeviceDestroyed\n");
     if (isUploadingDATA()) {
+        printf("isUploadingDATA is true\n");
         // We're in the middle of sending DATA frames, we need to abort
         // the stream.
         streamError(CANCEL, QLatin1String("Upload device destroyed while uploading"));
@@ -694,6 +736,7 @@ void QHttp2Stream::handleDATA(const Frame &inboundFrame)
                             inboundFrame.dataSize());
         if (endStream)
             transitionState(StateTransition::CloseRemote);
+        printf("dataReceived: `%s` endStream: %d\n", fragment.toStdString().c_str(), endStream);
         emit dataReceived(fragment, endStream);
         m_downloadBuffer.append(std::move(fragment));
     }
@@ -712,6 +755,12 @@ void QHttp2Stream::handleHEADERS(Http2::FrameFlags frameFlags, const HPack::Http
     if (endStream)
         transitionState(StateTransition::CloseRemote);
     if (!headers.empty()) {
+        for(auto&h:headers){
+            if(            h.name.toStdString() == ":status"){
+                printf("header ':status' %s received\n", h.value.toStdString().c_str());
+                break;
+            }
+        }
         m_headers.insert(m_headers.end(), headers.begin(), headers.end());
         emit headersUpdated();
     }

src/network/access/qhttpthreaddelegate.cpp

@@ -1,7 +1,7 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-//#define QHTTPTHREADDELEGATE_DEBUG
+#define QHTTPTHREADDELEGATE_DEBUG
 #include "qhttpthreaddelegate_p.h"
 
 #include <QThread>
@@ -171,6 +171,7 @@ QThreadStorage<QNetworkAccessCache *> QHttpThreadDelegate::connections;
 
 QHttpThreadDelegate::~QHttpThreadDelegate()
 {
+    printf("~QHttpThreadDelegate\n");
     // It could be that the main thread has asked us to shut down, so we need to delete the HTTP reply
     if (httpReply) {
         delete httpReply;
@@ -181,6 +182,7 @@ QHttpThreadDelegate::~QHttpThreadDelegate()
     if (connections.hasLocalData() && !cacheKey.isEmpty()) {
         connections.localData()->releaseEntry(cacheKey);
     }
+    printf("~QHttpThreadDelegate DONE\n");
 }
 
 

src/network/access/qhttpthreaddelegate_p.h

@@ -218,6 +218,7 @@ class QNonContiguousByteDeviceThreadForwardImpl : public QNonContiguousByteDevic
         m_pos += a;
 
         // To main thread to inform about our state. The m_pos will be sent as a sanity check.
+        printf("QNonContiguousByteDeviceThreadForwardImpl::advanceReadPointer, emit processedData(%d, %d)", (int)m_pos, (int)a);
         emit processedData(m_pos, a);
 
         return true;
@@ -263,6 +264,8 @@ public slots:
     // From user thread:
     void haveDataSlot(qint64 pos, const QByteArray &dataArray, bool dataAtEnd, qint64 dataSize)
     {
+        printf("QNonContiguousByteDeviceThreadForwardImpl::haveDataSlot(%d, dataArray with size %d, %d, %d)\n",
+               (int)pos, (int)dataArray.size(), dataAtEnd, (int)dataSize);
         if (pos != m_pos) {
             // Sometimes when re-sending a request in the qhttpnetwork* layer there is a pending haveData from the
             // user thread on the way to us. We need to ignore it since it is the data for the wrong(later) chunk.
@@ -274,6 +277,9 @@ public slots:
         m_data = const_cast<char*>(m_dataArray.constData());
         m_amount = dataArray.size();
 
+        if(!m_atEnd && dataAtEnd) {
+            printf("m_atEnd: false -> true\n");
+        }
         m_atEnd = dataAtEnd;
         m_size = dataSize;
 

src/network/access/qnetworkaccesscachebackend.cpp

@@ -1,7 +1,7 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-//#define QNETWORKACCESSCACHEBACKEND_DEBUG
+#define QNETWORKACCESSCACHEBACKEND_DEBUG
 
 #include "qnetworkaccesscachebackend_p.h"
 #include "qabstractnetworkcache.h"

src/network/access/qnetworkdiskcache.cpp

@@ -1,7 +1,7 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-//#define QNETWORKDISKCACHE_DEBUG
+#define QNETWORKDISKCACHE_DEBUG
 
 
 #include "qnetworkdiskcache.h"
@@ -511,13 +511,6 @@ qint64 QNetworkDiskCache::expire()
         if (totalSize < goal)
             break;
     }
-#if defined(QNETWORKDISKCACHE_DEBUG)
-    if (removedFiles > 0) {
-        qDebug() << "QNetworkDiskCache::expire()"
-                << "Removed:" << removedFiles
-                << "Kept:" << cacheItems.count() - removedFiles;
-    }
-#endif
     return totalSize;
 }
 

src/network/access/qnetworkreplyhttpimpl.cpp

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 // Qt-Security score:critical reason:network-protocol
 
-//#define QNETWORKACCESSHTTPBACKEND_DEBUG
+#define QNETWORKACCESSHTTPBACKEND_DEBUG
 
 #include "qnetworkreplyhttpimpl_p.h"
 #include "qnetworkaccessmanager_p.h"
@@ -1588,6 +1588,7 @@ void QNetworkReplyHttpImplPrivate::sentUploadDataSlot(qint64 pos, qint64 amount)
         error(QNetworkReply::UnknownNetworkError, QString());
         return;
     }
+    printf("QNetworkReplyHttpImplPrivate::sentUploadDataSlot(%d, %d)\n",(int)pos,(int)amount);
     uploadByteDevice->advanceReadPointer(amount);
     uploadByteDevicePosition += amount;
 }

src/network/socket/qtcpsocket.cpp

@@ -1,7 +1,7 @@
 // Copyright (C) 2016 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-//#define QTCPSOCKET_DEBUG
+#define QTCPSOCKET_DEBUG
 
 /*!
     \class QTcpSocket