#include <qnetworkreplyimpl_p.h>

Inheritance diagram for QNetworkReplyImplPrivate:

Public Types
enum	InternalNotifications { NotifyDownstreamReadyWrite, NotifyCloseDownstreamChannel, NotifyCopyFinished }

typedef QQueue< InternalNotifications >	NotificationQueue

enum	State { Idle, Buffering, Working, Finished, Aborted, WaitingForSession, Reconnecting }

Public Types inherited from QIODevicePrivate
enum	AccessMode { Unset, Sequential, RandomAccess }

Public Types inherited from QObjectPrivate
typedef void(*	StaticMetaCallFunction) (QObject , QMetaObject::Call, int, void *)

Public Types inherited from QNetworkHeadersPrivate
typedef QHash< QNetworkRequest::Attribute, QVariant >	AttributesMap

typedef QHash< QNetworkRequest::KnownHeaders, QVariant >	CookedHeadersMap

typedef QPair< QByteArray, QByteArray >	RawHeaderPair

typedef QList< RawHeaderPair >	RawHeadersList

Public Functions
void	_q_bufferOutgoingData ()

void	_q_bufferOutgoingDataFinished ()

void	_q_cacheDestroyed ()

void	_q_copyReadChannelFinished ()

void	_q_copyReadyRead ()

void	_q_networkSessionConnected ()

void	_q_networkSessionFailed ()

void	_q_sourceReadChannelFinished ()

void	_q_sourceReadyRead ()

void	_q_startOperation ()

void	appendDownstreamData (QByteDataBuffer &data)

void	appendDownstreamData (QIODevice *data)

void	appendDownstreamData (const QByteArray &data)

void	appendDownstreamDataDownloadBuffer (qint64, qint64)

void	appendDownstreamDataSignalEmissions ()

void	backendNotify (InternalNotifications notification)

void	completeCacheSave ()

void	consume (qint64 count)

void	createCache ()

void	emitUploadProgress (qint64 bytesSent, qint64 bytesTotal)

void	error (QNetworkReply::NetworkError code, const QString &errorString)

void	finished ()

char *	getDownloadBuffer (qint64 size)

void	handleNotifications ()

void	initCacheSaveDevice ()

bool	isCachingEnabled () const

void	metaDataChanged ()

bool	migrateBackend ()

QAbstractNetworkCache *	networkCache () const

qint64	nextDownstreamBlockSize () const

void	pauseNotificationHandling ()

	QNetworkReplyImplPrivate ()

void	redirectionRequested (const QUrl &target)

void	resumeNotificationHandling ()

void	setCachingEnabled (bool enable)

void	setDownloadBuffer (QSharedPointer< char > sp, qint64 size)

void	setup (QNetworkAccessManager::Operation op, const QNetworkRequest &request, QIODevice *outgoingData)

void	sslErrors (const QList< QSslError > &errors)

Public Functions inherited from QNetworkReplyPrivate
	QNetworkReplyPrivate ()

Public Functions inherited from QIODevicePrivate
bool	isSequential () const

virtual qint64	peek (char *data, qint64 maxSize)

virtual QByteArray	peek (qint64 maxSize)

virtual bool	putCharHelper (char c)

	QIODevicePrivate ()

virtual	~QIODevicePrivate ()

Public Functions inherited from QObjectPrivate
void	_q_reregisterTimers (void *pointer)

void	addConnection (int signal, Connection *c)

void	cleanConnectionLists ()

void	connectNotify (const char *signal)

void	deleteChildren ()

void	disconnectNotify (const char *signal)

bool	isSender (const QObject receiver, const char signal) const

bool	isSignalConnected (uint signalIdx) const
	Returns true if the signal with index signal_index from object sender is connected. More...

void	moveToThread_helper ()

	QObjectPrivate (int version=QObjectPrivateVersion)

QObjectList	receiverList (const char *signal) const

QObjectList	senderList () const

void	setParent_helper (QObject *)

void	setThreadData_helper (QThreadData currentData, QThreadData targetData)

int	signalIndex (const char *signalName) const
	Returns the signal index used in the internal connectionLists vector. More...

virtual	~QObjectPrivate ()

Public Functions inherited from QObjectData
virtual	~QObjectData ()=0

Public Functions inherited from QNetworkHeadersPrivate
RawHeadersList	allRawHeaders () const

RawHeadersList::ConstIterator	findRawHeader (const QByteArray &key) const

QList< QByteArray >	rawHeadersKeys () const

void	setAllRawHeaders (const RawHeadersList &list)
	Sets the internal raw headers list to match list. More...

void	setCookedHeader (QNetworkRequest::KnownHeaders header, const QVariant &value)

void	setRawHeader (const QByteArray &key, const QByteArray &value)

Public Variables
QNetworkAccessBackend *	backend

qint64	bytesDownloaded

qint64	bytesUploaded

bool	cacheEnabled

QIODevice *	cacheSaveDevice

QIODevice *	copyDevice

char *	downloadBuffer

qint64	downloadBufferCurrentSize

qint64	downloadBufferMaximumSize

QSharedPointer< char >	downloadBufferPointer

qint64	downloadBufferReadPosition

QString	httpReasonPhrase

int	httpStatusCode

qint64	lastBytesDownloaded

QNetworkProxy	lastProxyAuthentication

bool	notificationHandlingPaused

QIODevice *	outgoingData

QSharedPointer< QRingBuffer >	outgoingDataBuffer

NotificationQueue	pendingNotifications

qint64	preMigrationDownloaded

QList< QNetworkProxy >	proxyList

QByteDataBuffer	readBuffer

State	state

QUrl	urlForLastAuthentication

Public Variables inherited from QNetworkReplyPrivate
QNetworkReply::NetworkError	errorCode

bool	isFinished

QPointer< QNetworkAccessManager >	manager

QNetworkAccessManager::Operation	operation

qint64	readBufferMaxSize

QNetworkRequest	request

QUrl	url

Public Variables inherited from QIODevicePrivate
AccessMode	accessMode

bool	baseReadLineDataCalled

QIODevicePrivateLinearBuffer	buffer

qint64	devicePos

QString	errorString

bool	firstRead

QIODevice::OpenMode	openMode

qint64 *	pDevicePos

qint64	pos

qint64 *	pPos

qint64	seqDumpPos

Public Variables inherited from QObjectPrivate
union {
QObject * currentChildBeingDeleted

QAbstractDeclarativeData * declarativeData

};

quint32	connectedSignals [2]

QObjectConnectionListVector *	connectionLists

Sender *	currentSender

QList< QPointer< QObject > >	eventFilters

ExtraData *	extraData

QString	objectName

Connection *	senders

QAtomicPointer< QtSharedPointer::ExternalRefCountData >	sharedRefcount

QThreadData *	threadData

void *	unused

Public Variables inherited from QObjectData
uint	blockSig: 1

QObjectList	children

uint	hasGuards: 1

uint	inEventHandler: 1

uint	inThreadChangeEvent: 1

uint	isWidget: 1

QMetaObject *	metaObject

uint	ownObjectName: 1

QObject *	parent

uint	pendTimer: 1

int	postedEvents

QObject *	q_ptr

uint	receiveChildEvents: 1

uint	sendChildEvents: 1

uint	unused: 22

uint	wasDeleted: 1

Public Variables inherited from QNetworkHeadersPrivate
AttributesMap	attributes

CookedHeadersMap	cookedHeaders

QWeakPointer< QObject >	originatingObject

RawHeadersList	rawHeaders

Additional Inherited Members
Static Public Functions inherited from QNetworkReplyPrivate
static void	setManager (QNetworkReply reply, QNetworkAccessManager manager)

Static Public Functions inherited from QObjectPrivate
static void	clearGuards (QObject *)

static QObjectPrivate *	get (QObject *o)

static void	resetCurrentSender (QObject receiver, Sender currentSender, Sender *previousSender)

static Sender *	setCurrentSender (QObject receiver, Sender sender)

static void	signalSignature (const QMetaMethod &signal, QVarLengthArray< char > *result)

Static Public Functions inherited from QNetworkHeadersPrivate
static QDateTime	fromHttpDate (const QByteArray &value)

static QByteArray	toHttpDate (const QDateTime &dt)

Detailed Description

Definition at line 110 of file qnetworkreplyimpl_p.h.

Typedefs

◆ NotificationQueue

typedef QQueue<InternalNotifications> QNetworkReplyImplPrivate::NotificationQueue

Definition at line 129 of file qnetworkreplyimpl_p.h.

Enumerations

◆ InternalNotifications

enum QNetworkReplyImplPrivate::InternalNotifications

Enumerator
NotifyDownstreamReadyWrite
NotifyCloseDownstreamChannel
NotifyCopyFinished

Definition at line 113 of file qnetworkreplyimpl_p.h.

                                {
         NotifyDownstreamReadyWrite,
         NotifyCloseDownstreamChannel,
         NotifyCopyFinished
     };

◆ State

enum QNetworkReplyImplPrivate::State

Enumerator
Idle
Buffering
Working
Finished
Aborted
WaitingForSession
Reconnecting

Definition at line 119 of file qnetworkreplyimpl_p.h.

                {
         Idle,               // The reply is idle.
         Buffering,          // The reply is buffering outgoing data.
         Working,            // The reply is uploading/downloading data.
         Finished,           // The reply has finished.
         Aborted,            // The reply has been aborted.
         WaitingForSession,  // The reply is waiting for the session to open before connecting.
         Reconnecting        // The reply will reconnect to once roaming has completed.
     };

Constructors and Destructors

◆ QNetworkReplyImplPrivate()

QNetworkReplyImplPrivate::QNetworkReplyImplPrivate ( )

inline

Definition at line 59 of file qnetworkreplyimpl.cpp.

     : backend(0), outgoingData(0),
       copyDevice(0),
       cacheEnabled(false), cacheSaveDevice(0),
       notificationHandlingPaused(false),
       bytesDownloaded(0), lastBytesDownloaded(-1), bytesUploaded(-1), preMigrationDownloaded(-1),
       httpStatusCode(0),
       state(Idle)
       , downloadBufferReadPosition(0)
       , downloadBufferCurrentSize(0)
       , downloadBufferMaximumSize(0)
       , downloadBuffer(0)
 {
 }

Functions

◆ _q_bufferOutgoingData()

void QNetworkReplyImplPrivate::_q_bufferOutgoingData ( )

Definition at line 220 of file qnetworkreplyimpl.cpp.

Referenced by _q_bufferOutgoingDataFinished().

 {
     Q_Q(QNetworkReplyImpl);
 
     if (!outgoingDataBuffer) {
         // first call, create our buffer
         outgoingDataBuffer = QSharedPointer<QRingBuffer>(new QRingBuffer());
 
         QObject::connect(outgoingData, SIGNAL(readyRead()), q, SLOT(_q_bufferOutgoingData()));
         QObject::connect(outgoingData, SIGNAL(readChannelFinished()), q, SLOT(_q_bufferOutgoingDataFinished()));
     }
 
     qint64 bytesBuffered = 0;
     qint64 bytesToBuffer = 0;
 
     // read data into our buffer
     forever {
         bytesToBuffer = outgoingData->bytesAvailable();
         // unknown? just try 2 kB, this also ensures we always try to read the EOF
         if (bytesToBuffer <= 0)
             bytesToBuffer = 2*1024;
 
         char *dst = outgoingDataBuffer->reserve(bytesToBuffer);
         bytesBuffered = outgoingData->read(dst, bytesToBuffer);
 
         if (bytesBuffered == -1) {
             // EOF has been reached.
             outgoingDataBuffer->chop(bytesToBuffer);
 
             _q_bufferOutgoingDataFinished();
             break;
         } else if (bytesBuffered == 0) {
             // nothing read right now, just wait until we get called again
             outgoingDataBuffer->chop(bytesToBuffer);
 
             break;
         } else {
             // don't break, try to read() again
             outgoingDataBuffer->chop(bytesToBuffer - bytesBuffered);
         }
     }
 }

◆ _q_bufferOutgoingDataFinished()

void QNetworkReplyImplPrivate::_q_bufferOutgoingDataFinished ( )

Definition at line 203 of file qnetworkreplyimpl.cpp.

Referenced by _q_bufferOutgoingData().

 {
     Q_Q(QNetworkReplyImpl);
 
     // make sure this is only called once, ever.
     //_q_bufferOutgoingData may call it or the readChannelFinished emission
     if (state != Buffering)
         return;
 
     // disconnect signals
     QObject::disconnect(outgoingData, SIGNAL(readyRead()), q, SLOT(_q_bufferOutgoingData()));
     QObject::disconnect(outgoingData, SIGNAL(readChannelFinished()), q, SLOT(_q_bufferOutgoingDataFinished()));
 
     // finally, start the request
     QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
 }

◆ _q_cacheDestroyed()

void QNetworkReplyImplPrivate::_q_cacheDestroyed ( )

Definition at line 501 of file qnetworkreplyimpl.cpp.

Referenced by completeCacheSave(), initCacheSaveDevice(), and setCachingEnabled().

 {
     //destruction of cache invalidates cacheSaveDevice
     cacheSaveDevice = 0;
     cacheEnabled = false;
 }

◆ _q_copyReadChannelFinished()

void QNetworkReplyImplPrivate::_q_copyReadChannelFinished ( )

Definition at line 198 of file qnetworkreplyimpl.cpp.

Referenced by appendDownstreamData().

 {
     _q_copyReadyRead();
 }

◆ _q_copyReadyRead()

void QNetworkReplyImplPrivate::_q_copyReadyRead ( )

Definition at line 140 of file qnetworkreplyimpl.cpp.

Referenced by _q_copyReadChannelFinished(), appendDownstreamData(), and handleNotifications().

 {
     Q_Q(QNetworkReplyImpl);
     if (state != Working)
         return;
     if (!copyDevice || !q->isOpen())
         return;
 
     // FIXME Optimize to use download buffer if it is a QBuffer.
     // Needs to be done where sendCacheContents() (?) of HTTP is emitting
     // metaDataChanged ?
 
     forever {
         qint64 bytesToRead = nextDownstreamBlockSize();
         if (bytesToRead == 0)
             // we'll be called again, eventually
             break;
 
         bytesToRead = qBound<qint64>(1, bytesToRead, copyDevice->bytesAvailable());
         QByteArray byteData;
         byteData.resize(bytesToRead);
         qint64 bytesActuallyRead = copyDevice->read(byteData.data(), byteData.size());
         if (bytesActuallyRead == -1) {
             byteData.clear();
             backendNotify(NotifyCopyFinished);
             break;
         }
 
         byteData.resize(bytesActuallyRead);
         readBuffer.append(byteData);
 
         if (!copyDevice->isSequential() && copyDevice->atEnd()) {
             backendNotify(NotifyCopyFinished);
             bytesDownloaded += bytesActuallyRead;
             break;
         }
 
         bytesDownloaded += bytesActuallyRead;
     }
 
     if (bytesDownloaded == lastBytesDownloaded) {
         // we didn't read anything
         return;
     }
 
     lastBytesDownloaded = bytesDownloaded;
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
     if (preMigrationDownloaded != Q_INT64_C(-1))
         totalSize = totalSize.toLongLong() + preMigrationDownloaded;
     pauseNotificationHandling();
     // emit readyRead before downloadProgress incase this will cause events to be
     // processed and we get into a recursive call (as in QProgressDialog).
     emit q->readyRead();
     emit q->downloadProgress(bytesDownloaded,
                              totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
     resumeNotificationHandling();
 }

◆ _q_networkSessionConnected()

void QNetworkReplyImplPrivate::_q_networkSessionConnected ( )

Definition at line 264 of file qnetworkreplyimpl.cpp.

 {
     Q_Q(QNetworkReplyImpl);
 
     if (manager.isNull())
         return;
 
     QSharedPointer<QNetworkSession> session = manager->d_func()->getNetworkSession();
     if (!session)
         return;
 
     if (session->state() != QNetworkSession::Connected)
         return;
 
     #ifndef QT_NO_NETWORKPROXY
         // Re-set proxies here as new session might have changed them
         proxyList = manager->d_func()->queryProxy(QNetworkProxyQuery(request.url()));
     #endif
 
     switch (state) {
     case QNetworkReplyImplPrivate::Buffering:
     case QNetworkReplyImplPrivate::Working:
     case QNetworkReplyImplPrivate::Reconnecting:
         // Migrate existing downloads to new network connection.
         migrateBackend();
         break;
     case QNetworkReplyImplPrivate::WaitingForSession:
         // Start waiting requests.
         QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
         break;
     default:
         ;
     }
 }

◆ _q_networkSessionFailed()

void QNetworkReplyImplPrivate::_q_networkSessionFailed ( )

Definition at line 299 of file qnetworkreplyimpl.cpp.

Referenced by _q_startOperation().

 {
     // Abort waiting and working replies.
     if (state == WaitingForSession || state == Working) {
         state = Working;
         error(QNetworkReplyImpl::UnknownNetworkError,
               QCoreApplication::translate("QNetworkReply", "Network session error."));
         finished();
     }
 }

◆ _q_sourceReadChannelFinished()

void QNetworkReplyImplPrivate::_q_sourceReadChannelFinished ( )

◆ _q_sourceReadyRead()

void QNetworkReplyImplPrivate::_q_sourceReadyRead ( )

◆ _q_startOperation()

void QNetworkReplyImplPrivate::_q_startOperation ( )

Definition at line 74 of file qnetworkreplyimpl.cpp.

Referenced by setup().

 {
     // ensure this function is only being called once
     if (state == Working || state == Finished) {
         qDebug("QNetworkReplyImpl::_q_startOperation was called more than once");
         return;
     }
     state = Working;
 
     // note: if that method is called directly, it cannot happen that the backend is 0,
     // because we just checked via a qobject_cast that we got a http backend (see
     // QNetworkReplyImplPrivate::setup())
     if (!backend) {
         error(QNetworkReplyImpl::ProtocolUnknownError,
               QCoreApplication::translate("QNetworkReply", "Protocol \"%1\" is unknown").arg(url.scheme())); // not really true!;
         finished();
         return;
     }
 
     if (!backend->start()) {
 #ifndef QT_NO_BEARERMANAGEMENT
         // backend failed to start because the session state is not Connected.
         // QNetworkAccessManager will call _q_startOperation again for us when the session
         // state changes.
         state = WaitingForSession;
 
         QSharedPointer<QNetworkSession> session(manager->d_func()->getNetworkSession());
 
         if (session) {
             Q_Q(QNetworkReplyImpl);
 
             QObject::connect(session.data(), SIGNAL(error(QNetworkSession::SessionError)),
                              q, SLOT(_q_networkSessionFailed()), Qt::QueuedConnection);
 
             if (!session->isOpen())
                 session->open();
         } else {
             qWarning("Backend is waiting for QNetworkSession to connect, but there is none!");
             state = Working;
             error(QNetworkReplyImpl::UnknownNetworkError,
                   QCoreApplication::translate("QNetworkReply", "Network session error."));
             finished();
         }
 #else
         qWarning("Backend start failed");
         state = Working;
         error(QNetworkReplyImpl::UnknownNetworkError,
               QCoreApplication::translate("QNetworkReply", "backend start error."));
         finished();
 #endif
         return;
     }
 
     if (backend && backend->isSynchronous()) {
         state = Finished;
         q_func()->setFinished(true);
     } else {
         if (state != Finished) {
             if (operation == QNetworkAccessManager::GetOperation)
                 pendingNotifications.append(NotifyDownstreamReadyWrite);
 
             handleNotifications();
         }
     }
 }

◆ appendDownstreamData() [1/3]

void QNetworkReplyImplPrivate::appendDownstreamData ( QByteDataBuffer & data )

Definition at line 584 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessBackend::writeDownstreamData().

 {
     Q_Q(QNetworkReplyImpl);
     if (!q->isOpen())
         return;
 
     if (cacheEnabled && !cacheSaveDevice) {
         initCacheSaveDevice();
     }
 
     qint64 bytesWritten = 0;
     for (int i = 0; i < data.bufferCount(); i++) {
         QByteArray const &item = data[i];
 
         if (cacheSaveDevice)
             cacheSaveDevice->write(item.constData(), item.size());
         readBuffer.append(item);
 
         bytesWritten += item.size();
     }
     data.clear();
 
     bytesDownloaded += bytesWritten;
     lastBytesDownloaded = bytesDownloaded;
 
     appendDownstreamDataSignalEmissions();
 }

◆ appendDownstreamData() [2/3]

void QNetworkReplyImplPrivate::appendDownstreamData ( QIODevice * data )

Definition at line 635 of file qnetworkreplyimpl.cpp.

 {
     Q_Q(QNetworkReplyImpl);
     if (!q->isOpen())
         return;
 
     // read until EOF from data
     if (copyDevice) {
         qCritical("QNetworkReplyImpl: copy from QIODevice already in progress -- "
                   "backend probly needs to be fixed");
         return;
     }
 
     copyDevice = data;
     q->connect(copyDevice, SIGNAL(readyRead()), SLOT(_q_copyReadyRead()));
     q->connect(copyDevice, SIGNAL(readChannelFinished()), SLOT(_q_copyReadChannelFinished()));
 
     // start the copy:
     _q_copyReadyRead();
 }

◆ appendDownstreamData() [3/3]

void QNetworkReplyImplPrivate::appendDownstreamData ( const QByteArray & data )

Definition at line 656 of file qnetworkreplyimpl.cpp.

 {
     Q_UNUSED(data)
     // TODO implement
 
     // TODO call
 
     qFatal("QNetworkReplyImplPrivate::appendDownstreamData not implemented");
 }

◆ appendDownstreamDataDownloadBuffer()

void QNetworkReplyImplPrivate::appendDownstreamDataDownloadBuffer	(	qint64	bytesReceived,
		qint64	bytesTotal
	)

Definition at line 704 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessBackend::writeDownstreamDataDownloadBuffer().

 {
     Q_Q(QNetworkReplyImpl);
     if (!q->isOpen())
         return;
 
     if (cacheEnabled && !cacheSaveDevice)
         initCacheSaveDevice();
 
     if (cacheSaveDevice && bytesReceived == bytesTotal) {
 //        if (lastBytesDownloaded == -1)
 //            lastBytesDownloaded = 0;
 //        cacheSaveDevice->write(downloadBuffer + lastBytesDownloaded, bytesReceived - lastBytesDownloaded);
 
         // Write everything in one go if we use a download buffer. might be more performant.
         cacheSaveDevice->write(downloadBuffer, bytesTotal);
     }
 
     bytesDownloaded = bytesReceived;
     lastBytesDownloaded = bytesReceived;
 
     downloadBufferCurrentSize = bytesReceived;
 
     // Only emit readyRead when actual data is there
     // emit readyRead before downloadProgress incase this will cause events to be
     // processed and we get into a recursive call (as in QProgressDialog).
     if (bytesDownloaded > 0)
         emit q->readyRead();
     emit q->downloadProgress(bytesDownloaded, bytesTotal);
 }

◆ appendDownstreamDataSignalEmissions()

void QNetworkReplyImplPrivate::appendDownstreamDataSignalEmissions ( )

Definition at line 612 of file qnetworkreplyimpl.cpp.

Referenced by appendDownstreamData().

 {
     Q_Q(QNetworkReplyImpl);
 
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
     if (preMigrationDownloaded != Q_INT64_C(-1))
         totalSize = totalSize.toLongLong() + preMigrationDownloaded;
     pauseNotificationHandling();
     // important: At the point of this readyRead(), the data parameter list must be empty,
     // else implicit sharing will trigger memcpy when the user is reading data!
     emit q->readyRead();
     // emit readyRead before downloadProgress incase this will cause events to be
     // processed and we get into a recursive call (as in QProgressDialog).
     emit q->downloadProgress(bytesDownloaded,
                              totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
 
     resumeNotificationHandling();
     // do we still have room in the buffer?
     if (nextDownstreamBlockSize() > 0)
         backendNotify(QNetworkReplyImplPrivate::NotifyDownstreamReadyWrite);
 }

◆ backendNotify()

void QNetworkReplyImplPrivate::backendNotify ( InternalNotifications notification )

Definition at line 387 of file qnetworkreplyimpl.cpp.

Referenced by _q_copyReadyRead(), and appendDownstreamDataSignalEmissions().

 {
     Q_Q(QNetworkReplyImpl);
     if (!pendingNotifications.contains(notification))
         pendingNotifications.enqueue(notification);
 
     if (pendingNotifications.size() == 1)
         QCoreApplication::postEvent(q, new QEvent(QEvent::NetworkReplyUpdated));
 }

◆ completeCacheSave()

void QNetworkReplyImplPrivate::completeCacheSave ( )

Definition at line 508 of file qnetworkreplyimpl.cpp.

Referenced by finished().

 {
     Q_Q(QNetworkReplyImpl);
     if (cacheEnabled) {
         if (errorCode != QNetworkReplyImpl::NoError) {
             networkCache()->remove(url);
         } else if (cacheSaveDevice) {
             networkCache()->insert(cacheSaveDevice);
         }
         QObject::disconnect(networkCache(), SIGNAL(destroyed()), q, SLOT(_q_cacheDestroyed()));
     }
     cacheSaveDevice = 0;
     cacheEnabled = false;
 }

◆ consume()

void QNetworkReplyImplPrivate::consume ( qint64 count )

◆ createCache()

void QNetworkReplyImplPrivate::createCache ( )

Definition at line 455 of file qnetworkreplyimpl.cpp.

Referenced by setCachingEnabled().

 {
     // check if we can save and if we're allowed to
     if (!networkCache()
         || !request.attribute(QNetworkRequest::CacheSaveControlAttribute, true).toBool()
         || request.attribute(QNetworkRequest::CacheLoadControlAttribute,
                              QNetworkRequest::PreferNetwork).toInt()
             == QNetworkRequest::AlwaysNetwork)
         return;
     cacheEnabled = true;
 }

◆ emitUploadProgress()

void QNetworkReplyImplPrivate::emitUploadProgress	(	qint64	bytesSent,
		qint64	bytesTotal
	)

Definition at line 523 of file qnetworkreplyimpl.cpp.

 {
     Q_Q(QNetworkReplyImpl);
     bytesUploaded = bytesSent;
     pauseNotificationHandling();
     emit q->uploadProgress(bytesSent, bytesTotal);
     resumeNotificationHandling();
 }

◆ error()

void QNetworkReplyImplPrivate::error	(	QNetworkReply::NetworkError	code,
		const QString &	errorString
	)

Definition at line 799 of file qnetworkreplyimpl.cpp.

Referenced by _q_networkSessionFailed(), _q_startOperation(), QNetworkAccessBackend::error(), and finished().

 {
     Q_Q(QNetworkReplyImpl);
     // Can't set and emit multiple errors.
     if (errorCode != QNetworkReply::NoError) {
         qWarning("QNetworkReplyImplPrivate::error: Internal problem, this method must only be called once.");
         return;
     }
 
     errorCode = code;
     q->setErrorString(errorMessage);
 
     // note: might not be a good idea, since users could decide to delete us
     // which would delete the backend too...
     // maybe we should protect the backend
     emit q->error(code);
 }

◆ finished()

void QNetworkReplyImplPrivate::finished ( )

Definition at line 735 of file qnetworkreplyimpl.cpp.

Referenced by _q_networkSessionFailed(), _q_startOperation(), and QNetworkAccessBackend::finished().

 {
     Q_Q(QNetworkReplyImpl);
 
     if (state == Finished || state == Aborted || state == WaitingForSession)
         return;
 
     pauseNotificationHandling();
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
     if (preMigrationDownloaded != Q_INT64_C(-1))
         totalSize = totalSize.toLongLong() + preMigrationDownloaded;
 
     if (!manager.isNull()) {
 #ifndef QT_NO_BEARERMANAGEMENT
         QSharedPointer<QNetworkSession> session (manager->d_func()->getNetworkSession());
         if (session && session->state() == QNetworkSession::Roaming &&
             state == Working && errorCode != QNetworkReply::OperationCanceledError) {
             // only content with a known size will fail with a temporary network failure error
             if (!totalSize.isNull()) {
                 if (bytesDownloaded != totalSize) {
                     if (migrateBackend()) {
                         // either we are migrating or the request is finished/aborted
                         if (state == Reconnecting || state == WaitingForSession) {
                             resumeNotificationHandling();
                             return; // exit early if we are migrating.
                         }
                     } else {
                         error(QNetworkReply::TemporaryNetworkFailureError,
                               QNetworkReply::tr("Temporary network failure."));
                     }
                 }
             }
         }
 #endif
     }
     resumeNotificationHandling();
 
     state = Finished;
     q->setFinished(true);
 
     pendingNotifications.clear();
 
     pauseNotificationHandling();
     if (totalSize.isNull() || totalSize == -1) {
         emit q->downloadProgress(bytesDownloaded, bytesDownloaded);
     }
 
     if (bytesUploaded == -1 && (outgoingData || outgoingDataBuffer))
         emit q->uploadProgress(0, 0);
     resumeNotificationHandling();
 
     // if we don't know the total size of or we received everything save the cache
     if (totalSize.isNull() || totalSize == -1 || bytesDownloaded == totalSize)
         completeCacheSave();
 
     // note: might not be a good idea, since users could decide to delete us
     // which would delete the backend too...
     // maybe we should protect the backend
     pauseNotificationHandling();
     emit q->readChannelFinished();
     emit q->finished();
     resumeNotificationHandling();
 }

◆ getDownloadBuffer()

char * QNetworkReplyImplPrivate::getDownloadBuffer ( qint64 size )

Definition at line 671 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessBackend::getDownloadBuffer().

 {
     Q_Q(QNetworkReplyImpl);
 
     if (!downloadBuffer) {
         // We are requested to create it
         // Check attribute() if allocating a buffer of that size can be allowed
         QVariant bufferAllocationPolicy = request.attribute(QNetworkRequest::MaximumDownloadBufferSizeAttribute);
         if (bufferAllocationPolicy.isValid() && bufferAllocationPolicy.toLongLong() >= size) {
             downloadBufferCurrentSize = 0;
             downloadBufferMaximumSize = size;
             downloadBuffer = new char[downloadBufferMaximumSize]; // throws if allocation fails
             downloadBufferPointer = QSharedPointer<char>(downloadBuffer, downloadBufferDeleter);
 
             q->setAttribute(QNetworkRequest::DownloadBufferAttribute, qVariantFromValue<QSharedPointer<char> > (downloadBufferPointer));
         }
     }
 
     return downloadBuffer;
 }

◆ handleNotifications()

void QNetworkReplyImplPrivate::handleNotifications ( )

Definition at line 397 of file qnetworkreplyimpl.cpp.

Referenced by _q_startOperation().

 {
     if (notificationHandlingPaused)
         return;
 
     NotificationQueue current = pendingNotifications;
     pendingNotifications.clear();
 
     if (state != Working)
         return;
 
     while (state == Working && !current.isEmpty()) {
         InternalNotifications notification = current.dequeue();
         switch (notification) {
         case NotifyDownstreamReadyWrite:
             if (copyDevice)
                 _q_copyReadyRead();
             else
                 backend->downstreamReadyWrite();
             break;
 
         case NotifyCloseDownstreamChannel:
             backend->closeDownstreamChannel();
             break;
 
         case NotifyCopyFinished: {
             QIODevice *dev = copyDevice;
             copyDevice = 0;
             backend->copyFinished(dev);
             break;
         }
         }
     }
 }

◆ initCacheSaveDevice()

void QNetworkReplyImplPrivate::initCacheSaveDevice ( )

Definition at line 542 of file qnetworkreplyimpl.cpp.

Referenced by appendDownstreamData(), and appendDownstreamDataDownloadBuffer().

 {
     Q_Q(QNetworkReplyImpl);
 
     // The disk cache does not support partial content, so don't even try to
     // save any such content into the cache.
     if (q->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 206) {
         cacheEnabled = false;
         return;
     }
 
     // save the meta data
     QNetworkCacheMetaData metaData;
     metaData.setUrl(url);
     metaData = backend->fetchCacheMetaData(metaData);
 
     // save the redirect request also in the cache
     QVariant redirectionTarget = q->attribute(QNetworkRequest::RedirectionTargetAttribute);
     if (redirectionTarget.isValid()) {
         QNetworkCacheMetaData::AttributesMap attributes = metaData.attributes();
         attributes.insert(QNetworkRequest::RedirectionTargetAttribute, redirectionTarget);
         metaData.setAttributes(attributes);
     }
 
     cacheSaveDevice = networkCache()->prepare(metaData);
 
     if (!cacheSaveDevice || (cacheSaveDevice && !cacheSaveDevice->isOpen())) {
         if (cacheSaveDevice && !cacheSaveDevice->isOpen())
             qCritical("QNetworkReplyImpl: network cache returned a device that is not open -- "
                   "class %s probably needs to be fixed",
                   networkCache()->metaObject()->className());
 
         networkCache()->remove(url);
         cacheSaveDevice = 0;
         cacheEnabled = false;
     } else {
         q->connect(networkCache(), SIGNAL(destroyed()), SLOT(_q_cacheDestroyed()));
     }
 }

◆ isCachingEnabled()

bool QNetworkReplyImplPrivate::isCachingEnabled ( ) const

Definition at line 467 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessBackend::isCachingEnabled().

 {
     return (cacheEnabled && networkCache() != 0);
 }

◆ metaDataChanged()

void QNetworkReplyImplPrivate::metaDataChanged ( )

Definition at line 817 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessBackend::metaDataChanged().

 {
     Q_Q(QNetworkReplyImpl);
     // 1. do we have cookies?
     // 2. are we allowed to set them?
     if (cookedHeaders.contains(QNetworkRequest::SetCookieHeader) && !manager.isNull()
         && (static_cast<QNetworkRequest::LoadControl>
             (request.attribute(QNetworkRequest::CookieSaveControlAttribute,
                                QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Automatic)) {
         QList<QNetworkCookie> cookies =
             qvariant_cast<QList<QNetworkCookie> >(cookedHeaders.value(QNetworkRequest::SetCookieHeader));
         QNetworkCookieJar *jar = manager->cookieJar();
         if (jar)
             jar->setCookiesFromUrl(cookies, url);
     }
     emit q->metaDataChanged();
 }

◆ migrateBackend()

bool QNetworkReplyImplPrivate::migrateBackend ( )

Definition at line 1043 of file qnetworkreplyimpl.cpp.

Referenced by _q_networkSessionConnected(), and finished().

 {
     Q_Q(QNetworkReplyImpl);
 
     // Network reply is already finished or aborted, don't need to migrate.
     if (state == Finished || state == Aborted)
         return true;
 
     // Request has outgoing data, not migrating.
     if (outgoingData)
         return false;
 
     // Request is serviced from the cache, don't need to migrate.
     if (copyDevice)
         return true;
 
     // Backend does not support resuming download.
     if (backend && !backend->canResume())
         return false;
 
     state = QNetworkReplyImplPrivate::Reconnecting;
 
     if (backend) {
         delete backend;
         backend = 0;
     }
 
     cookedHeaders.clear();
     rawHeaders.clear();
 
     preMigrationDownloaded = bytesDownloaded;
 
     backend = manager->d_func()->findBackend(operation, request);
 
     if (backend) {
         backend->setParent(q);
         backend->reply = this;
         backend->setResumeOffset(bytesDownloaded);
     }
 
 #ifndef QT_NO_HTTP
     if (qobject_cast<QNetworkAccessHttpBackend *>(backend)) {
         _q_startOperation();
     } else {
         QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
     }
 #else
     QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
 #endif // QT_NO_HTTP
 
     return true;
 }

◆ networkCache()

QAbstractNetworkCache * QNetworkReplyImplPrivate::networkCache ( ) const

Definition at line 448 of file qnetworkreplyimpl.cpp.

Referenced by completeCacheSave(), createCache(), initCacheSaveDevice(), isCachingEnabled(), and setCachingEnabled().

 {
     if (!backend)
         return 0;
     return backend->networkCache();
 }

◆ nextDownstreamBlockSize()

qint64 QNetworkReplyImplPrivate::nextDownstreamBlockSize ( ) const

Definition at line 533 of file qnetworkreplyimpl.cpp.

Referenced by _q_copyReadyRead(), appendDownstreamDataSignalEmissions(), and QNetworkAccessBackend::nextDownstreamBlockSize().

 {
     enum { DesiredBufferSize = 32 * 1024 };
     if (readBufferMaxSize == 0)
         return DesiredBufferSize;
 
     return qMax<qint64>(0, readBufferMaxSize - readBuffer.byteAmount());
 }

◆ pauseNotificationHandling()

void QNetworkReplyImplPrivate::pauseNotificationHandling ( )

Definition at line 434 of file qnetworkreplyimpl.cpp.

Referenced by _q_copyReadyRead(), appendDownstreamDataSignalEmissions(), emitUploadProgress(), and finished().

 {
     notificationHandlingPaused = true;
 }

◆ redirectionRequested()

void QNetworkReplyImplPrivate::redirectionRequested ( const QUrl & target )

Definition at line 835 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessBackend::redirectionRequested().

 {
     attributes.insert(QNetworkRequest::RedirectionTargetAttribute, target);
 }

◆ resumeNotificationHandling()

void QNetworkReplyImplPrivate::resumeNotificationHandling ( )

Definition at line 440 of file qnetworkreplyimpl.cpp.

Referenced by _q_copyReadyRead(), appendDownstreamDataSignalEmissions(), emitUploadProgress(), and finished().

 {
     Q_Q(QNetworkReplyImpl);
     notificationHandlingPaused = false;
     if (pendingNotifications.size() >= 1)
         QCoreApplication::postEvent(q, new QEvent(QEvent::NetworkReplyUpdated));
 }

◆ setCachingEnabled()

void QNetworkReplyImplPrivate::setCachingEnabled ( bool enable )

Definition at line 472 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessBackend::setCachingEnabled().

 {
     Q_Q(QNetworkReplyImpl);
     if (!enable && !cacheEnabled)
         return;                 // nothing to do
     if (enable && cacheEnabled)
         return;                 // nothing to do either!
 
     if (enable) {
         if (bytesDownloaded) {
             // refuse to enable in this case
             qCritical("QNetworkReplyImpl: backend error: caching was enabled after some bytes had been written");
             return;
         }
 
         createCache();
     } else {
         // someone told us to turn on, then back off?
         // ok... but you should make up your mind
         qDebug("QNetworkReplyImpl: setCachingEnabled(true) called after setCachingEnabled(false) -- "
                "backend %s probably needs to be fixed",
                backend->metaObject()->className());
         networkCache()->remove(url);
         cacheSaveDevice = 0;
         cacheEnabled = false;
         QObject::disconnect(networkCache(), SIGNAL(destroyed()), q, SLOT(_q_cacheDestroyed()));
     }
 }

◆ setDownloadBuffer()

void QNetworkReplyImplPrivate::setDownloadBuffer	(	QSharedPointer< char >	sp,
		qint64	size
	)

Definition at line 692 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessHttpBackend::replyDownloadMetaData().

 {
     Q_Q(QNetworkReplyImpl);
 
     downloadBufferPointer = sp;
     downloadBuffer = downloadBufferPointer.data();
     downloadBufferCurrentSize = 0;
     downloadBufferMaximumSize = size;
     q->setAttribute(QNetworkRequest::DownloadBufferAttribute, qVariantFromValue<QSharedPointer<char> > (downloadBufferPointer));
 }

◆ setup()

void QNetworkReplyImplPrivate::setup	(	QNetworkAccessManager::Operation	op,
		const QNetworkRequest &	request,
		QIODevice *	outgoingData
	)

Definition at line 311 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessManager::createRequest().

 {
     Q_Q(QNetworkReplyImpl);
 
     outgoingData = data;
     request = req;
     url = request.url();
     operation = op;
 
     q->QIODevice::open(QIODevice::ReadOnly);
     // Internal code that does a HTTP reply for the synchronous Ajax
     // in QtWebKit.
     QVariant synchronousHttpAttribute = req.attribute(
             static_cast<QNetworkRequest::Attribute>(QNetworkRequest::SynchronousRequestAttribute));
     // The synchronous HTTP is a corner case, we will put all upload data in one big QByteArray in the outgoingDataBuffer.
     // Yes, this is not the most efficient thing to do, but on the other hand synchronous XHR needs to die anyway.
     if (synchronousHttpAttribute.toBool() && outgoingData) {
         outgoingDataBuffer = QSharedPointer<QRingBuffer>(new QRingBuffer());
         qint64 previousDataSize = 0;
         do {
             previousDataSize = outgoingDataBuffer->size();
             outgoingDataBuffer->append(outgoingData->readAll());
         } while (outgoingDataBuffer->size() != previousDataSize);
     }
 
     if (backend)
         backend->setSynchronous(synchronousHttpAttribute.toBool());
 
 
     if (outgoingData && backend && !backend->isSynchronous()) {
         // there is data to be uploaded, e.g. HTTP POST.
 
         if (!backend->needsResetableUploadData() || !outgoingData->isSequential()) {
             // backend does not need upload buffering or
             // fixed size non-sequential
             // just start the operation
             QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
         } else {
             bool bufferingDisallowed =
                     req.attribute(QNetworkRequest::DoNotBufferUploadDataAttribute,
                                   false).toBool();
 
             if (bufferingDisallowed) {
                 // if a valid content-length header for the request was supplied, we can disable buffering
                 // if not, we will buffer anyway
                 if (req.header(QNetworkRequest::ContentLengthHeader).isValid()) {
                     QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
                 } else {
                     state = Buffering;
                     QMetaObject::invokeMethod(q, "_q_bufferOutgoingData", Qt::QueuedConnection);
                 }
             } else {
                 // _q_startOperation will be called when the buffering has finished.
                 state = Buffering;
                 QMetaObject::invokeMethod(q, "_q_bufferOutgoingData", Qt::QueuedConnection);
             }
         }
     } else {
         // for HTTP, we want to send out the request as fast as possible to the network, without
         // invoking methods in a QueuedConnection
 #ifndef QT_NO_HTTP
         if (qobject_cast<QNetworkAccessHttpBackend *>(backend) || (backend && backend->isSynchronous())) {
             _q_startOperation();
         } else {
             QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
         }
 #else
         if (backend && backend->isSynchronous())
             _q_startOperation();
         else
             QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
 #endif // QT_NO_HTTP
         }
 }

◆ sslErrors()

void QNetworkReplyImplPrivate::sslErrors ( const QList< QSslError > & errors )

Definition at line 840 of file qnetworkreplyimpl.cpp.

Referenced by QNetworkAccessBackend::sslErrors().

 {
 #ifndef QT_NO_OPENSSL
     Q_Q(QNetworkReplyImpl);
     emit q->sslErrors(errors);
 #else
     Q_UNUSED(errors);
 #endif
 }

Properties

◆ backend

QNetworkAccessBackend* QNetworkReplyImplPrivate::backend

Definition at line 179 of file qnetworkreplyimpl_p.h.

Referenced by _q_startOperation(), QNetworkAccessManager::createRequest(), handleNotifications(), initCacheSaveDevice(), networkCache(), setCachingEnabled(), and setup().

◆ bytesDownloaded

qint64 QNetworkReplyImplPrivate::bytesDownloaded

Definition at line 201 of file qnetworkreplyimpl_p.h.

Referenced by _q_copyReadyRead(), appendDownstreamData(), appendDownstreamDataDownloadBuffer(), appendDownstreamDataSignalEmissions(), finished(), and setCachingEnabled().

◆ bytesUploaded

qint64 QNetworkReplyImplPrivate::bytesUploaded

Definition at line 203 of file qnetworkreplyimpl_p.h.

Referenced by emitUploadProgress(), and finished().

◆ cacheEnabled

bool QNetworkReplyImplPrivate::cacheEnabled

Definition at line 187 of file qnetworkreplyimpl_p.h.

Referenced by _q_cacheDestroyed(), appendDownstreamData(), appendDownstreamDataDownloadBuffer(), completeCacheSave(), createCache(), initCacheSaveDevice(), isCachingEnabled(), and setCachingEnabled().

◆ cacheSaveDevice

QIODevice* QNetworkReplyImplPrivate::cacheSaveDevice

Definition at line 188 of file qnetworkreplyimpl_p.h.

Referenced by _q_cacheDestroyed(), appendDownstreamData(), appendDownstreamDataDownloadBuffer(), completeCacheSave(), initCacheSaveDevice(), and setCachingEnabled().

◆ copyDevice

QIODevice* QNetworkReplyImplPrivate::copyDevice

Definition at line 182 of file qnetworkreplyimpl_p.h.

Referenced by _q_copyReadyRead(), appendDownstreamData(), and handleNotifications().

◆ downloadBuffer

char* QNetworkReplyImplPrivate::downloadBuffer

Definition at line 217 of file qnetworkreplyimpl_p.h.

Referenced by appendDownstreamDataDownloadBuffer(), getDownloadBuffer(), and setDownloadBuffer().

◆ downloadBufferCurrentSize

qint64 QNetworkReplyImplPrivate::downloadBufferCurrentSize

Definition at line 214 of file qnetworkreplyimpl_p.h.

Referenced by appendDownstreamDataDownloadBuffer(), getDownloadBuffer(), and setDownloadBuffer().

◆ downloadBufferMaximumSize

qint64 QNetworkReplyImplPrivate::downloadBufferMaximumSize

Definition at line 215 of file qnetworkreplyimpl_p.h.

Referenced by getDownloadBuffer(), and setDownloadBuffer().

◆ downloadBufferPointer

QSharedPointer<char> QNetworkReplyImplPrivate::downloadBufferPointer

Definition at line 216 of file qnetworkreplyimpl_p.h.

Referenced by getDownloadBuffer(), and setDownloadBuffer().

◆ downloadBufferReadPosition

qint64 QNetworkReplyImplPrivate::downloadBufferReadPosition

Definition at line 213 of file qnetworkreplyimpl_p.h.

◆ httpReasonPhrase

QString QNetworkReplyImplPrivate::httpReasonPhrase

Definition at line 206 of file qnetworkreplyimpl_p.h.

◆ httpStatusCode

int QNetworkReplyImplPrivate::httpStatusCode

Definition at line 207 of file qnetworkreplyimpl_p.h.

◆ lastBytesDownloaded

qint64 QNetworkReplyImplPrivate::lastBytesDownloaded

Definition at line 202 of file qnetworkreplyimpl_p.h.

Referenced by _q_copyReadyRead(), appendDownstreamData(), and appendDownstreamDataDownloadBuffer().

◆ lastProxyAuthentication

QNetworkProxy QNetworkReplyImplPrivate::lastProxyAuthentication

Definition at line 195 of file qnetworkreplyimpl_p.h.

Referenced by QNetworkAccessManagerPrivate::proxyAuthenticationRequired().

◆ notificationHandlingPaused

bool QNetworkReplyImplPrivate::notificationHandlingPaused

Definition at line 191 of file qnetworkreplyimpl_p.h.

Referenced by handleNotifications(), pauseNotificationHandling(), and resumeNotificationHandling().

◆ outgoingData

QIODevice* QNetworkReplyImplPrivate::outgoingData

Definition at line 180 of file qnetworkreplyimpl_p.h.

Referenced by _q_bufferOutgoingData(), _q_bufferOutgoingDataFinished(), finished(), and setup().

◆ outgoingDataBuffer

QSharedPointer<QRingBuffer> QNetworkReplyImplPrivate::outgoingDataBuffer

Definition at line 181 of file qnetworkreplyimpl_p.h.

Referenced by _q_bufferOutgoingData(), finished(), and setup().

◆ pendingNotifications

NotificationQueue QNetworkReplyImplPrivate::pendingNotifications

Definition at line 190 of file qnetworkreplyimpl_p.h.

Referenced by _q_startOperation(), backendNotify(), finished(), handleNotifications(), and resumeNotificationHandling().

◆ preMigrationDownloaded

qint64 QNetworkReplyImplPrivate::preMigrationDownloaded

Definition at line 204 of file qnetworkreplyimpl_p.h.

Referenced by _q_copyReadyRead(), appendDownstreamDataSignalEmissions(), and finished().

◆ proxyList

QList<QNetworkProxy> QNetworkReplyImplPrivate::proxyList

Definition at line 196 of file qnetworkreplyimpl_p.h.

Referenced by _q_networkSessionConnected(), QNetworkAccessBackend::proxyList(), and QNetworkAccessBackend::start().

◆ readBuffer

QByteDataBuffer QNetworkReplyImplPrivate::readBuffer

Definition at line 200 of file qnetworkreplyimpl_p.h.

Referenced by _q_copyReadyRead(), appendDownstreamData(), and nextDownstreamBlockSize().

◆ state

State QNetworkReplyImplPrivate::state

Definition at line 209 of file qnetworkreplyimpl_p.h.

Referenced by _q_bufferOutgoingDataFinished(), _q_copyReadyRead(), _q_networkSessionConnected(), _q_networkSessionFailed(), _q_startOperation(), finished(), handleNotifications(), and setup().

◆ urlForLastAuthentication

QUrl QNetworkReplyImplPrivate::urlForLastAuthentication

Definition at line 193 of file qnetworkreplyimpl_p.h.

Referenced by QNetworkAccessManagerPrivate::authenticationRequired().

The documentation for this class was generated from the following files:

/src/network/access/qnetworkreplyimpl_p.h
/src/network/access/qnetworkreplyimpl.cpp

Public Types

Public Functions

Public Variables

Additional Inherited Members