Merge remote-tracking branch 'origin/5.13' into dev

 Conflicts:
	src/corelib/global/qlogging.cpp
	src/gui/painting/qtextureglyphcache_p.h
	src/gui/text/qfontengine.cpp
	src/widgets/widgets/qlineedit.cpp

Change-Id: Ic8798538df466b7141caa8bbf1fb7605eb56be37

3 files changed, 74 insertions, 84 deletions

diff --git a/src/network/kernel/qhostinfo.cpp b/src/network/kernel/qhostinfo.cpp
index 6caee5e097..c17ba38e36 100644
--- a/src/network/kernel/qhostinfo.cpp
+++ b/src/network/kernel/qhostinfo.cpp
@@ -891,7 +891,9 @@ QHostInfoLookupManager::QHostInfoLookupManager() : wasDeleted(false)
 
 QHostInfoLookupManager::~QHostInfoLookupManager()
 {
+    QMutexLocker locker(&mutex);
     wasDeleted = true;
+    locker.unlock();
 
     // don't qDeleteAll currentLookups, the QThreadPool has ownership
     clear();
@@ -919,6 +921,8 @@ void QHostInfoLookupManager::clear()
 
 void QHostInfoLookupManager::work()
 {
+    QMutexLocker locker(&mutex);
+
     if (wasDeleted)
         return;
 
@@ -926,8 +930,6 @@ void QHostInfoLookupManager::work()
     //  - launch new lookups via the thread pool
     //  - make sure only one lookup per host/IP is in progress
 
-    QMutexLocker locker(&mutex);
-
     if (!finishedLookups.isEmpty()) {
         // remove ID from aborted if it is in there
         for (int i = 0; i < finishedLookups.length(); i++) {
@@ -979,10 +981,11 @@ void QHostInfoLookupManager::work()
 // called by QHostInfo
 void QHostInfoLookupManager::scheduleLookup(QHostInfoRunnable *r)
 {
+    QMutexLocker locker(&this->mutex);
+
     if (wasDeleted)
         return;
 
-    QMutexLocker locker(&this->mutex);
     scheduledLookups.enqueue(r);
     work();
 }
@@ -990,11 +993,11 @@ void QHostInfoLookupManager::scheduleLookup(QHostInfoRunnable *r)
 // called by QHostInfo
 void QHostInfoLookupManager::abortLookup(int id)
 {
+    QMutexLocker locker(&this->mutex);
+
     if (wasDeleted)
         return;
 
-    QMutexLocker locker(&this->mutex);
-
 #if QT_CONFIG(thread)
     // is postponed? delete and return
     for (int i = 0; i < postponedLookups.length(); i++) {
@@ -1020,20 +1023,22 @@ void QHostInfoLookupManager::abortLookup(int id)
 // called from QHostInfoRunnable
 bool QHostInfoLookupManager::wasAborted(int id)
 {
+    QMutexLocker locker(&this->mutex);
+
     if (wasDeleted)
         return true;
 
-    QMutexLocker locker(&this->mutex);
     return abortedLookups.contains(id);
 }
 
 // called from QHostInfoRunnable
 void QHostInfoLookupManager::lookupFinished(QHostInfoRunnable *r)
 {
+    QMutexLocker locker(&this->mutex);
+
     if (wasDeleted)
         return;
 
-    QMutexLocker locker(&this->mutex);
 #if QT_CONFIG(thread)
     currentLookups.removeOne(r);
 #endif
@@ -1095,23 +1100,10 @@ void qt_qhostinfo_cache_inject(const QString &hostname, const QHostInfo &resolut
 QHostInfoCache::QHostInfoCache() : max_age(60), enabled(true), cache(128)
 {
 #ifdef QT_QHOSTINFO_CACHE_DISABLED_BY_DEFAULT
-    enabled = false;
+    enabled.store(false, std::memory_order_relaxed);
 #endif
 }
 
-bool QHostInfoCache::isEnabled()
-{
-    return enabled;
-}
-
-// this function is currently only used for the auto tests
-// and not usable by public API
-void QHostInfoCache::setEnabled(bool e)
-{
-    enabled = e;
-}
-
-
 QHostInfo QHostInfoCache::get(const QString &name, bool *valid)
 {
     QMutexLocker locker(&this->mutex);
diff --git a/src/network/kernel/qhostinfo_p.h b/src/network/kernel/qhostinfo_p.h
index 7df3f5414c..0433d1d17b 100644
--- a/src/network/kernel/qhostinfo_p.h
+++ b/src/network/kernel/qhostinfo_p.h
@@ -73,6 +73,7 @@
 #include <QNetworkSession>
 #include <QSharedPointer>
 
+#include <atomic>
 
 QT_BEGIN_NAMESPACE
 
@@ -177,10 +178,12 @@ public:
     void put(const QString &name, const QHostInfo &info);
     void clear();
 
-    bool isEnabled();
-    void setEnabled(bool e);
+    bool isEnabled() { return enabled.load(std::memory_order_relaxed); }
+    // this function is currently only used for the auto tests
+    // and not usable by public API
+    void setEnabled(bool e) { enabled.store(e, std::memory_order_relaxed); }
 private:
-    bool enabled;
+    std::atomic<bool> enabled;
     struct QHostInfoCacheElement {
         QHostInfo info;
         QElapsedTimer age;
diff --git a/src/network/socket/qnativesocketengine_win.cpp b/src/network/socket/qnativesocketengine_win.cpp
index b429b3c365..9edabd7822 100644
--- a/src/network/socket/qnativesocketengine_win.cpp
+++ b/src/network/socket/qnativesocketengine_win.cpp
@@ -623,6 +623,53 @@ bool QNativeSocketEnginePrivate::fetchConnectionParameters()
 }
 
 
+static void setErrorFromWSAError(int error, QNativeSocketEnginePrivate *d)
+{
+    Q_ASSERT(d);
+    switch (error) {
+    case WSAEISCONN:
+        d->socketState = QAbstractSocket::ConnectedState;
+        break;
+    case WSAEHOSTUNREACH:
+        d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::HostUnreachableErrorString);
+        d->socketState = QAbstractSocket::UnconnectedState;
+        break;
+    case WSAEADDRNOTAVAIL:
+        d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::AddressNotAvailableErrorString);
+        d->socketState = QAbstractSocket::UnconnectedState;
+        break;
+    case WSAEINPROGRESS:
+        d->setError(QAbstractSocket::UnfinishedSocketOperationError, QNativeSocketEnginePrivate::InvalidSocketErrorString);
+        d->socketState = QAbstractSocket::ConnectingState;
+        break;
+    case WSAEADDRINUSE:
+        d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::AddressInuseErrorString);
+        break;
+    case WSAECONNREFUSED:
+        d->setError(QAbstractSocket::ConnectionRefusedError, QNativeSocketEnginePrivate::ConnectionRefusedErrorString);
+        d->socketState = QAbstractSocket::UnconnectedState;
+        break;
+    case WSAETIMEDOUT:
+        d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::ConnectionTimeOutErrorString);
+        d->socketState = QAbstractSocket::UnconnectedState;
+        break;
+    case WSAEACCES:
+        d->setError(QAbstractSocket::SocketAccessError, QNativeSocketEnginePrivate::AccessErrorString);
+        d->socketState = QAbstractSocket::UnconnectedState;
+        break;
+    case WSAENETUNREACH:
+        d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::NetworkUnreachableErrorString);
+        d->socketState = QAbstractSocket::UnconnectedState;
+        break;
+    case WSAEINVAL:
+    case WSAEALREADY:
+        d->setError(QAbstractSocket::UnfinishedSocketOperationError, QNativeSocketEnginePrivate::InvalidSocketErrorString);
+        break;
+    default:
+        break;
+    }
+}
+
 bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &address, quint16 port)
 {
 
@@ -651,9 +698,6 @@ bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &address, quin
             case WSANOTINITIALISED:
                 //###
                 break;
-            case WSAEISCONN:
-                socketState = QAbstractSocket::ConnectedState;
-                break;
             case WSAEWOULDBLOCK: {
                 // If WSAConnect returns WSAEWOULDBLOCK on the second
                 // connection attempt, we have to check SO_ERROR's
@@ -668,82 +712,33 @@ bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &address, quin
                 do {
                     if (::getsockopt(socketDescriptor, SOL_SOCKET, SO_ERROR, (char *) &value, &valueSize) == 0) {
                         if (value != NOERROR) {
+                            WS_ERROR_DEBUG(value);
+                            errorDetected = true;
                             // MSDN says getsockopt with SO_ERROR clears the error, but it's not actually cleared
                             // and this can affect all subsequent WSAConnect attempts, so clear it now.
                             const int val = NO_ERROR;
                             ::setsockopt(socketDescriptor, SOL_SOCKET, SO_ERROR, reinterpret_cast<const char*>(&val), sizeof val);
-                        }
-
-                        if (value == WSAECONNREFUSED) {
-                            setError(QAbstractSocket::ConnectionRefusedError, ConnectionRefusedErrorString);
-                            socketState = QAbstractSocket::UnconnectedState;
-                            errorDetected = true;
-                            break;
-                        }
-                        if (value == WSAETIMEDOUT) {
-                            setError(QAbstractSocket::NetworkError, ConnectionTimeOutErrorString);
-                            socketState = QAbstractSocket::UnconnectedState;
-                            errorDetected = true;
-                            break;
-                        }
-                        if (value == WSAEHOSTUNREACH) {
-                            setError(QAbstractSocket::NetworkError, HostUnreachableErrorString);
-                            socketState = QAbstractSocket::UnconnectedState;
-                            errorDetected = true;
-                            break;
-                        }
-                        if (value == WSAEADDRNOTAVAIL) {
-                            setError(QAbstractSocket::NetworkError, AddressNotAvailableErrorString);
-                            socketState = QAbstractSocket::UnconnectedState;
-                            errorDetected = true;
-                            break;
-                        }
-                        if (value == NOERROR) {
+                        } else {
                             // When we get WSAEWOULDBLOCK the outcome was not known, so a
                             // NOERROR might indicate that the result of the operation
                             // is still unknown. We try again to increase the chance that we did
                             // get the correct result.
                             tryAgain = !tryAgain;
                         }
+                        setErrorFromWSAError(value, this);
                     }
                     tries++;
                 } while (tryAgain && (tries < 2));
 
                 if (errorDetected)
                     break;
+                // fall through to unfinished operation error handling
+                err = WSAEINPROGRESS;
                 Q_FALLTHROUGH();
             }
-            case WSAEINPROGRESS:
-                setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString);
-                socketState = QAbstractSocket::ConnectingState;
-                break;
-            case WSAEADDRINUSE:
-                setError(QAbstractSocket::NetworkError, AddressInuseErrorString);
-                break;
-            case WSAECONNREFUSED:
-                setError(QAbstractSocket::ConnectionRefusedError, ConnectionRefusedErrorString);
-                socketState = QAbstractSocket::UnconnectedState;
-                break;
-            case WSAETIMEDOUT:
-                setError(QAbstractSocket::NetworkError, ConnectionTimeOutErrorString);
-                break;
-            case WSAEACCES:
-                setError(QAbstractSocket::SocketAccessError, AccessErrorString);
-                socketState = QAbstractSocket::UnconnectedState;
-                break;
-            case WSAEHOSTUNREACH:
-                setError(QAbstractSocket::NetworkError, HostUnreachableErrorString);
-                socketState = QAbstractSocket::UnconnectedState;
-                break;
-            case WSAENETUNREACH:
-                setError(QAbstractSocket::NetworkError, NetworkUnreachableErrorString);
-                socketState = QAbstractSocket::UnconnectedState;
-                break;
-            case WSAEINVAL:
-            case WSAEALREADY:
-                setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString);
-                break;
+
             default:
+                setErrorFromWSAError(err, this);
                 break;
             }
             if (socketState != QAbstractSocket::ConnectedState) {