[SCM] qtbase packaging branch, master, updated. debian/5.5.1+dfsg-7-2-g0fd26ab
Dmitry Shachnev
mitya57 at moszumanska.debian.org
Tue Nov 17 12:32:22 UTC 2015
Gitweb-URL: http://git.debian.org/?p=pkg-kde/qt/qtbase.git;a=commitdiff;h=0fd26ab
The following commit has been merged in the master branch:
commit 0fd26ab9c340acb639e57cca090e8285b1bb2302
Author: Dmitry Shachnev <mitya57 at gmail.com>
Date: Tue Nov 17 15:32:01 2015 +0300
Backport two upstream patches fix some issues with QNetworkAccessManager.
- qnetworkaccessmanager_accessibility.diff to fix upstream QTBUG-46323.
- qnetworkreply_abort_socket.diff to fix upstream QTBUG-47471.
Thanks to Soeren D. Schulze for the bug report and to Gaudenz Steinlin for
pointing me to the patches.
---
debian/changelog | 6 +
.../qnetworkaccessmanager_accessibility.diff | 214 +++++++++++++++++++++
debian/patches/qnetworkreply_abort_socket.diff | 113 +++++++++++
debian/patches/series | 2 +
4 files changed, 335 insertions(+)
diff --git a/debian/changelog b/debian/changelog
index d9ba49e..e9b6bc3 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,11 @@
qtbase-opensource-src (5.5.1+dfsg-8) UNRELEASED; urgency=medium
+ [ Dmitry Shachnev ]
+ * Backport two upstream patches fix some issues with QNetworkAccessManager:
+ - qnetworkaccessmanager_accessibility.diff to fix upstream QTBUG-46323.
+ - qnetworkreply_abort_socket.diff to fix upstream QTBUG-47471.
+ Closes: #804883. Thanks to Soeren D. Schulze for the bug report and to
+ Gaudenz Steinlin for pointing me to the patches.
-- Debian Qt/KDE Maintainers <debian-qt-kde at lists.debian.org> Tue, 17 Nov 2015 15:12:51 +0300
diff --git a/debian/patches/qnetworkaccessmanager_accessibility.diff b/debian/patches/qnetworkaccessmanager_accessibility.diff
new file mode 100644
index 0000000..9fba015
--- /dev/null
+++ b/debian/patches/qnetworkaccessmanager_accessibility.diff
@@ -0,0 +1,214 @@
+Description: make sure networkAccessibilityChanged is emitted
+Origin: upstream, http://code.qt.io/cgit/qt/qtbase.git/commit/?id=bb281eea179d50a4
+Bug: https://bugs.debian.org/804883
+Last-Update: 2015-11-17
+
+--- a/src/network/access/qnetworkaccessmanager.cpp
++++ b/src/network/access/qnetworkaccessmanager.cpp
+@@ -278,7 +278,8 @@
+
+ \snippet code/src_network_access_qnetworkaccessmanager.cpp 4
+
+- Network requests can be reenabled again by calling
++ Network requests can be re-enabled again, and this property will resume to
++ reflect the actual device state by calling
+
+ \snippet code/src_network_access_qnetworkaccessmanager.cpp 5
+
+@@ -467,16 +468,12 @@
+ qRegisterMetaType<QSharedPointer<char> >();
+
+ #ifndef QT_NO_BEARERMANAGEMENT
+- if (!d->networkSessionRequired) {
+- // if a session is required, we track online state through
+- // the QNetworkSession's signals
+- connect(&d->networkConfigurationManager, SIGNAL(onlineStateChanged(bool)),
+- SLOT(_q_onlineStateChanged(bool)));
+- }
+- // we would need all active configurations to check for
+- // d->networkConfigurationManager.isOnline(), which is asynchronous
+- // and potentially expensive. We can just check the configuration here
+- d->online = (d->networkConfiguration.state() & QNetworkConfiguration::Active);
++ // if a session is required, we track online state through
++ // the QNetworkSession's signals if a request is already made.
++ // we need to track current accessibility state by default
++ //
++ connect(&d->networkConfigurationManager, SIGNAL(onlineStateChanged(bool)),
++ SLOT(_q_onlineStateChanged(bool)));
+ #endif
+ }
+
+@@ -946,7 +943,8 @@
+ void QNetworkAccessManager::setNetworkAccessible(QNetworkAccessManager::NetworkAccessibility accessible)
+ {
+ Q_D(QNetworkAccessManager);
+- d->defaultAccessControl = false;
++
++ d->defaultAccessControl = accessible == NotAccessible ? false : true;
+
+ if (d->networkAccessible != accessible) {
+ NetworkAccessibility previous = networkAccessible();
+@@ -965,6 +963,10 @@
+ QNetworkAccessManager::NetworkAccessibility QNetworkAccessManager::networkAccessible() const
+ {
+ Q_D(const QNetworkAccessManager);
++
++ if (d->networkConfiguration.state().testFlag(QNetworkConfiguration::Undefined))
++ return UnknownAccessibility;
++
+ if (d->networkSessionRequired) {
+ QSharedPointer<QNetworkSession> networkSession(d->getNetworkSession());
+ if (networkSession) {
+@@ -1622,32 +1624,56 @@
+ if (online) {
+ if (state != QNetworkSession::Connected && state != QNetworkSession::Roaming) {
+ online = false;
+- networkAccessible = QNetworkAccessManager::NotAccessible;
+- emit q->networkAccessibleChanged(networkAccessible);
++ if (networkAccessible != QNetworkAccessManager::NotAccessible) {
++ networkAccessible = QNetworkAccessManager::NotAccessible;
++ emit q->networkAccessibleChanged(networkAccessible);
++ }
+ }
+ } else {
+ if (state == QNetworkSession::Connected || state == QNetworkSession::Roaming) {
+ online = true;
+ if (defaultAccessControl)
+- networkAccessible = QNetworkAccessManager::Accessible;
+- emit q->networkAccessibleChanged(networkAccessible);
++ if (networkAccessible != QNetworkAccessManager::Accessible) {
++ networkAccessible = QNetworkAccessManager::Accessible;
++ emit q->networkAccessibleChanged(networkAccessible);
++ }
+ }
+ }
+ }
+
+ void QNetworkAccessManagerPrivate::_q_onlineStateChanged(bool isOnline)
+ {
+- // if the user set a config, we only care whether this one is active.
++ Q_Q(QNetworkAccessManager);
++ // if the user set a config, we only care whether this one is active.
+ // Otherwise, this QNAM is online if there is an online config.
+ if (customNetworkConfiguration) {
+ online = (networkConfiguration.state() & QNetworkConfiguration::Active);
+ } else {
+- if (isOnline && online != isOnline) {
+- networkSessionStrongRef.clear();
+- networkSessionWeakRef.clear();
++ if (online != isOnline) {
++ if (isOnline) {
++ networkSessionStrongRef.clear();
++ networkSessionWeakRef.clear();
++ }
++ online = isOnline;
++ }
++ }
++ if (online) {
++ if (defaultAccessControl) {
++ if (networkAccessible != QNetworkAccessManager::Accessible) {
++ networkAccessible = QNetworkAccessManager::Accessible;
++ emit q->networkAccessibleChanged(networkAccessible);
++ }
++ }
++ } else if (networkConfiguration.state().testFlag(QNetworkConfiguration::Undefined)) {
++ if (networkAccessible != QNetworkAccessManager::UnknownAccessibility) {
++ networkAccessible = QNetworkAccessManager::UnknownAccessibility;
++ emit q->networkAccessibleChanged(networkAccessible);
++ }
++ } else {
++ if (networkAccessible != QNetworkAccessManager::NotAccessible) {
++ networkAccessible = QNetworkAccessManager::NotAccessible;
++ emit q->networkAccessibleChanged(networkAccessible);
+ }
+-
+- online = isOnline;
+ }
+ }
+
+--- a/src/network/access/qnetworkaccessmanager_p.h
++++ b/src/network/access/qnetworkaccessmanager_p.h
+@@ -78,7 +78,6 @@
+ customNetworkConfiguration(false),
+ networkSessionRequired(networkConfigurationManager.capabilities()
+ & QNetworkConfigurationManager::NetworkSessionRequired),
+- networkAccessible(QNetworkAccessManager::Accessible),
+ activeReplyCount(0),
+ online(false),
+ initializeSession(true),
+@@ -86,7 +85,18 @@
+ cookieJarCreated(false),
+ defaultAccessControl(true),
+ authenticationManager(QSharedPointer<QNetworkAccessAuthenticationManager>::create())
+- { }
++ {
++#ifndef QT_NO_BEARERMANAGEMENT
++ // we would need all active configurations to check for
++ // d->networkConfigurationManager.isOnline(), which is asynchronous
++ // and potentially expensive. We can just check the configuration here
++ online = (networkConfiguration.state().testFlag(QNetworkConfiguration::Active));
++ if (online)
++ networkAccessible = QNetworkAccessManager::Accessible;
++ else
++ networkAccessible = QNetworkAccessManager::NotAccessible;
++#endif
++ }
+ ~QNetworkAccessManagerPrivate();
+
+ void _q_replyFinished();
+--- a/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp
++++ b/tests/auto/network/access/qnetworkaccessmanager/tst_qnetworkaccessmanager.cpp
+@@ -74,6 +74,10 @@
+ // if there is no session, we cannot know in which state we are in
+ QNetworkAccessManager::NetworkAccessibility initialAccessibility =
+ manager.networkAccessible();
++
++ if (initialAccessibility == QNetworkAccessManager::UnknownAccessibility)
++ QSKIP("Unknown accessibility", SkipAll);
++
+ QCOMPARE(manager.networkAccessible(), initialAccessibility);
+
+ manager.setNetworkAccessible(QNetworkAccessManager::NotAccessible);
+@@ -94,29 +98,28 @@
+ QCOMPARE(manager.networkAccessible(), initialAccessibility);
+
+ QNetworkConfigurationManager configManager;
+- bool sessionRequired = (configManager.capabilities()
+- & QNetworkConfigurationManager::NetworkSessionRequired);
+ QNetworkConfiguration defaultConfig = configManager.defaultConfiguration();
+ if (defaultConfig.isValid()) {
+ manager.setConfiguration(defaultConfig);
+
+- // the accessibility has not changed if no session is required
+- if (sessionRequired) {
++ QCOMPARE(spy.count(), 0);
++
++ if (defaultConfig.state().testFlag(QNetworkConfiguration::Active))
++ QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::Accessible);
++ else
++ QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::NotAccessible);
++
++ manager.setNetworkAccessible(QNetworkAccessManager::NotAccessible);
++
++ if (defaultConfig.state().testFlag(QNetworkConfiguration::Active)) {
+ QCOMPARE(spy.count(), 1);
+- QCOMPARE(spy.takeFirst().at(0).value<QNetworkAccessManager::NetworkAccessibility>(),
+- QNetworkAccessManager::Accessible);
++ QCOMPARE(QNetworkAccessManager::NetworkAccessibility(spy.takeFirst().at(0).toInt()),
++ QNetworkAccessManager::NotAccessible);
+ } else {
+ QCOMPARE(spy.count(), 0);
+ }
+- QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::Accessible);
+-
+- manager.setNetworkAccessible(QNetworkAccessManager::NotAccessible);
+-
+- QCOMPARE(spy.count(), 1);
+- QCOMPARE(QNetworkAccessManager::NetworkAccessibility(spy.takeFirst().at(0).toInt()),
+- QNetworkAccessManager::NotAccessible);
+- QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::NotAccessible);
+ }
++ QCOMPARE(manager.networkAccessible(), QNetworkAccessManager::NotAccessible);
+ #endif
+ }
+
diff --git a/debian/patches/qnetworkreply_abort_socket.diff b/debian/patches/qnetworkreply_abort_socket.diff
new file mode 100644
index 0000000..6489cb8
--- /dev/null
+++ b/debian/patches/qnetworkreply_abort_socket.diff
@@ -0,0 +1,113 @@
+Description: abort underlying socket when aborting QNetworkReply
+Origin: upstream, http://code.qt.io/cgit/qt/qtbase.git/commit/?id=f98c2ef27a4f6fa3
+Last-Update: 2015-11-17
+
+--- a/src/network/access/qhttpnetworkconnection.cpp
++++ b/src/network/access/qhttpnetworkconnection.cpp
+@@ -835,8 +835,13 @@
+ // if HTTP mandates we should close
+ // or the reply is not finished yet, e.g. it was aborted
+ // we have to close that connection
+- if (reply->d_func()->isConnectionCloseEnabled() || !reply->isFinished())
+- channels[i].close();
++ if (reply->d_func()->isConnectionCloseEnabled() || !reply->isFinished()) {
++ if (reply->isAborted()) {
++ channels[i].abort();
++ } else {
++ channels[i].close();
++ }
++ }
+
+ QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
+ return;
+--- a/src/network/access/qhttpnetworkconnectionchannel.cpp
++++ b/src/network/access/qhttpnetworkconnectionchannel.cpp
+@@ -205,6 +205,26 @@
+ }
+
+
++void QHttpNetworkConnectionChannel::abort()
++{
++ if (!socket)
++ state = QHttpNetworkConnectionChannel::IdleState;
++ else if (socket->state() == QAbstractSocket::UnconnectedState)
++ state = QHttpNetworkConnectionChannel::IdleState;
++ else
++ state = QHttpNetworkConnectionChannel::ClosingState;
++
++ // pendingEncrypt must only be true in between connected and encrypted states
++ pendingEncrypt = false;
++
++ if (socket) {
++ // socket can be 0 since the host lookup is done from qhttpnetworkconnection.cpp while
++ // there is no socket yet.
++ socket->abort();
++ }
++}
++
++
+ bool QHttpNetworkConnectionChannel::sendRequest()
+ {
+ Q_ASSERT(!protocolHandler.isNull());
+--- a/src/network/access/qhttpnetworkconnectionchannel_p.h
++++ b/src/network/access/qhttpnetworkconnectionchannel_p.h
+@@ -157,6 +157,7 @@
+
+ void init();
+ void close();
++ void abort();
+
+ bool sendRequest();
+
+--- a/src/network/access/qhttpnetworkreply.cpp
++++ b/src/network/access/qhttpnetworkreply.cpp
+@@ -247,6 +247,17 @@
+ return d->userProvidedDownloadBuffer;
+ }
+
++void QHttpNetworkReply::abort()
++{
++ Q_D(QHttpNetworkReply);
++ d->state = QHttpNetworkReplyPrivate::Aborted;
++}
++
++bool QHttpNetworkReply::isAborted() const
++{
++ return d_func()->state == QHttpNetworkReplyPrivate::Aborted;
++}
++
+ bool QHttpNetworkReply::isFinished() const
+ {
+ return d_func()->state == QHttpNetworkReplyPrivate::AllDoneState;
+--- a/src/network/access/qhttpnetworkreply_p.h
++++ b/src/network/access/qhttpnetworkreply_p.h
+@@ -121,6 +121,9 @@
+ void setUserProvidedDownloadBuffer(char*);
+ char* userProvidedDownloadBuffer();
+
++ void abort();
++
++ bool isAborted() const;
+ bool isFinished() const;
+
+ bool isPipeliningUsed() const;
+@@ -205,7 +208,8 @@
+ SPDYSYNSent,
+ SPDYUploading,
+ SPDYHalfClosed,
+- SPDYClosed
++ SPDYClosed,
++ Aborted
+ } state;
+
+ QHttpNetworkRequest request;
+--- a/src/network/access/qhttpthreaddelegate.cpp
++++ b/src/network/access/qhttpthreaddelegate.cpp
+@@ -396,6 +396,7 @@
+ qDebug() << "QHttpThreadDelegate::abortRequest() thread=" << QThread::currentThreadId() << "sync=" << synchronous;
+ #endif
+ if (httpReply) {
++ httpReply->abort();
+ delete httpReply;
+ httpReply = 0;
+ }
diff --git a/debian/patches/series b/debian/patches/series
index 540ebe0..e1548df 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -5,6 +5,8 @@ bsd_volumeinfo.diff
hurd_forkfd.diff
mips_no_atomic.diff
detect_64bit_atomic.diff
+qnetworkreply_abort_socket.diff
+qnetworkaccessmanager_accessibility.diff
# Debian specific.
gnukfreebsd.diff
--
qtbase packaging
More information about the pkg-kde-commits
mailing list