COMMIT_MESSAGE

[Qt] QNetworkReplyHandler refactoring: signal queue 

https://bugs.webkit.org/show_bug.cgi?id=57075

Reviewed by NOBODY (OOPS!).

The idea is to make all signals that come from the QNetworkReply to pass through a queue and to

stop that queue when loading is deferred. This way almost all the deferred logic can be removed

from QNetworkReplyHandler class and encapsulated in its own class.

To stop the queue during wrapper methods execution avoids stacking handler methods over wrapper

methods. Because of this there is no chance for the wrapper to be destroyed inside one of its methods.

This together with empting the queue at wrapper destruction time makes sure that the handler will

not receive calls from a dead wrapper.

The new class is named QNetworkReplyHandlerCallQueue.

* platform/network/qt/QNetworkReplyHandler.cpp:

(WebCore::QNetworkReplyHandlerCallQueue::QNetworkReplyHandlerCallQueue):

(WebCore::QNetworkReplyHandlerCallQueue::push):

(WebCore::QNetworkReplyHandlerCallQueue::lock):

(WebCore::QNetworkReplyHandlerCallQueue::unlock):

(WebCore::QNetworkReplyHandlerCallQueue::setDeferSignals):

(WebCore::QueueLocker::QueueLocker):

(WebCore::QueueLocker::~QueueLocker):

(WebCore::QNetworkReplyWrapper::QNetworkReplyWrapper):

(WebCore::QNetworkReplyWrapper::~QNetworkReplyWrapper):

(WebCore::QNetworkReplyWrapper::receiveMetaData):

(WebCore::QNetworkReplyWrapper::readyRead):

(WebCore::QNetworkReplyWrapper::didReceiveFinished):

(WebCore::QNetworkReplyHandler::QNetworkReplyHandler):

(WebCore::QNetworkReplyHandler::resetState):

(WebCore::QNetworkReplyHandler::release):

(WebCore::QNetworkReplyHandler::finish):

(WebCore::QNetworkReplyHandler::sendResponseIfNeeded):

(WebCore::QNetworkReplyHandler::forwardData):

(WebCore::QNetworkReplyHandler::start):

* platform/network/qt/QNetworkReplyHandler.h:

(WebCore::QNetworkReplyHandlerCallQueue::deferSignals):

(WebCore::QNetworkReplyHandlerCallQueue::clear):

(WebCore::QNetworkReplyWrapper::synchronousLoad):

(WebCore::QNetworkReplyHandler::setLoadingDeferred):

Source/WebCore/ChangeLog

2011-04-12  Luiz Agostini  <luiz.agostini@openbossa.org>

        Reviewed by NOBODY (OOPS!).

        [Qt] QNetworkReplyHandler refactoring: signal queue

        https://bugs.webkit.org/show_bug.cgi?id=57075

        The idea is to make all signals that come from the QNetworkReply to pass through a queue and to

        stop that queue when loading is deferred. This way almost all the deferred logic can be removed

        from QNetworkReplyHandler class and encapsulated in its own class.

        To stop the queue during wrapper methods execution avoids stacking handler methods over wrapper

        methods. Because of this there is no chance for the wrapper to be destroyed inside one of its methods.

        This together with empting the queue at wrapper destruction time makes sure that the handler will

        not receive calls from a dead wrapper.

        The new class is named QNetworkReplyHandlerCallQueue.

        * platform/network/qt/QNetworkReplyHandler.cpp:

        (WebCore::QNetworkReplyHandlerCallQueue::QNetworkReplyHandlerCallQueue):

        (WebCore::QNetworkReplyHandlerCallQueue::push):

        (WebCore::QNetworkReplyHandlerCallQueue::lock):

        (WebCore::QNetworkReplyHandlerCallQueue::unlock):

        (WebCore::QNetworkReplyHandlerCallQueue::setDeferSignals):

        (WebCore::QueueLocker::QueueLocker):

        (WebCore::QueueLocker::~QueueLocker):

        (WebCore::QNetworkReplyWrapper::QNetworkReplyWrapper):

        (WebCore::QNetworkReplyWrapper::~QNetworkReplyWrapper):

        (WebCore::QNetworkReplyWrapper::receiveMetaData):

        (WebCore::QNetworkReplyWrapper::readyRead):

        (WebCore::QNetworkReplyWrapper::didReceiveFinished):

        (WebCore::QNetworkReplyHandler::QNetworkReplyHandler):

        (WebCore::QNetworkReplyHandler::resetState):

        (WebCore::QNetworkReplyHandler::release):

        (WebCore::QNetworkReplyHandler::finish):

        (WebCore::QNetworkReplyHandler::sendResponseIfNeeded):

        (WebCore::QNetworkReplyHandler::forwardData):

        (WebCore::QNetworkReplyHandler::start):

        * platform/network/qt/QNetworkReplyHandler.h:

        (WebCore::QNetworkReplyHandlerCallQueue::deferSignals):

        (WebCore::QNetworkReplyHandlerCallQueue::clear):

        (WebCore::QNetworkReplyWrapper::synchronousLoad):

        (WebCore::QNetworkReplyHandler::setLoadingDeferred):

2011-04-11  Abhishek Arya  <inferno@chromium.org>

        Reviewed by Dave Hyatt.

Source/WebCore/platform/network/qt/QNetworkReplyHandler.cpp

@@bool FormDataIODevice::isSequential() const

    return true;

}

152 QNetworkReplyWrapper::QNetworkReplyWrapper(QNetworkReply* reply, QObject* parent)

QNetworkReplyHandlerCallQueue::QNetworkReplyHandlerCallQueue(QNetworkReplyHandler* handler, bool deferSignals)

    : m_replyHandler(handler)

    , m_locks(0)

    , m_deferSignals(deferSignals)

{

    Q_ASSERT(handler);

}

void QNetworkReplyHandlerCallQueue::push(EnqueuedCall method)

{

    if (m_deferSignals || m_locks) {

        m_enqueuedCalls.append(method);

        return;

    }

    (m_replyHandler->*method)();

}

void QNetworkReplyHandlerCallQueue::lock()

{

    ++m_locks;

}

void QNetworkReplyHandlerCallQueue::unlock()

{

    if (!m_locks)

        return;

    --m_locks;

    setDeferSignals(m_deferSignals);

}

void QNetworkReplyHandlerCallQueue::setDeferSignals(bool defer)

{

    m_deferSignals = defer;

    if (m_deferSignals || m_locks)

        return;

    while (!m_enqueuedCalls.isEmpty())

        (m_replyHandler->*(m_enqueuedCalls.takeFirst()))();

}

class QueueLocker {

public:

    QueueLocker(QNetworkReplyHandlerCallQueue* queue) : m_queue(queue) { m_queue->lock(); }

    ~QueueLocker() { m_queue->unlock(); }

private:

    QNetworkReplyHandlerCallQueue* m_queue;

};

QNetworkReplyWrapper::QNetworkReplyWrapper(QNetworkReplyHandlerCallQueue* queue, QNetworkReply* reply, QObject* parent)

153204 : QObject(parent)

154205 , m_reply(reply)

206 , m_queue(queue)

{

    Q_ASSERT(m_reply);

@@QNetworkReplyWrapper::~QNetworkReplyWrapper()

{

    if (m_reply)

        m_reply->deleteLater();

219 m_queue->clear();

}

QNetworkReply* QNetworkReplyWrapper::release()

@@void QNetworkReplyWrapper::receiveMetaData()

    // This slot is only used to receive the first signal from the QNetworkReply object.

    resetConnections();

246 QueueLocker lock(m_queue);

247

193248 m_redirectionTargetUrl = m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();

194249 if (m_redirectionTargetUrl.isValid()) {

195 ~~emit metaDataChanged(~~);

196 ~~emi~~t finish~~ed(~~);

250 m_queue->push(&QNetworkReplyHandler::sendResponseIfNeeded);

251 m_queue->push(&QNetworkReplyHandler::finish);

        return;

    }

@@void QNetworkReplyWrapper::receiveMetaData()

    m_encoding = extractCharsetFromMediaType(contentType);

    m_advertisedMimeType = extractMIMETypeFromMediaType(contentType);

    bool hasData = m_reply->bytesAvailable();

    bool isFinished = m_reply->isFinished();

    if (!isFinished) {

        // If not finished, connect to the slots that will be used from this point on.

        connect(m_reply, SIGNAL(readyRead()), this, SIGNAL(readyRead()));

        connect(m_reply, SIGNAL(finished()), this, SLOT(didReceiveFinished()));

    }

    emit metaDataChanged();

259 m_queue->push(&QNetworkReplyHandler::sendResponseIfNeeded);

214260

215 if (h~~asData~~)

216 ~~emi~~t ~~ready~~Read();

261 if (m_reply->bytesAvailable())

262 m_queue->push(&QNetworkReplyHandler::forwardData);

217263

218 if (isFinished) {

219 ~~emi~~t finish~~ed(~~);

264 if (m_reply->isFinished()) {

265 m_queue->push(&QNetworkReplyHandler::finish);

        return;

    }

    // If not finished, connect to the slots that will be used from this point on.

    connect(m_reply, SIGNAL(readyRead()), this, SLOT(readyRead()));

    connect(m_reply, SIGNAL(finished()), this, SLOT(didReceiveFinished()));

}

void QNetworkReplyWrapper::readyRead()

{

    m_queue->push(&QNetworkReplyHandler::forwardData);

}

void QNetworkReplyWrapper::didReceiveFinished()

{

    // Disconnecting will make sure that nothing will happen after emitting the finished signal.

    resetConnections();

229 ~~emi~~t finish~~ed(~~);

283 m_queue->push(&QNetworkReplyHandler::finish);

}

String QNetworkReplyHandler::httpMethod() const

@@QNetworkReplyHandler::QNetworkReplyHandler(ResourceHandle* handle, LoadType load

    , m_replyWrapper(0)

    , m_resourceHandle(handle)

    , m_loadType(loadType)

258 , m_deferred(deferred)

259312 , m_redirectionTries(gMaxRedirections)

313 , m_queue(this, deferred)

{

    resetState();

@@QNetworkReplyHandler::QNetworkReplyHandler(ResourceHandle* handle, LoadType load

    m_request = r.toNetworkRequest(originatingObject);

284 if (!m_deferred)

285 start();

338 m_queue.push(&QNetworkReplyHandler::start);

}

void QNetworkReplyHandler::resetState()

{

    m_redirected = false;

291 m_responseSent = false;

292344 m_responseContainsData = false;

    m_hasStarted = false;

    m_callFinishOnResume = false;

    m_callSendResponseIfNeededOnResume = false;

    m_callForwardDataOnResume = false;

297345

298346 if (m_replyWrapper) {

299 m_replyWrapper~~->deleteLater()~~;

347 delete m_replyWrapper;

        m_replyWrapper = 0;

    }

}

void QNetworkReplyHandler::setLoadingDeferred(bool deferred)

{

    m_deferred = deferred;

    if (!deferred)

        resumeDeferredLoad();

}

void QNetworkReplyHandler::resumeDeferredLoad()

{

    if (!m_hasStarted) {

        ASSERT(!m_callSendResponseIfNeededOnResume);

        ASSERT(!m_callForwardDataOnResume);

        ASSERT(!m_callFinishOnResume);

        start();

        return;

    }

    if (m_callSendResponseIfNeededOnResume)

        sendResponseIfNeeded();

    if (m_callForwardDataOnResume)

        forwardData();

    if (m_callFinishOnResume)

        finish();

}

void QNetworkReplyHandler::abort()

{

    m_resourceHandle = 0;

@@QNetworkReply* QNetworkReplyHandler::release()

        return 0;

    QNetworkReply* reply = m_replyWrapper->release();

348 m_replyWrapper~~->deleteLater()~~;

368 delete m_replyWrapper;

    m_replyWrapper = 0;

    return reply;

}

@@static bool shouldIgnoreHttpError(QNetworkReply* reply, bool receivedData)

void QNetworkReplyHandler::finish()

{

    ASSERT(m_hasStarted);

    m_callFinishOnResume = m_deferred;

    if (m_deferred)

        return;

    if (!m_replyWrapper || !m_replyWrapper->reply())

        return;

    sendResponseIfNeeded();

    if (wasAborted())

        return;

388 ASSERT(m_replyWrapper && m_replyWrapper->reply() && !wasAborted());

    ResourceHandleClient* client = m_resourceHandle->client();

    if (!client) {

385 m_replyWrapper~~->deleteLater()~~;

392 delete m_replyWrapper;

        m_replyWrapper = 0;

        return;

    }

    if (m_redirected) {

        resetState();

392 start();

399 m_queue.push(&QNetworkReplyHandler::start);

        return;

    }

@@void QNetworkReplyHandler::finish()

    }

    if (m_replyWrapper) {

412 m_replyWrapper~~->deleteLater()~~;

419 delete m_replyWrapper;

        m_replyWrapper = 0;

    }

}

void QNetworkReplyHandler::sendResponseIfNeeded()

{

    ASSERT(m_hasStarted);

    m_callSendResponseIfNeededOnResume = m_deferred;

    if (m_deferred)

        return;

    if (!m_replyWrapper || !m_replyWrapper->reply())

        return;

426 ASSERT(m_replyWrapper && m_replyWrapper->reply() && !wasAborted());

    if (m_replyWrapper->reply()->error() && !shouldIgnoreHttpError(m_replyWrapper->reply(), m_responseContainsData))

        return;

    if (wasAborted())

        return;

    if (m_responseSent)

        return;

    m_responseSent = true;

    ResourceHandleClient* client = m_resourceHandle->client();

    if (!client)

        return;

@@void QNetworkReplyHandler::redirect(ResourceResponse& response, const QUrl& redi

void QNetworkReplyHandler::forwardData()

{

    ASSERT(m_hasStarted);

    m_callForwardDataOnResume = m_deferred;

    if (m_deferred)

        return;

529 ASSERT(m_replyWrapper && m_replyWrapper->reply() && !wasAborted());

541530

542 if (!m_replyWrapper || !m_replyWrapper->reply())

543 return;

531 ASSERT(!m_redirected);

    if (m_replyWrapper->reply()->bytesAvailable())

        m_responseContainsData = true;

    sendResponseIfNeeded();

    // don't emit the "Document has moved here" type of HTML

    if (m_redirected)

        return;

    if (wasAborted())

        return;

    QByteArray data = m_replyWrapper->reply()->read(m_replyWrapper->reply()->bytesAvailable());

    ResourceHandleClient* client = m_resourceHandle->client();

@@QNetworkReply* QNetworkReplyHandler::sendNetworkRequest()

void QNetworkReplyHandler::start()

{

    ASSERT(!m_hasStarted);

    m_hasStarted = true;

    QNetworkReply* reply = sendNetworkRequest();

    if (!reply)

        return;

649 m_replyWrapper = new QNetworkReplyWrapper(reply, this);

625 m_replyWrapper = new QNetworkReplyWrapper(&m_queue, reply, this);

    if (m_loadType == SynchronousLoad && m_replyWrapper->reply()->isFinished()) {

        // If supported, a synchronous request will be finished at this point, no need to hook up the signals.

        return;

    }

    connect(m_replyWrapper, SIGNAL(finished()), this, SLOT(finish()));

    connect(m_replyWrapper, SIGNAL(metaDataChanged()), this, SLOT(sendResponseIfNeeded()));

    connect(m_replyWrapper, SIGNAL(readyRead()), this, SLOT(forwardData()));

    if (m_resourceHandle->firstRequest().reportUploadProgress())

        connect(m_replyWrapper->reply(), SIGNAL(uploadProgress(qint64, qint64)), this, SLOT(uploadProgress(qint64, qint64)));

}

Source/WebCore/platform/network/qt/QNetworkReplyHandler.h

@@namespace WebCore {

class ResourceHandle;

class ResourceResponse;

class QNetworkReplyHandler;

class QNetworkReplyHandlerCallQueue {

public:

    QNetworkReplyHandlerCallQueue(QNetworkReplyHandler* handler, bool deferSignals);

    bool deferSignals() const { return m_deferSignals; }

    void setDeferSignals(bool);

    typedef void (QNetworkReplyHandler::*EnqueuedCall)();

    void push(EnqueuedCall method);

    void clear() { m_enqueuedCalls.clear(); }

    void lock();

    void unlock();

private:

    QNetworkReplyHandler* m_replyHandler;

    int m_locks;

    bool m_deferSignals;

    QList<EnqueuedCall> m_enqueuedCalls;

};

class QNetworkReplyWrapper : public QObject {

    Q_OBJECT

public:

42 QNetworkReplyWrapper(QNetworkReply*, QObject* parent = 0);

62 QNetworkReplyWrapper(QNetworkReplyHandlerCallQueue* queue, QNetworkReply*, QObject* parent = 0);

    ~QNetworkReplyWrapper();

    QNetworkReply* reply() const { return m_reply; }

    QNetworkReply* release();

68 void synchronousLoad() { receiveMetaData(); }

    QUrl redirectionTargetUrl() const { return m_redirectionTargetUrl; }

    QString encoding() const { return m_encoding; }

    QString advertisedMimeType() const { return m_advertisedMimeType; }

Q_SIGNALS:

    void finished();

    void metaDataChanged();

    void readyRead();

    void uploadProgress(qint64 bytesSent, qint64 bytesTotal);

private Q_SLOTS:

    void receiveMetaData();

    void didReceiveFinished();

77 void readyRead();

private:

    void resetConnections();

@@private:

    QString m_encoding;

    QString m_advertisedMimeType;

88 QNetworkReplyHandlerCallQueue* m_queue;

};

class QNetworkReplyHandler : public QObject

@@public:

    };

    QNetworkReplyHandler(ResourceHandle*, LoadType, bool deferred = false);

82 void setLoadingDeferred(bool);

101 void setLoadingDeferred(bool deferred) { m_queue.setDeferSignals(deferred); }

    QNetworkReply* reply() const { return m_replyWrapper ? m_replyWrapper->reply() : 0; }

@@private:

    void start();

    void resetState();

    String httpMethod() const;

100 void resumeDeferredLoad();

    void redirect(ResourceResponse&, const QUrl&);

    bool wasAborted() const { return !m_resourceHandle; }

    QNetworkReply* sendNetworkRequest();

@@private:

    QNetworkReplyWrapper* m_replyWrapper;

    ResourceHandle* m_resourceHandle;

    bool m_redirected;

108 bool m_responseSent;

    bool m_responseContainsData;

    LoadType m_loadType;

    QNetworkAccessManager::Operation m_method;

    QNetworkRequest m_request;

114 bool m_deferred;

115

116131 // defer state holding

    bool m_hasStarted;

    bool m_callFinishOnResume;

    bool m_callSendResponseIfNeededOnResume;

    bool m_callForwardDataOnResume;

121132 int m_redirectionTries;

133

134 QNetworkReplyHandlerCallQueue m_queue;

};

// Self destructing QIODevice for FormData