Changeset 83695 in webkit

Timestamp:

Apr 12, 2011 9:30:11 PM (13 years ago)

Author:

luiz@webkit.org

Message:

[Qt] QNetworkReplyHandler refactoring: remove nested event loop.
​https://bugs.webkit.org/show_bug.cgi?id=58375

Reviewed by Andreas Kling.

As QNAM now makes actual synchronous loads there is no need for a nested event loop
in ResourceHandleQt.

Moving the call for QNetworkReplyWrapper::synchronousLoad from
ResourceHandle::loadResourceSynchronously to QNetworkReplyHandler::start for the
redirections to work in synchronous requests.

• platform/network/qt/QNetworkReplyHandler.cpp:

(WebCore::QNetworkReplyHandler::start):

• platform/network/qt/QNetworkReplyHandler.h:
• platform/network/qt/ResourceHandleQt.cpp:

(WebCore::WebCoreSynchronousLoader::WebCoreSynchronousLoader):
(WebCore::WebCoreSynchronousLoader::didReceiveResponse):
(WebCore::WebCoreSynchronousLoader::didReceiveData):
(WebCore::WebCoreSynchronousLoader::didFinishLoading):
(WebCore::WebCoreSynchronousLoader::didFail):
(WebCore::ResourceHandle::loadResourceSynchronously):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/network/qt/QNetworkReplyHandler.cpp (modified) (2 diffs)
• platform/network/qt/QNetworkReplyHandler.h (modified) (1 diff)
• platform/network/qt/ResourceHandleQt.cpp (modified) (3 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-04-12  Luiz Agostini  <luiz.agostini@openbossa.org>
+
+        Reviewed by Andreas Kling.
+
+        [Qt] QNetworkReplyHandler refactoring: remove nested event loop.
+        https://bugs.webkit.org/show_bug.cgi?id=58375
+
+        As QNAM now makes actual synchronous loads there is no need for a nested event loop
+        in ResourceHandleQt.
+
+        Moving the call for QNetworkReplyWrapper::synchronousLoad from
+        ResourceHandle::loadResourceSynchronously to QNetworkReplyHandler::start for the
+        redirections to work in synchronous requests.
+
+        * platform/network/qt/QNetworkReplyHandler.cpp:
+        (WebCore::QNetworkReplyHandler::start):
+        * platform/network/qt/QNetworkReplyHandler.h:
+        * platform/network/qt/ResourceHandleQt.cpp:
+        (WebCore::WebCoreSynchronousLoader::WebCoreSynchronousLoader):
+        (WebCore::WebCoreSynchronousLoader::didReceiveResponse):
+        (WebCore::WebCoreSynchronousLoader::didReceiveData):
+        (WebCore::WebCoreSynchronousLoader::didFinishLoading):
+        (WebCore::WebCoreSynchronousLoader::didFail):
+        (WebCore::ResourceHandle::loadResourceSynchronously):
+
 2011-04-12  Vangelis Kokkevis  <vangelis@chromium.org>
 

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

@@ -631 +631 @@
 
     if (m_loadType == SynchronousLoad && m_replyWrapper->reply()->isFinished()) {
+        m_replyWrapper->synchronousLoad();
         // If supported, a synchronous request will be finished at this point, no need to hook up the signals.
         return;
@@ -639 +640 @@
 }
 
-void QNetworkReplyHandler::synchronousLoad()
-{
-    if (m_replyWrapper)
-        m_replyWrapper->synchronousLoad();
-}
-
 }
 

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

@@ -110 +110 @@
     QNetworkReply* release();
 
-    void synchronousLoad();
-
 public slots:
     void finish();

trunk/Source/WebCore/platform/network/qt/ResourceHandleQt.cpp

@@ -54 +54 @@
 class WebCoreSynchronousLoader : public ResourceHandleClient {
 public:
-    WebCoreSynchronousLoader();
+    WebCoreSynchronousLoader(ResourceError& error, ResourceResponse& response, Vector<char>& data)
+        : m_error(error)
+        , m_response(response)
+        , m_data(data)
+    {}
 
-    void waitForCompletion();
-
-    virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
-    virtual void didReceiveData(ResourceHandle*, const char*, int, int lengthReceived);
-    virtual void didFinishLoading(ResourceHandle*, double /*finishTime*/);
-    virtual void didFail(ResourceHandle*, const ResourceError&);
-
-    ResourceResponse resourceResponse() const { return m_response; }
-    ResourceError resourceError() const { return m_error; }
-    Vector<char> data() const { return m_data; }
-
-    void setReplyFinished(bool finished) { m_replyFinished = finished; }
-
+    virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse& response) { m_response = response; }
+    virtual void didReceiveData(ResourceHandle*, const char* data, int length, int) { m_data.append(data, length); }
+    virtual void didFinishLoading(ResourceHandle*, double /*finishTime*/) {}
+    virtual void didFail(ResourceHandle*, const ResourceError& error) { m_error = error; }
 private:
-    ResourceResponse m_response;
-    ResourceError m_error;
-    Vector<char> m_data;
-    QEventLoop m_eventLoop;
-    bool m_replyFinished;
+    ResourceError& m_error;
+    ResourceResponse& m_response;
+    Vector<char>& m_data;
 };
-
-WebCoreSynchronousLoader::WebCoreSynchronousLoader()
-        : m_replyFinished(false)
-{
-}
-
-void WebCoreSynchronousLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
-{
-    m_response = response;
-}
-
-void WebCoreSynchronousLoader::didReceiveData(ResourceHandle*, const char* data, int length, int)
-{
-    m_data.append(data, length);
-}
-
-void WebCoreSynchronousLoader::didFinishLoading(ResourceHandle*, double)
-{
-    if (!m_replyFinished)
-        m_eventLoop.exit();
-}
-
-void WebCoreSynchronousLoader::didFail(ResourceHandle*, const ResourceError& error)
-{
-    m_error = error;
-    if (!m_replyFinished)
-        m_eventLoop.exit();
-}
-
-void WebCoreSynchronousLoader::waitForCompletion()
-{
-    m_eventLoop.exec(QEventLoop::ExcludeUserInputEvents);
-}
 
 ResourceHandleInternal::~ResourceHandleInternal()
@@ -192 +152 @@
 void ResourceHandle::loadResourceSynchronously(NetworkingContext* context, const ResourceRequest& request, StoredCredentials /*storedCredentials*/, ResourceError& error, ResourceResponse& response, Vector<char>& data)
 {
-    WebCoreSynchronousLoader syncLoader;
+    WebCoreSynchronousLoader syncLoader(error, response, data);
     RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(request, &syncLoader, true, false));
 
@@ -205 +165 @@
     }
     d->m_context = context;
-    d->m_job = new QNetworkReplyHandler(handle.get(), QNetworkReplyHandler::SynchronousLoad);
 
-    QNetworkReply* reply = d->m_job->reply();
-    // When using synchronous calls, we are finished when reaching this point.
-    if (reply->isFinished()) {
-        syncLoader.setReplyFinished(true);
-        d->m_job->synchronousLoad();
-    } else
-        syncLoader.waitForCompletion();
-
-    error = syncLoader.resourceError();
-    data = syncLoader.data();
-    response = syncLoader.resourceResponse();
+    // starting in deferred mode gives d->m_job the chance of being set before sending the request.
+    d->m_job = new QNetworkReplyHandler(handle.get(), QNetworkReplyHandler::SynchronousLoad, true);
+    d->m_job->setLoadingDeferred(false);
 }