Revert "adding debugging messages to QtCore"

This reverts commit ed174ba.

Author: tamaskenezlego

src/corelib/io/qnoncontiguousbytedevice.cpp

@@ -99,7 +99,6 @@ 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,7 +15,6 @@
 
 #include <algorithm>
 #include <memory>
-#include <thread>
 
 QT_BEGIN_NAMESPACE
 
@@ -44,7 +43,6 @@ 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,
@@ -292,7 +290,6 @@ 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);
 }
 
@@ -313,7 +310,6 @@ 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);
@@ -330,7 +326,6 @@ 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);
 }
 
@@ -351,7 +346,6 @@ 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) {
@@ -365,11 +359,8 @@ 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();
@@ -405,22 +396,17 @@ 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);
@@ -431,7 +417,6 @@ void QHttp2Stream::internalSendDATA()
             m_uploadByteDevice->advanceReadPointer(bytesToWrite);
 
             bytesWritten += bytesToWrite;
-            printf("bytesWritten: %d\n", (int)bytesWritten);
 
             m_sendWindow -= bytesToWrite;
             Q_ASSERT(m_sendWindow >= 0);
@@ -450,47 +435,26 @@ 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);
-    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 || (!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 ");
         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.
@@ -501,17 +465,13 @@ void QHttp2Stream::internalSendDATA()
         }
         finishSendDATA();
     } else if (isUploadBlocked()) {
-        printf("Upload is blocked\n");
-        //qDebug(qHttp2ConnectionLog, "[%p] stream %u, upload blocked", connection, m_streamID);
+        qCDebug(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);
 
@@ -633,9 +593,7 @@ 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"));
@@ -736,7 +694,6 @@ 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));
     }
@@ -755,12 +712,6 @@ 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,7 +171,6 @@ 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;
@@ -182,7 +181,6 @@ QHttpThreadDelegate::~QHttpThreadDelegate()
     if (connections.hasLocalData() && !cacheKey.isEmpty()) {
         connections.localData()->releaseEntry(cacheKey);
     }
-    printf("~QHttpThreadDelegate DONE\n");
 }
 
 

src/network/access/qhttpthreaddelegate_p.h

@@ -218,7 +218,6 @@ 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;
@@ -264,8 +263,6 @@ 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.
@@ -277,9 +274,6 @@ 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,6 +511,13 @@ 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"
@@ -1597,7 +1597,6 @@ 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