Changeset 561 for trunk/src/network/access/qnetworkreplyimpl.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/network/access/qnetworkreplyimpl.cpp (modified) (33 diffs)

trunk/src/network/access/qnetworkreplyimpl.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you 
+** @nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -47 +47 @@
 #include "QtCore/qdatetime.h"
 #include "QtNetwork/qsslconfiguration.h"
+
 
 #include <QtCore/QCoreApplication>
@@ -53 +54 @@
 
 inline QNetworkReplyImplPrivate::QNetworkReplyImplPrivate()
-    : copyDevice(0), networkCache(0),
+    : backend(0), outgoingData(0), outgoingDataBuffer(0),
+      copyDevice(0),
       cacheEnabled(false), cacheSaveDevice(0),
+
       bytesDownloaded(0), lastBytesDownloaded(-1), bytesUploaded(-1),
+
       state(Idle)
 {
@@ -62 +66 @@
 void QNetworkReplyImplPrivate::_q_startOperation()
 {
-    // This function is called exactly once
+    // ensure this function is only being called once
+    if (state == Working) {
+        qDebug("QNetworkReplyImpl::_q_startOperation was called more than once");
+        return;
+    }
     state = Working;
+
     if (!backend) {
         error(QNetworkReplyImpl::ProtocolUnknownError,
@@ -75 +84 @@
         if (operation == QNetworkAccessManager::GetOperation)
             pendingNotifications.append(NotifyDownstreamReadyWrite);
-        if (outgoingData) {
-            _q_sourceReadyRead();
-#if 0 // ### FIXME
-            if (outgoingData->atEndOfStream() && writeBuffer.isEmpty())
-                // empty upload
-                emit q->uploadProgress(0, 0);
-#endif
-        }
 
         handleNotifications();
@@ -88 +89 @@
 }
 
-void QNetworkReplyImplPrivate::_q_sourceReadyRead()
-{
-    // read data from the outgoingData QIODevice into our internal buffer
-    enum { DesiredBufferSize = 32 * 1024 };
-
-    if (writeBuffer.size() >= DesiredBufferSize)
-        return;                 // don't grow the buffer too much
-
-    // read as many bytes are available or up until we fill up the buffer
-    // but always read at least one byte
-    qint64 bytesToRead = qBound<qint64>(1, outgoingData->bytesAvailable(),
-                                        DesiredBufferSize - writeBuffer.size());
-    char *ptr = writeBuffer.reserve(bytesToRead);
-    qint64 bytesActuallyRead = outgoingData->read(ptr, bytesToRead);
-    if (bytesActuallyRead == -1) {
-        // EOF
-        writeBuffer.chop(bytesToRead);
-        backendNotify(NotifyCloseUpstreamChannel);
-        return;
-    }
-
-    if (bytesActuallyRead < bytesToRead)
-        writeBuffer.chop(bytesToRead - bytesActuallyRead);
-
-    // if we did read anything, let the backend know and handle it
-    if (bytesActuallyRead)
-        backendNotify(NotifyUpstreamReadyRead);
-
-    // check for EOF again
-    if (!outgoingData->isSequential() && outgoingData->atEnd())
-        backendNotify(NotifyCloseUpstreamChannel);
-}
-
-void QNetworkReplyImplPrivate::_q_sourceReadChannelFinished()
-{
-    _q_sourceReadyRead();
-}
-
 void QNetworkReplyImplPrivate::_q_copyReadyRead()
 {
     Q_Q(QNetworkReplyImpl);
-    if (!copyDevice && !q->isOpen())
-        return;
-
-    qint64 bytesToRead = nextDownstreamBlockSize();
-    if (bytesToRead == 0)
-        // we'll be called again, eventually
-        return;
-
-    bytesToRead = qBound<qint64>(1, bytesToRead, copyDevice->bytesAvailable());
-    char *ptr = readBuffer.reserve(bytesToRead);
-    qint64 bytesActuallyRead = copyDevice->read(ptr, bytesToRead);
-    if (bytesActuallyRead == -1) {
-        readBuffer.chop(bytesToRead);
-        backendNotify(NotifyCopyFinished);
-        return;
-    }
-
-    if (bytesActuallyRead != bytesToRead)
-        readBuffer.chop(bytesToRead - bytesActuallyRead);
-
-    if (!copyDevice->isSequential() && copyDevice->atEnd())
-        backendNotify(NotifyCopyFinished);
-
-    bytesDownloaded += bytesActuallyRead;
+    if (state != Working)
+        return;
+    if (!copyDevice || !q->isOpen())
+        return;
+
+    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);
+
     emit q->downloadProgress(bytesDownloaded,
                              totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
     emit q->readyRead();
+
 }
 
@@ -164 +143 @@
     _q_copyReadyRead();
 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 void QNetworkReplyImplPrivate::setup(QNetworkAccessManager::Operation op, const QNetworkRequest &req,
@@ -175 +215 @@
     operation = op;
 
-    if (outgoingData) {
-        q->connect(outgoingData, SIGNAL(readyRead()), SLOT(_q_sourceReadyRead()));
-        q->connect(outgoingData, SIGNAL(readChannelFinished()), SLOT(_q_sourceReadChannelFinished()));
+    if (outgoingData && backend) {
+        // 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 {
+        // No outgoing data (e.g. HTTP GET request)
+        // or no backend
+        // if no backend, _q_startOperation will handle the error of this
+        QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
     }
 
     q->QIODevice::open(QIODevice::ReadOnly);
-    QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
-}
-
-void QNetworkReplyImplPrivate::setNetworkCache(QAbstractNetworkCache *nc)
-{
-    networkCache = nc;
 }
 
@@ -201 +265 @@
 void QNetworkReplyImplPrivate::handleNotifications()
 {
+
+
+
     NotificationQueue current = pendingNotifications;
     pendingNotifications.clear();
@@ -207 +274 @@
         return;
 
-    while (!current.isEmpty()) {
+    while (!current.isEmpty()) {
         InternalNotifications notification = current.dequeue();
         switch (notification) {
@@ -217 +284 @@
             break;
 
-        case NotifyUpstreamReadyRead:
-            backend->upstreamReadyRead();
-            break;
-
         case NotifyCloseDownstreamChannel:
             backend->closeDownstreamChannel();
-            break;
-
-        case NotifyCloseUpstreamChannel:
-            backend->closeUpstreamChannel();
             break;
 
@@ -239 +298 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 void QNetworkReplyImplPrivate::createCache()
 {
     // check if we can save and if we're allowed to
-    if (!networkCache || !request.attribute(QNetworkRequest::CacheSaveControlAttribute, true).toBool())
+    if (!networkCache()
+        || !request.attribute(QNetworkRequest::CacheSaveControlAttribute, true).toBool()
+        || request.attribute(QNetworkRequest::CacheLoadControlAttribute,
+                             QNetworkRequest::PreferNetwork).toInt()
+            == QNetworkRequest::AlwaysNetwork)
         return;
     cacheEnabled = true;
@@ -249 +335 @@
 bool QNetworkReplyImplPrivate::isCachingEnabled() const
 {
-    return (cacheEnabled && networkCache != 0);
+    return (cacheEnabled && networkCache != 0);
 }
 
@@ -273 +359 @@
                "backend %s probably needs to be fixed",
                backend->metaObject()->className());
-        networkCache->remove(url);
+        networkCache->remove(url);
         cacheSaveDevice = 0;
         cacheEnabled = false;
@@ -282 +368 @@
 {
     if (cacheEnabled && errorCode != QNetworkReplyImpl::NoError) {
-        networkCache->remove(url);
+        networkCache->remove(url);
     } else if (cacheEnabled && cacheSaveDevice) {
-        networkCache->insert(cacheSaveDevice);
+        networkCache->insert(cacheSaveDevice);
     }
     cacheSaveDevice = 0;
@@ -290 +376 @@
 }
 
-void QNetworkReplyImplPrivate::consume(qint64 count)
-{
-    Q_Q(QNetworkReplyImpl);
-    if (count <= 0) {
-        qWarning("QNetworkConnection: backend signalled that it consumed %ld bytes", long(count));
-        return;
-    }
-
-    if (outgoingData)
-        // schedule another read from the source
-        QMetaObject::invokeMethod(q_func(), "_q_sourceReadyRead", Qt::QueuedConnection);
-
-    writeBuffer.skip(count);
-    if (bytesUploaded == -1)
-        bytesUploaded = count;
-    else
-        bytesUploaded += count;
-
-    QVariant totalSize = request.header(QNetworkRequest::ContentLengthHeader);
-    emit q->uploadProgress(bytesUploaded,
-                           totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
-}
+void QNetworkReplyImplPrivate::emitUploadProgress(qint64 bytesSent, qint64 bytesTotal)
+{
+    Q_Q(QNetworkReplyImpl);
+    bytesUploaded = bytesSent;
+    pauseNotificationHandling();
+    emit q->uploadProgress(bytesSent, bytesTotal);
+    resumeNotificationHandling();
+}
+
 
 qint64 QNetworkReplyImplPrivate::nextDownstreamBlockSize() const
@@ -319 +392 @@
         return DesiredBufferSize;
 
-    return qMax<qint64>(0, readBufferMaxSize - readBuffer.size());
-}
-
-void QNetworkReplyImplPrivate::feed(const QByteArray &data)
+    return qMax<qint64>(0, readBufferMaxSize - readBuffer.byteAmount());
+}
+
+// we received downstream data and send this to the cache
+// and to our readBuffer (which in turn gets read by the user of QNetworkReply)
+void QNetworkReplyImplPrivate::appendDownstreamData(QByteDataBuffer &data)
 {
     Q_Q(QNetworkReplyImpl);
     if (!q->isOpen())
         return;
-
-    char *ptr = readBuffer.reserve(data.size());
-    memcpy(ptr, data.constData(), data.size());
 
     if (cacheEnabled && !cacheSaveDevice) {
@@ -336 +408 @@
         metaData.setUrl(url);
         metaData = backend->fetchCacheMetaData(metaData);
-        cacheSaveDevice = networkCache->prepare(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);
+                      networkCache->metaObject()->className());
+
+            networkCache->remove(url);
             cacheSaveDevice = 0;
             cacheEnabled = false;
@@ -349 +431 @@
     }
 
-    if (cacheSaveDevice)
-        cacheSaveDevice->write(data);
-
-    bytesDownloaded += data.size();
+    qint64 bytesWritten = 0;
+    for (int i = 0; i < data.bufferCount(); i++) {
+        QByteArray item = data[i];
+
+        if (cacheSaveDevice)
+            cacheSaveDevice->write(item.constData(), item.size());
+        readBuffer.append(item);
+
+        bytesWritten += item.size();
+    }
+    data.clear();
+
+    bytesDownloaded += bytesWritten;
     lastBytesDownloaded = bytesDownloaded;
 
@@ -358 +449 @@
 
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
+
     emit q->downloadProgress(bytesDownloaded,
                              totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
+
+
     emit q->readyRead();
 
     // hopefully we haven't been deleted here
     if (!qq.isNull()) {
+
         // do we still have room in the buffer?
         if (nextDownstreamBlockSize() > 0)
@@ -370 +465 @@
 }
 
-void QNetworkReplyImplPrivate::feed(QIODevice *data)
-{
-    Q_Q(QNetworkReplyImpl);
-    Q_ASSERT(q->isOpen());
+// this is used when it was fetched from the cache, right?
+void QNetworkReplyImplPrivate::appendDownstreamData(QIODevice *data)
+{
+    Q_Q(QNetworkReplyImpl);
+    if (!q->isOpen())
+        return;
 
     // read until EOF from data
@@ -393 +490 @@
 {
     Q_Q(QNetworkReplyImpl);
-    Q_ASSERT_X(state != Finished, "QNetworkReplyImpl",
-               "Backend called finished/finishedWithError more than once");
+    
+        ;
 
     state = Finished;
     pendingNotifications.clear();
 
+
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
-    if (bytesDownloaded != lastBytesDownloaded || totalSize.isNull())
+    if (
         emit q->downloadProgress(bytesDownloaded, bytesDownloaded);
-    if (bytesUploaded == -1 && outgoingData)
+    }
+
+    if (bytesUploaded == -1 && (outgoingData || outgoingDataBuffer))
         emit q->uploadProgress(0, 0);
+
 
     completeCacheSave();
@@ -410 +511 @@
     // which would delete the backend too...
     // maybe we should protect the backend
+
     emit q->readChannelFinished();
     emit q->finished();
+
 }
 
@@ -456 +559 @@
 }
 
+
+
+
+
+
 QNetworkReplyImpl::QNetworkReplyImpl(QObject *parent)
     : QNetworkReply(*new QNetworkReplyImplPrivate, parent)
@@ -465 +573 @@
     Q_D(QNetworkReplyImpl);
     if (d->isCachingEnabled())
-        d->networkCache->remove(url());
+        d->networkCache()->remove(url());
+    if (d->outgoingDataBuffer)
+        delete d->outgoingDataBuffer;
 }
 
@@ -471 +581 @@
 {
     Q_D(QNetworkReplyImpl);
-    if (d->state == QNetworkReplyImplPrivate::Aborted)
+    if (d->state == QNetworkReplyImplPrivate::Aborted)
         return;
 
     // stop both upload and download
-    if (d->backend) {
-        d->backend->deleteLater();
-        d->backend = 0;
-    }
     if (d->outgoingData)
         disconnect(d->outgoingData, 0, this, 0);
@@ -492 +598 @@
     }
     d->state = QNetworkReplyImplPrivate::Aborted;
+
+
+
+
+
+
 }
 
@@ -521 +633 @@
 qint64 QNetworkReplyImpl::bytesAvailable() const
 {
-    return QNetworkReply::bytesAvailable() + d_func()->readBuffer.size();
+    return QNetworkReply::bytesAvailable() + d_func()->readBuffer.();
 }
 
@@ -528 +640 @@
     Q_D(QNetworkReplyImpl);
     if (size > d->readBufferMaxSize &&
-        size == d->readBuffer.size())
+        size ())
         d->backendNotify(QNetworkReplyImplPrivate::NotifyDownstreamReadyWrite);
 
@@ -558 +670 @@
 }
 
+
+
+
+
+
+
 #endif  // QT_NO_OPENSSL
 
@@ -576 +694 @@
     }
 
-    maxlen = qMin<qint64>(maxlen, d->readBuffer.size());
+    maxlen = qMin<qint64>(maxlen, d->readBuffer.());
     return d->readBuffer.read(data, maxlen);
 }