Changeset 769 for trunk/src/network/access

Timestamp:

Aug 2, 2010, 9:27:30 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.3 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/network/access/qfilenetworkreply.cpp (modified) (9 diffs)
• src/network/access/qfilenetworkreply_p.h (modified) (2 diffs)
• src/network/access/qftp.cpp (modified) (1 diff)
• src/network/access/qhttpnetworkconnection.cpp (modified) (11 diffs)
• src/network/access/qhttpnetworkconnection_p.h (modified) (2 diffs)
• src/network/access/qhttpnetworkconnectionchannel.cpp (modified) (26 diffs)
• src/network/access/qhttpnetworkconnectionchannel_p.h (modified) (5 diffs)
• src/network/access/qhttpnetworkheader.cpp (modified) (1 diff)
• src/network/access/qhttpnetworkreply.cpp (modified) (9 diffs)
• src/network/access/qhttpnetworkreply_p.h (modified) (3 diffs)
• src/network/access/qnetworkaccessbackend.cpp (modified) (1 diff)
• src/network/access/qnetworkaccesshttpbackend.cpp (modified) (3 diffs)
• src/network/access/qnetworkaccesshttpbackend_p.h (modified) (1 diff)
• src/network/access/qnetworkaccessmanager.cpp (modified) (4 diffs)
• src/network/access/qnetworkcookie.h (modified) (1 diff)
• src/network/access/qnetworkcookiejar.h (modified) (1 diff)
• src/network/access/qnetworkdiskcache.cpp (modified) (2 diffs)
• src/network/access/qnetworkdiskcache_p.h (modified) (2 diffs)
• src/network/access/qnetworkreplyimpl.cpp (modified) (5 diffs)
• src/network/access/qnetworkreplyimpl_p.h (modified) (1 diff)
• src/network/access/qnetworkrequest.cpp (modified) (2 diffs)

trunk/src/network/access/qfilenetworkreply.cpp

@@ -50 +50 @@
 
 QFileNetworkReplyPrivate::QFileNetworkReplyPrivate()
-    : QNetworkReplyPrivate(), realFileSize(0)
-{
+    : QNetworkReplyPrivate(), fileEngine(0), fileSize(0), filePos(0)
+{
+}
+
+QFileNetworkReplyPrivate::~QFileNetworkReplyPrivate()
+{
+    delete fileEngine;
 }
 
@@ -95 +100 @@
         fileName = url.toString(QUrl::RemoveAuthority | QUrl::RemoveFragment | QUrl::RemoveQuery);
     }
-    d->realFile.setFileName(fileName);
-
-    QFileInfo fi(d->realFile);
+
+    QFileInfo fi(fileName);
     if (fi.isDir()) {
         QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Cannot open %1: Path is a directory").arg(url.toString());
@@ -107 +111 @@
     }
 
-    bool opened = d->realFile.open(QIODevice::ReadOnly | QIODevice::Unbuffered);
+    d->fileEngine = QAbstractFileEngine::create(fileName);
+    bool opened = d->fileEngine->open(QIODevice::ReadOnly | QIODevice::Unbuffered);
 
     // could we open the file?
     if (!opened) {
         QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Error opening %1: %2")
-                      .arg(d->realFile.fileName(), d->realFile.errorString());
-
-        if (d->realFile.exists()) {
+                      .arg(errorString());
+
+        if (.exists()) {
             setError(QNetworkReply::ContentAccessDenied, msg);
             QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
@@ -127 +132 @@
     }
 
-    d->realFileSize = fi.size();
+    d->ileSize = fi.size();
     setHeader(QNetworkRequest::LastModifiedHeader, fi.lastModified());
-    setHeader(QNetworkRequest::ContentLengthHeader, d->realFileSize);
+    setHeader(QNetworkRequest::ContentLengthHeader, d->ileSize);
 
     QMetaObject::invokeMethod(this, "metaDataChanged", Qt::QueuedConnection);
     QMetaObject::invokeMethod(this, "downloadProgress", Qt::QueuedConnection,
-        Q_ARG(qint64, d->realFileSize), Q_ARG(qint64, d->realFileSize));
+        Q_ARG(qint64, d->ileSize));
     QMetaObject::invokeMethod(this, "readyRead", Qt::QueuedConnection);
     QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
@@ -147 +152 @@
     Q_D(QFileNetworkReply);
     QNetworkReply::close();
-    d->realFile.close();
+    if (d->fileEngine)
+        d->fileEngine->close();
 }
 
@@ -154 +160 @@
     Q_D(QFileNetworkReply);
     QNetworkReply::close();
-    d->realFile.close();
+    if (d->fileEngine)
+        d->fileEngine->close();
 }
 
@@ -160 +167 @@
 {
     Q_D(const QFileNetworkReply);
-    return QNetworkReply::bytesAvailable() + d->realFile.bytesAvailable();
+    if (!d->fileEngine)
+        return 0;
+
+    return QNetworkReply::bytesAvailable() + d->fileSize - d->filePos;
 }
 
@@ -171 +181 @@
 {
     Q_D(const QFileNetworkReply);
-    return d->realFileSize;
+    return d->ileSize;
 }
 
@@ -180 +190 @@
 {
     Q_D(QFileNetworkReply);
-    qint64 ret = d->realFile.read(data, maxlen);
-    if (ret == 0 && bytesAvailable() == 0)
+    if (!d->fileEngine)
+        return -1;
+
+    qint64 ret = d->fileEngine->read(data, maxlen);
+    if (ret == 0 && bytesAvailable() == 0) {
         return -1; // everything had been read
-    else
-        return ret;
+    } else if (ret > 0) {
+        d->filePos += ret;
+    }
+
+    return ret;
 }
 

trunk/src/network/access/qfilenetworkreply_p.h

@@ -58 +58 @@
 #include "qnetworkaccessmanager.h"
 #include <QFile>
+
 
 QT_BEGIN_NAMESPACE
@@ -86 +87 @@
 public:
     QFileNetworkReplyPrivate();
+
 
-    QFile realFile;
-    qint64 realFileSize;
+    QAbstractFileEngine *fileEngine;
+    qint64 fileSize;
+    qint64 filePos;
 
     virtual bool isFinished() const;

trunk/src/network/access/qftp.cpp

@@ -2310 +2310 @@
 {
     Q_Q(QFtp);
+
+
+
+
+
+
     QFtpCommand *c = pending.first();
 

trunk/src/network/access/qhttpnetworkconnection.cpp

@@ -72 +72 @@
 #endif
 
-// the maximum amount of requests that might be pipelined into a socket
-// from what was suggested, 3 seems to be OK
+// The pipeline length. So there will be 4 requests in flight.
 const int QHttpNetworkConnectionPrivate::defaultPipelineLength = 3;
+
+
+
 
 
@@ -405 +407 @@
     reply->setRequest(request);
     reply->d_func()->connection = q;
+
     HttpMessagePair pair = qMakePair(request, reply);
 
@@ -416 +419 @@
         break;
     }
+
     // this used to be called via invokeMethod and a QueuedConnection
+
+
+
+
+
+
+
     _q_startNextRequest();
+
+
     return reply;
 }
@@ -423 +436 @@
 void QHttpNetworkConnectionPrivate::requeueRequest(const HttpMessagePair &pair)
 {
+
+
     QHttpNetworkRequest request = pair.first;
     switch (request.priority()) {
@@ -433 +448 @@
         break;
     }
-    // this used to be called via invokeMethod and a QueuedConnection
-    _q_startNextRequest();
+
+    );
 }
 
@@ -475 +490 @@
     int i = indexOf(socket);
 
-    bool highPriorityQueueProcessingDone = false;
-    bool lowPriorityQueueProcessingDone = false;
-
-    while (!highPriorityQueueProcessingDone && !lowPriorityQueueProcessingDone) {
-        // this loop runs once per request we intend to pipeline in.
-
-        if (channels[i].pipeliningSupported != QHttpNetworkConnectionChannel::PipeliningProbablySupported)
-            return;
-
-        // the current request that is in must already support pipelining
-        if (!channels[i].request.isPipeliningAllowed())
-            return;
-
-        // the current request must be a idempotent (right now we only check GET)
-        if (channels[i].request.operation() != QHttpNetworkRequest::Get)
-            return;
-
-        // check if socket is connected
-        if (socket->state() != QAbstractSocket::ConnectedState)
-            return;
-
-        // check for resendCurrent
-        if (channels[i].resendCurrent)
-            return;
-
-        // we do not like authentication stuff
-        // ### make sure to be OK with this in later releases
-        if (!channels[i].authenticator.isNull() || !channels[i].authenticator.user().isEmpty())
-            return;
-        if (!channels[i].proxyAuthenticator.isNull() || !channels[i].proxyAuthenticator.user().isEmpty())
-            return;
-
-        // check for pipeline length
+    // return fast if there was no reply right now processed
+    if (channels[i].reply == 0)
+        return;
+
+    if (! (defaultPipelineLength - channels[i].alreadyPipelinedRequests.length() >= defaultRePipelineLength)) {
+        return;
+    }
+
+    if (channels[i].pipeliningSupported != QHttpNetworkConnectionChannel::PipeliningProbablySupported)
+        return;
+
+    // the current request that is in must already support pipelining
+    if (!channels[i].request.isPipeliningAllowed())
+        return;
+
+    // the current request must be a idempotent (right now we only check GET)
+    if (channels[i].request.operation() != QHttpNetworkRequest::Get)
+        return;
+
+    // check if socket is connected
+    if (socket->state() != QAbstractSocket::ConnectedState)
+        return;
+
+    // check for resendCurrent
+    if (channels[i].resendCurrent)
+        return;
+
+    // we do not like authentication stuff
+    // ### make sure to be OK with this in later releases
+    if (!channels[i].authenticator.isNull() || !channels[i].authenticator.user().isEmpty())
+        return;
+    if (!channels[i].proxyAuthenticator.isNull() || !channels[i].proxyAuthenticator.user().isEmpty())
+        return;
+
+    // must be in ReadingState or WaitingState
+    if (! (channels[i].state == QHttpNetworkConnectionChannel::WaitingState
+           || channels[i].state == QHttpNetworkConnectionChannel::ReadingState))
+        return;
+
+
+    //qDebug() << "QHttpNetworkConnectionPrivate::fillPipeline processing highPriorityQueue, size=" << highPriorityQueue.size() << " alreadyPipelined=" << channels[i].alreadyPipelinedRequests.length();
+    int lengthBefore;
+    while (!highPriorityQueue.isEmpty()) {
+        lengthBefore = channels[i].alreadyPipelinedRequests.length();
+        fillPipeline(highPriorityQueue, channels[i]);
+
         if (channels[i].alreadyPipelinedRequests.length() >= defaultPipelineLength)
             return;
 
-        // must be in ReadingState or WaitingState
-        if (! (channels[i].state == QHttpNetworkConnectionChannel::WaitingState
-               || channels[i].state == QHttpNetworkConnectionChannel::ReadingState))
+        if (lengthBefore == channels[i].alreadyPipelinedRequests.length())
+            break; // did not process anything, now do the low prio queue
+    }
+
+    //qDebug() << "QHttpNetworkConnectionPrivate::fillPipeline processing lowPriorityQueue, size=" << lowPriorityQueue.size() << " alreadyPipelined=" << channels[i].alreadyPipelinedRequests.length();
+    while (!lowPriorityQueue.isEmpty()) {
+        lengthBefore = channels[i].alreadyPipelinedRequests.length();
+        fillPipeline(lowPriorityQueue, channels[i]);
+
+        if (channels[i].alreadyPipelinedRequests.length() >= defaultPipelineLength)
             return;
 
-        highPriorityQueueProcessingDone = fillPipeline(highPriorityQueue, channels[i]);
-        // not finished with highPriorityQueue? then loop again
-        if (!highPriorityQueueProcessingDone)
-            continue;
-        // highPriorityQueue was processed, now deal with the lowPriorityQueue
-        lowPriorityQueueProcessingDone = fillPipeline(lowPriorityQueue, channels[i]);
-    }
+        if (lengthBefore == channels[i].alreadyPipelinedRequests.length())
+            break; // did not process anything
+    }
+
+
 }
 
@@ -682 +715 @@
 
 
+
+
+
 void QHttpNetworkConnectionPrivate::_q_startNextRequest()
 {
@@ -689 +725 @@
             channels[i].resendCurrent = false;
             channels[i].state = QHttpNetworkConnectionChannel::IdleState;
-            if (channels[i].reply)
-                channels[i].sendRequest();
+
+            // if this is not possible, error will be emitted and connection terminated
+            if (!channels[i].resetUploadData())
+                continue;
+            channels[i].sendRequest();
         }
     }
@@ -696 +735 @@
     // dequeue new ones
 
-    QAbstractSocket *socket = 0;
+    // return fast if there is nothing to do
+    if (highPriorityQueue.isEmpty() && lowPriorityQueue.isEmpty())
+        return;
+    // try to get a free AND connected socket
     for (int i = 0; i < channelCount; ++i) {
-        QAbstractSocket *chSocket = channels[i].socket;
-        // try to get a free AND connected socket
         if (!channels[i].isSocketBusy() && channels[i].socket->state() == QAbstractSocket::ConnectedState) {
-            socket = chSocket;
-            dequeueAndSendRequest(socket);
-            break;
-        }
-    }
-
-    if (!socket) {
-        for (int i = 0; i < channelCount; ++i) {
-            QAbstractSocket *chSocket = channels[i].socket;
-            // try to get a free unconnected socket
-            if (!channels[i].isSocketBusy()) {
-                socket = chSocket;
-                dequeueAndSendRequest(socket);
-                break;
-            }
+            dequeueAndSendRequest(channels[i].socket);
+        }
+    }
+
+    // return fast if there is nothing to do
+    if (highPriorityQueue.isEmpty() && lowPriorityQueue.isEmpty())
+        return;
+    // try to get a free unconnected socket
+    for (int i = 0; i < channelCount; ++i) {
+        if (!channels[i].isSocketBusy()) {
+            dequeueAndSendRequest(channels[i].socket);
         }
     }
@@ -729 +765 @@
     if (highPriorityQueue.isEmpty() && lowPriorityQueue.isEmpty())
         return;
-    for (int j = 0; j < channelCount; j++)
-        fillPipeline(channels[j].socket);
+    for (int i = 0; i < channelCount; i++)
+        if (channels[i].socket->state() == QAbstractSocket::ConnectedState)
+            fillPipeline(channels[i].socket);
 }
 
@@ -856 +893 @@
 // SSL support below
 #ifndef QT_NO_OPENSSL
-QSslConfiguration QHttpNetworkConnectionPrivate::sslConfiguration(const QHttpNetworkReply &reply) const
-{
-    if (!encrypt)
-        return QSslConfiguration();
-
-    for (int i = 0; i < channelCount; ++i)
-        if (channels[i].reply == &reply)
-            return static_cast<QSslSocket *>(channels[0].socket)->sslConfiguration();
-    return QSslConfiguration(); // pending or done request
-}
-
 void QHttpNetworkConnection::setSslConfiguration(const QSslConfiguration &config)
 {

trunk/src/network/access/qhttpnetworkconnection_p.h

@@ -157 +157 @@
     static const int defaultChannelCount;
     static const int defaultPipelineLength;
+
 
     QHttpNetworkConnectionPrivate(const QString &hostName, quint16 port, bool encrypt);
@@ -211 +212 @@
     bool handleAuthenticateChallenge(QAbstractSocket *socket, QHttpNetworkReply *reply, bool isProxy, bool &resend);
 
-
-#ifndef QT_NO_OPENSSL
-    QSslConfiguration sslConfiguration(const QHttpNetworkReply &reply) const;
-#endif
-
 #ifndef QT_NO_NETWORKPROXY
     QNetworkProxy networkProxy;

trunk/src/network/access/qhttpnetworkconnectionchannel.cpp

@@ -59 +59 @@
 // TODO: Put channel specific stuff here so it does not polute qhttpnetworkconnection.cpp
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 void QHttpNetworkConnectionChannel::init()
 {
@@ -125 +147 @@
 bool QHttpNetworkConnectionChannel::sendRequest()
 {
+
+
+
+
+
+
+
     switch (state) {
     case QHttpNetworkConnectionChannel::IdleState: { // write the header
@@ -135 +164 @@
         written = 0; // excluding the header
         bytesTotal = 0;
-        if (reply) {
-            reply->d_func()->clear();
-            reply->d_func()->connection = connection;
-            reply->d_func()->autoDecompress = request.d->autoDecompress;
-            reply->d_func()->pipeliningUsed = false;
-        }
-        state = QHttpNetworkConnectionChannel::WritingState;
+
+        reply->d_func()->clear();
+        reply->d_func()->connection = connection;
+        s;
+        ;
+        
+
         pendingEncrypt = false;
         // if the url contains authentication parameters, use the new ones
@@ -175 +204 @@
 
             bytesTotal = request.contentLength();
+
+
+
         } else {
-            state = QHttpNetworkConnectionChannel::WaitingState;
-            sendRequest();
-            break;
-        }
-        // write the initial chunk together with the headers
-        // fall through
+            state = QHttpNetworkConnectionChannel::WaitingState; // now wait for response
+            sendRequest(); //recurse
+        }
+
+        break;
     }
     case QHttpNetworkConnectionChannel::WritingState:
@@ -191 +222 @@
                 emit reply->dataSendProgress(written, bytesTotal);
             state = QHttpNetworkConnectionChannel::WaitingState; // now wait for response
-            sendRequest();
+            sendRequest();
             break;
         }
@@ -255 +286 @@
 
         // HTTP pipelining
-        connection->d_func()->fillPipeline(socket);
-        socket->flush();
+        connection->d_func()->fillPipeline(socket);
+        socket->flush();
 
         // ensure we try to receive a reply in all cases, even if _q_readyRead_ hat not been called
         // this is needed if the sends an reply before we have finished sending the request. In that
         // case receiveReply had been called before but ignored the server reply
-        QMetaObject::invokeMethod(this, "_q_receiveReply", Qt::QueuedConnection);
+        if (socket->bytesAvailable())
+            QMetaObject::invokeMethod(this, "_q_receiveReply", Qt::QueuedConnection);
         break;
     }
@@ -279 +311 @@
     Q_ASSERT(socket);
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     qint64 bytes = 0;
     QAbstractSocket::SocketState socketState = socket->state();
@@ -284 +331 @@
     // connection might be closed to signal the end of data
     if (socketState == QAbstractSocket::UnconnectedState) {
-        if (!socket->bytesAvailable()) {
-            if (reply && reply->d_func()->state == QHttpNetworkReplyPrivate::ReadingDataState) {
+        if (socket->bytesAvailable() <= 0) {
+            if (reply->d_func()->state == QHttpNetworkReplyPrivate::ReadingDataState) {
+                // finish this reply. this case happens when the server did not send a content length
                 reply->d_func()->state = QHttpNetworkReplyPrivate::AllDoneState;
-                this->state = QHttpNetworkConnectionChannel::IdleState;
                 allDone();
+
             } else {
-                // try to reconnect/resend before sending an error.
-                if (reconnectAttempts-- > 0) {
-                    closeAndResendCurrentRequest();
-                } else if (reply) {
-                    reply->d_func()->errorString = connection->d_func()->errorDetail(QNetworkReply::RemoteHostClosedError, socket);
-                    emit reply->finishedWithError(QNetworkReply::RemoteHostClosedError, reply->d_func()->errorString);
-                    QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
-                }
-            }
+                handleUnexpectedEOF();
+                return;
+            }
+        } else {
+            // socket not connected but still bytes for reading.. just continue in this function
         }
     }
@@ -304 +348 @@
     // read loop for the response
     while (socket->bytesAvailable()) {
-        QHttpNetworkReplyPrivate::ReplyState state = reply ? reply->d_func()->state : QHttpNetworkReplyPrivate::AllDoneState;
+        QHttpNetworkReplyPrivate::ReplyState state = replytate;
         switch (state) {
-        case QHttpNetworkReplyPrivate::NothingDoneState:
+        case QHttpNetworkReplyPrivate::NothingDoneState: {
+            // only eat whitespace on the first call
+            eatWhitespace();
+            state = reply->d_func()->state = QHttpNetworkReplyPrivate::ReadingStatusState;
+            // fallthrough
+        }
         case QHttpNetworkReplyPrivate::ReadingStatusState: {
-            eatWhitespace();
             qint64 statusBytes = reply->d_func()->readStatus(socket);
-            if (statusBytes == -1 && reconnectAttempts <= 0) {
-                // too many errors reading/receiving/parsing the status, close the socket and emit error
-                close();
-                reply->d_func()->errorString = connection->d_func()->errorDetail(QNetworkReply::ProtocolFailure, socket);
-                emit reply->finishedWithError(QNetworkReply::ProtocolFailure, reply->d_func()->errorString);
-                QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
-                break;
-            } else if (statusBytes == -1) {
-                reconnectAttempts--;
-                reply->d_func()->clear();
-                closeAndResendCurrentRequest();
-                break;
+            if (statusBytes == -1) {
+                // connection broke while reading status. also handled if later _q_disconnected is called
+                handleUnexpectedEOF();
+                return;
             }
             bytes += statusBytes;
@@ -329 +369 @@
         case QHttpNetworkReplyPrivate::ReadingHeaderState: {
             QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();
-            bytes += replyPrivate->readHeader(socket);
+            qint64 headerBytes = replyPrivate->readHeader(socket);
+            if (headerBytes == -1) {
+                // connection broke while reading headers. also handled if later _q_disconnected is called
+                handleUnexpectedEOF();
+                return;
+            }
+            bytes += headerBytes;
             if (replyPrivate->state == QHttpNetworkReplyPrivate::ReadingDataState) {
                 if (replyPrivate->isGzipped() && replyPrivate->autoDecompress) {
@@ -338 +384 @@
                 }
                 if (replyPrivate->statusCode == 100) {
+
                     replyPrivate->state = QHttpNetworkReplyPrivate::ReadingStatusState;
                     break; // ignore
@@ -345 +392 @@
                 if (!replyPrivate->expectContent()) {
                     replyPrivate->state = QHttpNetworkReplyPrivate::AllDoneState;
-                    this->state = QHttpNetworkConnectionChannel::IdleState;
                     allDone();
-                    return;
+                    ;
                 }
             }
@@ -417 +463 @@
                 }
             }
+
             if (replyPrivate->state == QHttpNetworkReplyPrivate::ReadingDataState)
                 break;
+
             // everything done, fall through
             }
       case QHttpNetworkReplyPrivate::AllDoneState:
-            this->state = QHttpNetworkConnectionChannel::IdleState;
             allDone();
             break;
@@ -428 +475 @@
             break;
         }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     }
 }
@@ -557 +623 @@
     // ### at this point there should be no more data on the socket
     // close if server requested
-    if (reply->d_func()->isConnectionCloseEnabled())
+    bool connectionCloseEnabled = reply->d_func()->isConnectionCloseEnabled();
+    if (connectionCloseEnabled)
         close();
     // queue the finished signal, this is required since we might send new requests from
@@ -570 +637 @@
     detectPipeliningSupport();
 
+
+
+
+
+
+
+
+
+
+
+
     // move next from pipeline to current request
     if (!alreadyPipelinedRequests.isEmpty()) {
-        if (resendCurrent || reply->d_func()->isConnectionCloseEnabled() || socket->state() != QAbstractSocket::ConnectedState) {
+        if (resendCurrent ||  || socket->state() != QAbstractSocket::ConnectedState) {
             // move the pipelined ones back to the main queue
             requeueCurrentlyPipelinedRequests();
@@ -592 +670 @@
 
             // continue reading
-            _q_receiveReply();
+            //_q_receiveReply();
+            // this was wrong, allDone gets called from that function anyway.
         }
     } else if (alreadyPipelinedRequests.isEmpty() && socket->bytesAvailable() > 0) {
@@ -608 +687 @@
 {
     // detect HTTP Pipelining support
-    QByteArray serverHeaderField = reply->headerField("Server");
+    QByteArray serverHeaderField;
     if (
-            // check for broken servers in server reply header
-            // this is adapted from http://mxr.mozilla.org/firefox/ident?i=SupportsPipelining
-            (!serverHeaderField.contains("Microsoft-IIS/4."))
-            && (!serverHeaderField.contains("Microsoft-IIS/5."))
-            && (!serverHeaderField.contains("Netscape-Enterprise/3."))
             // check for HTTP/1.1
-            && (reply->d_func()->majorVersion == 1 && reply->d_func()->minorVersion == 1)
+            (reply->d_func()->majorVersion == 1 && reply->d_func()->minorVersion == 1)
             // check for not having connection close
             && (!reply->d_func()->isConnectionCloseEnabled())
             // check if it is still connected
             && (socket->state() == QAbstractSocket::ConnectedState)
+
+
+
+
+
+
+
             ) {
         pipeliningSupported = QHttpNetworkConnectionChannel::PipeliningProbablySupported;
@@ -635 +716 @@
     alreadyPipelinedRequests.clear();
 
-    QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+    // only run when the QHttpNetworkConnection is not currently being destructed, e.g.
+    // this function is called from _q_disconnected which is called because
+    // of ~QHttpNetworkConnectionPrivate
+    if (qobject_cast<QHttpNetworkConnection*>(connection))
+        QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
 }
 
@@ -675 +760 @@
         if (connection->d_func()->handleAuthenticateChallenge(socket, reply, (statusCode == 407), resend)) {
             if (resend) {
-                QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();
-                if (uploadByteDevice) {
-                    if (uploadByteDevice->reset()) {
-                        written = 0;
-                    } else {
-                        connection->d_func()->emitReplyError(socket, reply, QNetworkReply::ContentReSendError);
-                        break;
-                    }
-                }
+                if (!resetUploadData())
+                    break;
 
                 reply->d_func()->eraseData();
@@ -713 +791 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 void  QHttpNetworkConnectionChannel::pipelineInto(HttpMessagePair &pair)
 {
@@ -719 +813 @@
     QHttpNetworkRequest &request = pair.first;
     QHttpNetworkReply *reply = pair.second;
-    if (reply) {
-        reply->d_func()->clear();
-        reply->d_func()->connection = connection;
-        reply->d_func()->autoDecompress = request.d->autoDecompress;
-        reply->d_func()->pipeliningUsed = true;
-    }
+    reply->d_func()->clear();
+    reply->d_func()->connection = connection;
+    reply->d_func()->connectionChannel = this;
+    reply->d_func()->autoDecompress = request.d->autoDecompress;
+    reply->d_func()->pipeliningUsed = true;
 
 #ifndef QT_NO_NETWORKPROXY
@@ -788 +881 @@
     // read the available data before closing
     if (isSocketWaiting() || isSocketReading()) {
-        state = QHttpNetworkConnectionChannel::ReadingState;
-        if (reply)
+        
+        
             _q_receiveReply();
+
     } else if (state == QHttpNetworkConnectionChannel::IdleState && resendCurrent) {
         // re-sending request because the socket was in ClosingState
@@ -805 +899 @@
 {
     // improve performance since we get the request sent by the kernel ASAP
-    socket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
+    //socket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
+    // We have this commented out now. It did not have the effect we wanted. If we want to
+    // do this properly, Qt has to combine multiple HTTP requests into one buffer
+    // and send this to the kernel in one syscall and then the kernel immediately sends
+    // it as one TCP packet because of TCP_NODELAY.
+    // However, this code is currently not in Qt, so we rely on the kernel combining
+    // the requests into one TCP packet.
+
     // not sure yet if it helps, but it makes sense
     socket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
@@ -872 +973 @@
         break;
     }
-    QPointer<QObject> that = connection;
+    QPointer<Q> that = connection;
     QString errorString = connection->d_func()->errorDetail(errorCode, socket, socket->errorString());
     if (send2Reply) {
@@ -927 +1028 @@
     // otherwise we do nothing
 }
-#endif
+
+#endif
+
+void QHttpNetworkConnectionChannel::setConnection(QHttpNetworkConnection *c)
+{
+    // Inlining this function in the header leads to compiler error on
+    // release-armv5, on at least timebox 9.2 and 10.1.
+    connection = c;
+}
 
 QT_END_NAMESPACE

trunk/src/network/access/qhttpnetworkconnectionchannel_p.h

@@ -66 +66 @@
 #include <private/qhttpnetworkreply_p.h>
 
+
 
 #ifndef QT_NO_HTTP
@@ -81 +82 @@
 class QHttpNetworkReply;
 class QByteArray;
-class QHttpNetworkConnection;
 
 #ifndef HttpMessagePair
@@ -128 +128 @@
 
 
-    QHttpNetworkConnectionChannel() : socket(0), state(IdleState), reply(0), written(0), bytesTotal(0), resendCurrent(false),
-    lastStatus(0), pendingEncrypt(false), reconnectAttempts(2),
-    authMehtod(QAuthenticatorPrivate::None), proxyAuthMehtod(QAuthenticatorPrivate::None)
-#ifndef QT_NO_OPENSSL
-    , ignoreAllSslErrors(false)
-#endif
-    , pipeliningSupported(PipeliningSupportUnknown)
-    , connection(0)
-    {}
-
-    void setConnection(QHttpNetworkConnection *c) {connection = c;}
-    QHttpNetworkConnection *connection;
+    QHttpNetworkConnectionChannel();
+    
+    void setConnection(QHttpNetworkConnection *c);
+    QPointer<QHttpNetworkConnection> connection;
 
     void init();
@@ -152 +144 @@
     void handleStatus(); // called from allDone()
 
+
+
     void pipelineInto(HttpMessagePair &pair);
     void requeueCurrentlyPipelinedRequests();
     void detectPipeliningSupport();
 
+
     void closeAndResendCurrentRequest();
 
@@ -185 +180 @@
 };
 
-
-
 QT_END_NAMESPACE
 

trunk/src/network/access/qhttpnetworkheader.cpp

@@ -81 +81 @@
     QByteArray result;
     bool first = true;
-    foreach (QByteArray value, allValues) {
+    foreach (value, allValues) {
         if (!first)
             result += ", ";

trunk/src/network/access/qhttpnetworkreply.cpp

@@ -180 +180 @@
 {
     Q_D(QHttpNetworkReply);
+
+
+
     // we'll take the last buffer, so schedule another read from http
     if (d->downstreamLimited && d->responseData.bufferCount() == 1)
@@ -220 +223 @@
 }
 
-void QHttpNetworkReplyPrivate::clear()
+void QHttpNetworkReplyPrivate::clear()
 {
     state = NothingDoneState;
@@ -230 +233 @@
     currentChunkRead = 0;
     connectionCloseEnabled = true;
-    connection = 0;
 #ifndef QT_NO_COMPRESS
     if (initInflate)
@@ -237 +239 @@
     initInflate = false;
     streamEnd = false;
+
+
+
+
+
+
+
+
     autoDecompress = false;
-    fields.clear();
+    ();
 }
 
@@ -424 +434 @@
 qint64 QHttpNetworkReplyPrivate::readStatus(QAbstractSocket *socket)
 {
+
+
+
+
+
     qint64 bytes = 0;
     char c;
-
-    while (socket->bytesAvailable()) {
+    qint64 haveRead = 0;
+
+    do {
+        haveRead = socket->read(&c, 1);
+        if (haveRead == -1)
+            return -1; // unexpected EOF
+        else if (haveRead == 0)
+            break; // read more later
+
+        bytes++;
+
         // allow both CRLF & LF (only) line endings
-        if (socket->peek(&c, 1) == 1 && c == '\n') {
-            bytes += socket->read(&c, 1); // read the "n"
+        if (c == '\n') {
             // remove the CR at the end
             if (fragment.endsWith('\r')) {
@@ -443 +466 @@
             break;
         } else {
-            c = 0;
-            int haveRead = socket->read(&c, 1);
-            if (haveRead == -1)
-                return -1;
-            bytes += haveRead;
             fragment.append(c);
         }
@@ -457 +475 @@
             return -1;
         }
-
-    }
+    } while (haveRead == 1);
 
     return bytes;
@@ -501 +518 @@
 qint64 QHttpNetworkReplyPrivate::readHeader(QAbstractSocket *socket)
 {
+
+
+
+
+
+
+
     qint64 bytes = 0;
     char c = 0;
     bool allHeaders = false;
-    while (!allHeaders && socket->bytesAvailable()) {
-        if (socket->peek(&c, 1) == 1 && c == '\n') {
-            // check for possible header endings. As per HTTP rfc,
-            // the header endings will be marked by CRLFCRLF. But
-            // we will allow CRLFLF, LFLF & CRLFCRLF
-            if (fragment.endsWith("\n\r") || fragment.endsWith('\n'))
-                allHeaders = true;
-        }
-        bytes += socket->read(&c, 1);
-        fragment.append(c);
-    }
+    qint64 haveRead = 0;
+    do {
+        haveRead = socket->read(&c, 1);
+        if (haveRead == 0) {
+            // read more later
+            break;
+        } else if (haveRead == -1) {
+            // connection broke down
+            return -1;
+        } else {
+            fragment.append(c);
+            bytes++;
+
+            if (c == '\n') {
+                // check for possible header endings. As per HTTP rfc,
+                // the header endings will be marked by CRLFCRLF. But
+                // we will allow CRLFCRLF, CRLFLF, LFLF
+                if (fragment.endsWith("\r\n\r\n")
+                    || fragment.endsWith("\r\n\n")
+                    || fragment.endsWith("\n\n"))
+                    allHeaders = true;
+
+                // there is another case: We have no headers. Then the fragment equals just the line ending
+                if ((fragment.length() == 2 && fragment.endsWith("\r\n"))
+                    || (fragment.length() == 1 && fragment.endsWith("\n")))
+                    allHeaders = true;
+            }
+        }
+    } while (!allHeaders && haveRead > 0);
+
     // we received all headers now parse them
     if (allHeaders) {
@@ -776 +819 @@
 {
     Q_D(const QHttpNetworkReply);
-    if (d->connection)
-        return d->connection->d_func()->sslConfiguration(*this);
-    return QSslConfiguration();
+
+    if (!d->connectionChannel)
+        return QSslConfiguration();
+
+    QSslSocket *sslSocket = qobject_cast<QSslSocket*>(d->connectionChannel->socket);
+    if (!sslSocket)
+        return QSslConfiguration();
+
+    return sslSocket->sslConfiguration();
 }
 

trunk/src/network/access/qhttpnetworkreply_p.h

@@ -87 +87 @@
 
 class QHttpNetworkConnection;
+
 class QHttpNetworkRequest;
 class QHttpNetworkConnectionPrivate;
@@ -172 +173 @@
     QAuthenticatorPrivate::Method authenticationMethod(bool isProxy) const;
     void clear();
+
 
     qint64 readReplyBodyRaw(QIODevice *in, QByteDataBuffer *out, qint64 size);
@@ -219 +221 @@
     qint64 currentChunkRead;
     QPointer<QHttpNetworkConnection> connection;
+
     bool initInflate;
     bool streamEnd;

trunk/src/network/access/qnetworkaccessbackend.cpp

@@ -73 +73 @@
 {
     QMutexLocker locker(&factoryData()->mutex);
-    factoryData()->prepend(this);
+    factoryData()->pend(this);
 }
 

trunk/src/network/access/qnetworkaccesshttpbackend.cpp

@@ -681 +681 @@
 
     while (httpReply->bytesAvailable() != 0 && nextDownstreamBlockSize() != 0 && nextDownstreamBlockSize() > list.byteAmount()) {
-        QByteArray data = httpReply->readAny();
-        list.append(data);
+        list.append(httpReply->readAny());
     }
 
@@ -754 +753 @@
         if (!value.isEmpty()) {
             if (qstricmp(it->first.constData(), "set-cookie") == 0)
-                value += "\n";
+                value += ;
             else
                 value += ", ";
@@ -977 +976 @@
         // write to disk when only the date changes).
         // However, without the date we cannot calculate the age of the page
-        // anymore. Consider a proper fix of that problem for 4.6.1.
+        // anymore.
         //if (header == "date")
             //continue;

trunk/src/network/access/qnetworkaccesshttpbackend_p.h

@@ -95 +95 @@
     QNetworkCacheMetaData fetchCacheMetaData(const QNetworkCacheMetaData &metaData) const;
 
-    qint64 deviceReadData(char *buffer, qint64 maxlen);
-
     // we return true since HTTP needs to send PUT/POST data again after having authenticated
     bool needsResetableUploadData() { return true; }

trunk/src/network/access/qnetworkaccessmanager.cpp

@@ -108 +108 @@
     it sends. It contains the proxy and cache configuration, as well as the
     signals related to such issues, and reply signals that can be used to
-    monitor the progress of a network operation.
+    monitor the progress of a network operation. One QNetworkAccessManager
+    should be enough for the whole Qt application.
 
     Once a QNetworkAccessManager object has been created, the application can
@@ -119 +120 @@
     \snippet doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp 0
 
+
     When the \tt replyFinished slot above is called, the parameter it
     takes is the QNetworkReply object containing the downloaded data
@@ -128 +130 @@
     deleteLater() function.
 
+
+
+
+
+
     A more involved example, assuming the manager is already existent,
     can be:
     \snippet doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp 1
+
+
+
+
+
+
+
+
+
+
 
     \sa QNetworkRequest, QNetworkReply, QNetworkProxy
@@ -550 +567 @@
 /*!
     Posts a request to obtain the network headers for \a request
-    and returns a new QNetworkReply object which will contain such headers
+    and returns a new QNetworkReply object which will contain such headers
 
     The function is named after the HTTP request associated (HEAD).

trunk/src/network/access/qnetworkcookie.h

@@ -115 +115 @@
 
 // ### Qt5 remove this include
-#include "qnetworkcookiejar.h"
+#include 
 
 Q_DECLARE_METATYPE(QNetworkCookie)

trunk/src/network/access/qnetworkcookiejar.h

@@ -47 +47 @@
 
 // ### Qt5 remove this include
-#include "qnetworkcookie.h"
+#include 
 
 QT_BEGIN_HEADER

trunk/src/network/access/qnetworkdiskcache.cpp

@@ -42 +42 @@
 //#define QNETWORKDISKCACHE_DEBUG
 
-#ifndef QT_NO_NETWORKDISKCACHE
 
 #include "qnetworkdiskcache.h"
@@ -60 +59 @@
 #define CACHE_POSTFIX QLatin1String(".cache")
 #define MAX_COMPRESSION_SIZE (1024 * 1024 * 3)
+
+
 
 QT_BEGIN_NAMESPACE

trunk/src/network/access/qnetworkdiskcache_p.h

@@ -60 +60 @@
 #include <qtemporaryfile.h>
 
+
+
 QT_BEGIN_NAMESPACE
 
@@ -120 +122 @@
 QT_END_NAMESPACE
 
+
+
 #endif // QNETWORKDISKCACHE_P_H

trunk/src/network/access/qnetworkreplyimpl.cpp

@@ -404 +404 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // we received downstream data and send this to the cache
 // and to our readBuffer (which in turn gets read by the user of QNetworkReply)
@@ -413 +444 @@
 
     if (cacheEnabled && !cacheSaveDevice) {
-        // 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;
-        }
+        initCacheSaveDevice();
     }
 
     qint64 bytesWritten = 0;
     for (int i = 0; i < data.bufferCount(); i++) {
-        QByteArray item = data[i];
+        QByteArray item = data[i];
 
         if (cacheSaveDevice)
@@ -454 +461 @@
     bytesDownloaded += bytesWritten;
     lastBytesDownloaded = bytesDownloaded;
+
+
+
+
+
+
+
 
     QPointer<QNetworkReplyImpl> qq = q;
@@ -496 +510 @@
 }
 
+
+
+
+
+
+
+
+
+
 void QNetworkReplyImplPrivate::finished()
 {
@@ -581 +604 @@
 {
     Q_D(QNetworkReplyImpl);
+
+
+
+
     if (d->isCachingEnabled())
         d->networkCache()->remove(url());
+
     if (d->outgoingDataBuffer)
         delete d->outgoingDataBuffer;

trunk/src/network/access/qnetworkreplyimpl_p.h

@@ -146 +146 @@
     void emitUploadProgress(qint64 bytesSent, qint64 bytesTotal);
     qint64 nextDownstreamBlockSize() const;
+
+
+
     void appendDownstreamData(QByteDataBuffer &data);
     void appendDownstreamData(QIODevice *data);
+
+
     void finished();
     void error(QNetworkReply::NetworkError code, const QString &errorString);

trunk/src/network/access/qnetworkrequest.cpp

@@ -139 +139 @@
         determine if the requested redirection should be allowed,
         according to its security policies.
+
+
 
     \value ConnectionEncryptedAttribute
@@ -650 +652 @@
     QList<QNetworkCookie> result;
     QList<QByteArray> cookieList = raw.split(';');
-    foreach (QByteArray cookie, cookieList) {
+    foreach (cookie, cookieList) {
         QList<QNetworkCookie> parsed = QNetworkCookie::parseCookies(cookie.trimmed());
         if (parsed.count() != 1)