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

Based on merge done by Liang Qi

Change-Id: Id566e5b9f284d29bff2199f13f9417c660f5b26f

2 files changed, 57 insertions, 23 deletions

diff --git a/src/corelib/kernel/qfunctions_fake_env_p.h b/src/corelib/kernel/qfunctions_fake_env_p.h
index 8b1ab44696..b4c5ffb079 100644
--- a/src/corelib/kernel/qfunctions_fake_env_p.h
+++ b/src/corelib/kernel/qfunctions_fake_env_p.h
@@ -46,51 +46,72 @@
 //
 
 #include "qbytearray.h"
-#include "qhash.h"
+#include "qvector.h"
 
 QT_BEGIN_NAMESPACE
 
 // Environment ------------------------------------------------------
-Q_CORE_EXPORT QHash<QByteArray, QByteArray> &qt_app_environment()
-{
-    static QHash<QByteArray, QByteArray> internalEnvironment;
-    return internalEnvironment;
-}
+struct Variable {
+    Variable() { }
+
+    Variable(const QByteArray &name, const QByteArray &value)
+        : name(name), value(value) { }
+
+    QByteArray name;
+    QByteArray value;
+};
+
+Q_DECLARE_TYPEINFO(Variable, Q_MOVABLE_TYPE);
+
+struct NameEquals {
+    typedef bool result_type;
+    const char *name;
+    explicit NameEquals(const char *name) Q_DECL_NOTHROW : name(name) {}
+    result_type operator()(const Variable &other) const Q_DECL_NOTHROW
+    { return qstrcmp(other.name, name) == 0; }
+};
+
+Q_GLOBAL_STATIC(QVector<Variable>, qt_app_environment)
 
 errno_t qt_fake_getenv_s(size_t *sizeNeeded, char *buffer, size_t bufferSize, const char *varName)
 {
     if (!sizeNeeded)
         return EINVAL;
 
-    QHash<QByteArray, QByteArray>::const_iterator iterator = qt_app_environment().constFind(varName);
-    if (iterator == qt_app_environment().constEnd()) {
+    QVector<Variable>::const_iterator end = qt_app_environment->constEnd();
+    QVector<Variable>::const_iterator iterator = std::find_if(qt_app_environment->constBegin(),
+                                                              end,
+                                                              NameEquals(varName));
+    if (iterator == end) {
         if (buffer)
             buffer[0] = '\0';
         return ENOENT;
     }
 
-    const int size = iterator->size() + 1;
+    const int size = iterator->value.size() + 1;
     if (bufferSize < size_t(size)) {
         *sizeNeeded = size;
         return ERANGE;
     }
 
-    qstrcpy(buffer, iterator->constData());
+    qstrcpy(buffer, iterator->value.constData());
     return 0;
 }
 
 errno_t qt_fake__putenv_s(const char *varName, const char *value)
 {
-    QHash<QByteArray, QByteArray>::iterator iterator = qt_app_environment().find(varName);
-    QHash<QByteArray, QByteArray>::iterator end = qt_app_environment().end();
+    QVector<Variable>::iterator end = qt_app_environment->end();
+    QVector<Variable>::iterator iterator = std::find_if(qt_app_environment->begin(),
+                                                        end,
+                                                        NameEquals(varName));
     if (!value || !*value) {
         if (iterator != end)
-            qt_app_environment().erase(iterator);
+            qt_app_environment->erase(iterator);
     } else {
         if (iterator == end)
-            qt_app_environment()[varName] = QByteArray(value);
+            qt_app_environment->append(Variable(varName, value));
         else
-            (*iterator) = value;
+            iterator->value = value;
     }
 
     return 0;
diff --git a/src/corelib/kernel/qfunctions_winrt.h b/src/corelib/kernel/qfunctions_winrt.h
index ee4e050793..dc1cbe0ade 100644
--- a/src/corelib/kernel/qfunctions_winrt.h
+++ b/src/corelib/kernel/qfunctions_winrt.h
@@ -40,6 +40,7 @@
 
 #include <QtCore/QThread>
 #include <QtCore/QAbstractEventDispatcher>
+#include <QtCore/QElapsedTimer>
 #include <QtCore/qt_windows.h>
 
 // Convenience macros for handling HRESULT values
@@ -160,7 +161,7 @@ enum AwaitStyle
 };
 
 template <typename T>
-static inline HRESULT _await_impl(const Microsoft::WRL::ComPtr<T> &asyncOp, AwaitStyle awaitStyle)
+static inline HRESULT _await_impl(const Microsoft::WRL::ComPtr<T> &asyncOp, AwaitStyle awaitStyle, uint timeout)
 {
     Microsoft::WRL::ComPtr<IAsyncInfo> asyncInfo;
     HRESULT hr = asyncOp.As(&asyncInfo);
@@ -168,22 +169,34 @@ static inline HRESULT _await_impl(const Microsoft::WRL::ComPtr<T> &asyncOp, Awai
         return hr;
 
     AsyncStatus status;
+    QElapsedTimer t;
+    if (timeout)
+        t.start();
     switch (awaitStyle) {
     case ProcessMainThreadEvents:
-        while (SUCCEEDED(hr = asyncInfo->get_Status(&status)) && status == Started)
+        while (SUCCEEDED(hr = asyncInfo->get_Status(&status)) && status == Started) {
             QCoreApplication::processEvents();
+            if (timeout && t.hasExpired(timeout))
+                return ERROR_TIMEOUT;
+        }
         break;
     case ProcessThreadEvents:
         if (QAbstractEventDispatcher *dispatcher = QThread::currentThread()->eventDispatcher()) {
-            while (SUCCEEDED(hr = asyncInfo->get_Status(&status)) && status == Started)
+            while (SUCCEEDED(hr = asyncInfo->get_Status(&status)) && status == Started) {
                 dispatcher->processEvents(QEventLoop::AllEvents);
+                if (timeout && t.hasExpired(timeout))
+                    return ERROR_TIMEOUT;
+            }
             break;
         }
         // fall through
     default:
     case YieldThread:
-        while (SUCCEEDED(hr = asyncInfo->get_Status(&status)) && status == Started)
+        while (SUCCEEDED(hr = asyncInfo->get_Status(&status)) && status == Started) {
             QThread::yieldCurrentThread();
+            if (timeout && t.hasExpired(timeout))
+                return ERROR_TIMEOUT;
+        }
         break;
     }
 
@@ -199,9 +212,9 @@ static inline HRESULT _await_impl(const Microsoft::WRL::ComPtr<T> &asyncOp, Awai
 }
 
 template <typename T>
-static inline HRESULT await(const Microsoft::WRL::ComPtr<T> &asyncOp, AwaitStyle awaitStyle = YieldThread)
+static inline HRESULT await(const Microsoft::WRL::ComPtr<T> &asyncOp, AwaitStyle awaitStyle = YieldThread, uint timeout = 0)
 {
-    HRESULT hr = _await_impl(asyncOp, awaitStyle);
+    HRESULT hr = _await_impl(asyncOp, awaitStyle, timeout);
     if (FAILED(hr))
         return hr;
 
@@ -209,9 +222,9 @@ static inline HRESULT await(const Microsoft::WRL::ComPtr<T> &asyncOp, AwaitStyle
 }
 
 template <typename T, typename U>
-static inline HRESULT await(const Microsoft::WRL::ComPtr<T> &asyncOp, U *results, AwaitStyle awaitStyle = YieldThread)
+static inline HRESULT await(const Microsoft::WRL::ComPtr<T> &asyncOp, U *results, AwaitStyle awaitStyle = YieldThread, uint timeout = 0)
 {
-    HRESULT hr = _await_impl(asyncOp, awaitStyle);
+    HRESULT hr = _await_impl(asyncOp, awaitStyle, timeout);
     if (FAILED(hr))
         return hr;