Merge dev into 5.8

Change-Id: I41ee7b50534b01cf042bed8bb8824ba2e5026a29

17 files changed, 1265 insertions, 32 deletions

diff --git a/src/corelib/kernel/kernel.pri b/src/corelib/kernel/kernel.pri
index 39fe61ea4e..a78397e46c 100644
--- a/src/corelib/kernel/kernel.pri
+++ b/src/corelib/kernel/kernel.pri
@@ -4,6 +4,8 @@ HEADERS += \
         kernel/qabstracteventdispatcher.h \
         kernel/qabstractnativeeventfilter.h \
         kernel/qbasictimer.h \
+        kernel/qdeadlinetimer.h \
+        kernel/qdeadlinetimer_p.h \
         kernel/qelapsedtimer.h \
         kernel/qeventloop.h\
         kernel/qpointer.h \
@@ -46,6 +48,7 @@ SOURCES += \
         kernel/qabstracteventdispatcher.cpp \
         kernel/qabstractnativeeventfilter.cpp \
         kernel/qbasictimer.cpp \
+        kernel/qdeadlinetimer.cpp \
         kernel/qelapsedtimer.cpp \
         kernel/qeventloop.cpp \
         kernel/qcoreapplication.cpp \
@@ -120,6 +123,11 @@ mac {
         # We need UIKit for UIDevice
         LIBS_PRIVATE += -framework UIKit
     }
+
+    watchos {
+        # We need WatchKit for WKExtension in qeventdispatcher_cf.mm
+        LIBS_PRIVATE += -framework WatchKit
+    }
 }
 
 nacl {
@@ -144,21 +152,20 @@ unix|integrity {
             kernel/qpoll_p.h \
             kernel/qtimerinfo_unix_p.h
 
-    contains(QT_CONFIG, poll_select): SOURCES += kernel/qpoll.cpp
-    contains(QT_CONFIG, poll_poll): DEFINES += QT_HAVE_POLL
-    contains(QT_CONFIG, poll_ppoll): DEFINES += QT_HAVE_POLL QT_HAVE_PPOLL
-    contains(QT_CONFIG, poll_pollts): DEFINES += QT_HAVE_POLL QT_HAVE_POLLTS
+    qtConfig(poll_select): SOURCES += kernel/qpoll.cpp
+    qtConfig(poll_poll): DEFINES += QT_HAVE_POLL
+    qtConfig(poll_ppoll): DEFINES += QT_HAVE_POLL QT_HAVE_PPOLL
+    qtConfig(poll_pollts): DEFINES += QT_HAVE_POLL QT_HAVE_POLLTS
 
-    contains(QT_CONFIG, glib) {
+    qtConfig(glib) {
         SOURCES += \
             kernel/qeventdispatcher_glib.cpp
         HEADERS += \
             kernel/qeventdispatcher_glib_p.h
-        QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_GLIB
-        LIBS_PRIVATE +=$$QMAKE_LIBS_GLIB
+        QMAKE_USE_PRIVATE += glib
     }
 
-   contains(QT_CONFIG, clock-gettime):include($$QT_SOURCE_TREE/config.tests/unix/clock-gettime/clock-gettime.pri)
+   qtConfig(clock-gettime): include($$QT_SOURCE_TREE/config.tests/unix/clock-gettime/clock-gettime.pri)
 
     !android {
         SOURCES += kernel/qsharedmemory_posix.cpp \
@@ -181,7 +188,7 @@ vxworks {
 }
 
 qqnx_pps {
-        LIBS_PRIVATE += -lpps
+        QMAKE_USE_PRIVATE += pps
         SOURCES += \
                 kernel/qppsattribute.cpp \
                 kernel/qppsobject.cpp
diff --git a/src/corelib/kernel/qcore_mac_objc.mm b/src/corelib/kernel/qcore_mac_objc.mm
index 068b6b0440..ee1a290386 100644
--- a/src/corelib/kernel/qcore_mac_objc.mm
+++ b/src/corelib/kernel/qcore_mac_objc.mm
@@ -101,7 +101,7 @@ QT_FOR_EACH_MUTABLE_CORE_GRAPHICS_TYPE(QT_DECLARE_WEAK_QDEBUG_OPERATOR_FOR_CF_TY
 QAppleOperatingSystemVersion qt_apple_os_version()
 {
     QAppleOperatingSystemVersion v = {0, 0, 0};
-#if QT_MAC_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_10_10, __IPHONE_8_0) || defined(Q_OS_TVOS)
+#if QT_MAC_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_10_10, __IPHONE_8_0) || defined(Q_OS_TVOS) || defined(Q_OS_WATCHOS)
     if ([NSProcessInfo instancesRespondToSelector:@selector(operatingSystemVersion)]) {
         NSOperatingSystemVersion osv = NSProcessInfo.processInfo.operatingSystemVersion;
         v.major = osv.majorVersion;
diff --git a/src/corelib/kernel/qcore_unix_p.h b/src/corelib/kernel/qcore_unix_p.h
index c393609188..b5756af994 100644
--- a/src/corelib/kernel/qcore_unix_p.h
+++ b/src/corelib/kernel/qcore_unix_p.h
@@ -299,7 +299,7 @@ static inline int qt_safe_close(int fd)
 #undef QT_CLOSE
 #define QT_CLOSE qt_safe_close
 
-// - VxWorks & iOS/tvOS don't have processes
+// - VxWorks & iOS/tvOS/watchOS don't have processes
 #if !defined(Q_OS_VXWORKS) && !defined(QT_NO_PROCESS)
 static inline int qt_safe_execve(const char *filename, char *const argv[],
                                  char *const envp[])
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index 72645b4d9b..0413e06665 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -72,7 +72,7 @@
 
 #ifndef QT_NO_QOBJECT
 #if defined(Q_OS_UNIX)
-# if defined(Q_OS_OSX)
+# if defined(Q_OS_DARWIN)
 #  include "qeventdispatcher_cf_p.h"
 # else
 #  if !defined(QT_NO_GLIB)
@@ -483,7 +483,7 @@ void QCoreApplicationPrivate::createEventDispatcher()
 {
     Q_Q(QCoreApplication);
 #if defined(Q_OS_UNIX)
-#  if defined(Q_OS_OSX)
+#  if defined(Q_OS_DARWIN)
     bool ok = false;
     int value = qEnvironmentVariableIntValue("QT_EVENT_DISPATCHER_CORE_FOUNDATION", &ok);
     if (ok && value > 0)
@@ -687,7 +687,7 @@ QCoreApplication::QCoreApplication(QCoreApplicationPrivate &p)
 
     If you are doing graphical changes inside a loop that does not
     return to the event loop on asynchronous window systems like X11
-    or double buffered window systems like Quartz (OS X and iOS), and you want to
+    or double buffered window systems like Quartz (\macos and iOS), and you want to
     visualize these changes immediately (e.g. Splash Screens), call
     this function.
 
@@ -2059,7 +2059,7 @@ void QCoreApplicationPrivate::setApplicationFilePath(const QString &path)
     directory, and you run the \c{regexp} example, this function will
     return "C:/Qt/examples/tools/regexp".
 
-    On OS X and iOS this will point to the directory actually containing
+    On \macos and iOS this will point to the directory actually containing
     the executable, which may be inside an application bundle (if the
     application is bundled).
 
diff --git a/src/corelib/kernel/qcoreevent.cpp b/src/corelib/kernel/qcoreevent.cpp
index 00c120093f..e3d0185004 100644
--- a/src/corelib/kernel/qcoreevent.cpp
+++ b/src/corelib/kernel/qcoreevent.cpp
@@ -174,7 +174,7 @@ QT_BEGIN_NAMESPACE
     \value NonClientAreaMouseButtonPress    A mouse button press occurred outside the client area.
     \value NonClientAreaMouseButtonRelease  A mouse button release occurred outside the client area.
     \value NonClientAreaMouseMove           A mouse move occurred outside the client area.
-    \value MacSizeChange                    The user changed his widget sizes (OS X only).
+    \value MacSizeChange                    The user changed his widget sizes (\macos only).
     \value MetaCall                         An asynchronous method invocation via QMetaObject::invokeMethod().
     \value ModifiedChange                   Widgets modification state has been changed.
     \value MouseButtonDblClick              Mouse press again (QMouseEvent).
@@ -219,7 +219,7 @@ QT_BEGIN_NAMESPACE
     \omitvalue ThemeChange
     \value ThreadChange                     The object is moved to another thread. This is the last event sent to this object in the previous thread. See QObject::moveToThread().
     \value Timer                            Regular timer events (QTimerEvent).
-    \value ToolBarChange                    The toolbar button is toggled on OS X.
+    \value ToolBarChange                    The toolbar button is toggled on \macos.
     \value ToolTip                          A tooltip was requested (QHelpEvent).
     \value ToolTipChange                    The widget's tooltip has changed.
     \value TouchBegin                       Beginning of a sequence of touch-screen or track-pad events (QTouchEvent).
diff --git a/src/corelib/kernel/qdeadlinetimer.cpp b/src/corelib/kernel/qdeadlinetimer.cpp
new file mode 100644
index 0000000000..7906b29ece
--- /dev/null
+++ b/src/corelib/kernel/qdeadlinetimer.cpp
@@ -0,0 +1,827 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Intel Corporation.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdeadlinetimer.h"
+#include "qdeadlinetimer_p.h"
+#include <qpair.h>
+
+QT_BEGIN_NAMESPACE
+
+Q_DECL_CONST_FUNCTION static inline QPair<qint64, qint64> toSecsAndNSecs(qint64 nsecs)
+{
+    qint64 secs = nsecs / (1000*1000*1000);
+    if (nsecs < 0)
+        --secs;
+    nsecs -= secs * 1000*1000*1000;
+    return qMakePair(secs, nsecs);
+}
+
+/*!
+    \class QDeadlineTimer
+    \inmodule QtCore
+    \brief The QDeadlineTimer class marks a deadline in the future.
+    \since 5.8
+
+    \reentrant
+    \ingroup tools
+
+    The QDeadlineTimer class is usually used to calculate future deadlines and
+    verify whether the deadline has expired. QDeadlineTimer can also be used
+    for deadlines without expiration ("forever"). It forms a counterpart to
+    QElapsedTimer, which calculates how much time has elapsed since
+    QElapsedTimer::start() was called.
+
+    QDeadlineTimer provides a more convenient API compared to
+    QElapsedTimer::hasExpired().
+
+    The typical use-case for the class is to create a QDeadlineTimer before the
+    operation in question is started, and then use remainingTime() or
+    hasExpired() to determine whether to continue trying the operation.
+    QDeadlineTimer objects can be passed to functions being called to execute
+    this operation so they know how long to still operate.
+
+    \code
+    void executeOperation(int msecs)
+    {
+        QDeadlineTimer deadline(msecs);
+        do {
+            if (readFromDevice(deadline.remainingTime())
+                break;
+            waitForReadyRead(deadline);
+        } while (!deadline.hasExpired());
+    }
+    \endcode
+
+    Many QDeadlineTimer functions deal with time out values, which all are
+    measured in milliseconds. There are two special values, the same as many
+    other Qt functions named \c{waitFor} or similar:
+
+    \list
+      \o 0: no time left, expired
+      \o -1: infinite time left, timer never expires
+    \endlist
+
+    \section1 Reference Clocks
+
+    QDeadlineTimer will use the same clock as QElapsedTimer (see
+    QElapsedTimer::clockType() and QElapsedTimer::isMonotonic()).
+
+    \section1 Timer types
+
+    Like QTimer, QDeadlineTimer can select among different levels of coarseness
+    on the timers. You can select precise timing by passing Qt::PreciseTimer to
+    the functions that set of change the timer, or you can select coarse timing
+    by passing Qt::CoarseTimer. Qt::VeryCoarseTimer is currently interpreted
+    the same way as Qt::CoarseTimer.
+
+    This feature is dependent on support from the operating system: if the OS
+    does not support a coarse timer functionality, then QDeadlineTimer will
+    behave like Qt::PreciseTimer was passed.
+
+    QDeadlineTimer defaults to Qt::CoarseTimer because on operating systems
+    that do support coarse timing, making timing calls to that clock source is
+    often much more efficient. The level of coarseness depends on the
+    operating system, but should be in the order of a couple of milliseconds.
+
+    \section1 \c{std::chrono} Compatibility
+
+    QDeadlineTimer is compatible with the \c{std::chrono} API from C++11 and
+    can be constructed from or compared to both \c{std::chrono::duration} and
+    \c{std::chrono::time_point} objects. In addition, it is fully compatible
+    with the time literals from C++14, which allow one to write code as:
+
+    \code
+        using namespace std::chrono;
+
+        QDeadlineTimer deadline(30s);
+        device->waitForReadyRead(deadline);
+        if (deadline.remainingTime<nanoseconds>() > 300ms)
+            cleanup();
+    \endcode
+
+    As can be seen in the example above, QDeadlineTimer offers a templated
+    version of remainingTime() and deadline() that can be used to return
+    \c{std::chrono} objects.
+
+    Note that comparing to \c{time_point} is not as efficient as comparing to
+    \c{duration}, since QDeadlineTimer may need to convert from its own
+    internal clock source to the clock source used by the \c{time_point} object.
+    Also note that, due to this conversion, the deadlines will not be precise,
+    so the following code is not expected to compare equally:
+
+    \code
+        using namespace std::chrono;
+        auto now = steady_clock::now();
+        QDeadlineTimer deadline(now + 1s);
+        Q_ASSERT(deadline == now + 1s);
+    \endcode
+
+    \sa QTime, QTimer, QDeadlineTimer, Qt::TimerType
+*/
+
+/*!
+    \enum QDeadlineTimer::ForeverConstant
+
+    \value Forever      Used when creating a QDeadlineTimer to indicate the
+                        deadline should not expire
+*/
+
+/*!
+    \fn QDeadlineTimer::QDeadlineTimer(Qt::TimerType timerType)
+
+    Constructs an expired QDeadlineTimer object. For this object,
+    remainingTime() will return 0.
+
+    The timer type \a timerType may be ignored, since the timer is already
+    expired. Similarly, for optimization purposes, this function will not
+    attempt to obtain the current time and will use a value known to be in the
+    past. Therefore, deadline() may return an unexpected value and this object
+    cannot be used in calculation of how long it is overdue. If that
+    functionality is required, use QDeadlineTimer::current().
+
+    \sa hasExpired(), remainingTime(), timerType(), current()
+*/
+
+/*!
+    \fn QDeadlineTimer::QDeadlineTimer(ForeverConstant, Qt::TimerType timerType)
+
+    Constructs a QDeadlineTimer object that never expires. For this object,
+    remainingTime() will return -1, deadline() will return the maximum value,
+    and isForever() will return true.
+
+    The timer type \a timerType may be ignored, since the timer is already
+    expired.
+
+    \sa hasExpired(), isForever(), remainingTime(), timerType()
+*/
+
+/*!
+    Constructs a QDeadlineTimer object with an expiry time of \a msecs msecs
+    from the moment of the creation of this object, if msecs is positive. If \a
+    msecs is zero, this QDeadlineTimer will be marked as expired, causing
+    remainingTime() to return zero and deadline() to return an indeterminate
+    time point in the past. If \a msecs is -1, the timer will be set it to
+    never expire, causing remainingTime() to return -1 and deadline() to return
+    the maximum value.
+
+    The QDeadlineTimer object will be constructed with a timer type of \a
+    timerType.
+
+    For optimization purposes, if \a msecs is zero, this function may skip
+    obtaining the current time and may instead use a value known to be in the
+    past. If that happens, deadline() may return an unexpected value and this
+    object cannot be used in calculation of how long it is overdue. If that
+    functionality is required, use QDeadlineTimer::current() and add time to
+    it.
+
+    \sa hasExpired(), isForever(), remainingTime(), setRemainingTime()
+*/
+QDeadlineTimer::QDeadlineTimer(qint64 msecs, Qt::TimerType type) Q_DECL_NOTHROW
+    : t2(0)
+{
+    setRemainingTime(msecs, type);
+}
+
+/*!
+    \fn QDeadlineTimer::QDeadlineTimer(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type)
+
+    Constructs a QDeadlineTimer object with a deadline at \a deadline time
+    point, converting from the clock source \c{Clock} to Qt's internal clock
+    source (see QElapsedTimer::clcokType()).
+
+    If \a deadline is in the past, this QDeadlineTimer object is set to
+    expired, whereas if \a deadline is equal to \c{Duration::max()}, then this
+    object is set to never expire.
+
+    The QDeadlineTimer object will be constructed with a timer type of \a
+    timerType.
+
+    \sa hasExpired(), isForever(), remainingTime<Duration>(), setDeadline()
+*/
+
+/*!
+    \fn QDeadlineTimer::QDeadlineTimer(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type)
+
+    Constructs a QDeadlineTimer object with a remaining time of \a remaining.
+    If \a remaining is zero or negative, this QDeadlineTimer object will be
+    mark as expired, whereas if \a remaining is equal to \c{duration::max()},
+    the object will be set to never expire.
+
+    The QDeadlineTimer object will be constructed with a timer type of \a
+    timerType.
+
+    This constructor can be used with C++14's user-defined literals for time, such as in:
+
+    \code
+        using namespace std::chrono;
+        QDeadlineTimer deadline(250ms);
+    \endcode
+
+    For optimization purposes, if \a remaining is zero or negative, this
+    function may skip obtaining the current time and may instead use a value
+    known to be in the past. If that happens, deadline() may return an
+    unexpected value and this object cannot be used in calculation of how long
+    it is overdue. If that functionality is required, use
+    QDeadlineTimer::current() and add time to it.
+
+    \sa hasExpired(), isForever(), remainingTime<Duration>(), setRemainingTime()
+*/
+
+/*!
+    \fn void QDeadlineTimer::setDeadline(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type)
+
+    Sets this QDeadlineTimer to the deadline marked by \a deadline time
+    point, converting from the clock source \c{Clock} to Qt's internal clock
+    source (see QElapsedTimer::clcokType()).
+
+    If \a deadline is in the past, this QDeadlineTimer object is set to
+    expired, whereas if \a deadline is equal to \c{Duration::max()}, then this
+    object is set to never expire.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    \sa hasExpired(), isForever(), remainingTime<Duration>(),
+*/
+
+/*!
+    Sets the remaining time for this QDeadlineTimer object to \a msecs
+    milliseconds from now, if \a msecs has a positive value. If \a msecs is
+    zero, this QDeadlineTimer object will be marked as expired, whereas a value
+    of -1 will set it to never expire.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    \sa setPreciseRemainingTime(), hasExpired(), isForever(), remainingTime()
+*/
+void QDeadlineTimer::setRemainingTime(qint64 msecs, Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    if (msecs == -1)
+        *this = QDeadlineTimer(Forever, timerType);
+    else
+        setPreciseRemainingTime(0, msecs * 1000 * 1000, timerType);
+}
+
+/*!
+    Sets the remaining time for this QDeadlineTimer object to \a secs seconds
+    plus \a nsecs nanoseconds from now, if \a secs has a positive value. If \a
+    secs is -1, this QDeadlineTimer will be set it to never expire. If both
+    parameters are zero, this QDeadlineTimer will be marked as expired.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    \sa setRemainingTime(), hasExpired(), isForever(), remainingTime()
+*/
+void QDeadlineTimer::setPreciseRemainingTime(qint64 secs, qint64 nsecs, Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    if (secs == -1) {
+        *this = QDeadlineTimer(Forever, timerType);
+        return;
+    }
+
+    *this = current(timerType);
+    if (QDeadlineTimerNanosecondsInT2) {
+        t1 += secs + toSecsAndNSecs(nsecs).first;
+        t2 += toSecsAndNSecs(nsecs).second;
+        if (t2 > 1000*1000*1000) {
+            t2 -= 1000*1000*1000;
+            ++t1;
+        }
+    } else {
+        t1 += secs * 1000 * 1000 * 1000 + nsecs;
+    }
+}
+
+/*!
+    \overload
+    \fn void QDeadlineTimer::setRemainingTime(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type)
+
+    Sets the remaining time for this QDeadlineTimer object to \a remaining. If
+    \a remaining is zero or negative, this QDeadlineTimer object will be mark
+    as expired, whereas if \a remaining is equal to \c{duration::max()}, the
+    object will be set to never expire.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    This function can be used with C++14's user-defined literals for time, such as in:
+
+    \code
+        using namespace std::chrono;
+        deadline.setRemainingTime(250ms);
+    \endcode
+
+    \sa setDeadline(), remainingTime<Duration>(), hasExpired(), isForever()
+*/
+
+/*!
+    \fn void QDeadlineTimer::setPreciseRemainingTime(qint64 secs, unsigned nsecs, Qt::TimerType type)
+
+    Sets the remaining time for this QDeadlineTimer object to \a secs seconds
+    and \a nsecs nanoseconds from now, if \a secs is a positive value. If both
+    values are zero, this QDeadlineTimer object will be marked as expired,
+    whereas if \a secs is -1, it will set it to never expire.
+
+    If value of \a nsecs is more than 1 billion nanoseconds (1 second), this
+    function will adjust \a secs accordingly.
+
+    The timer type for this QDeadlineTimer object will be set to \a timerType type.
+
+    \sa setRemainingTime(), hasExpired(), isForever(), remainingTime()
+*/
+
+/*!
+    \overload
+    \fn Duration QDeadlineTimer::remainingTime() const
+
+    Returns a \c{std::chrono::duration} object of type \c{Duration} containing
+    the remaining time in this QDeadlineTimer, if it still has time left. If
+    the deadline has passed, this returns \c{Duration::zero()}, whereas if the
+    object is set to never expire, it returns \c{Duration::max()} (instead of
+    -1).
+
+    It is not possible to obtain the overdue time for expired timers with this
+    function. To do that, see deadline().
+
+    \note The overload of this function without template parameter always
+    returns milliseconds.
+
+    \sa setRemainingTime(), deadline<Clock, Duration>()
+*/
+
+/*!
+    \overload
+    \fn std::chrono::time_point<Clock, Duration> QDeadlineTimer::deadline() const
+
+    Returns the absolute time point for the deadline stored in QDeadlineTimer
+    object as a \c{std::chrono::time_point} object. The template parameter
+    \c{Clock} is mandatory and indicates which of the C++ timekeeping clocks to
+    use as a reference. The value will be in the past if this QDeadlineTimer
+    has expired.
+
+    If this QDeadlineTimer never expires, this function returns
+    \c{std::chrono::time_point<Clock, Duration>::max()}.
+
+    This function can be used to calculate the amount of time a timer is
+    overdue, by subtracting the current time point of the reference clock, as
+    in the following example:
+
+    \code
+        auto realTimeLeft = std::chrono::nanoseconds::max();
+        auto tp = deadline.deadline<std::chrono::steady_clock>();
+        if (tp != std::chrono::steady_clock::max())
+            realTimeLeft = tp - std::chrono::steady_clock::now();
+    \endcode
+
+    \note Timers that were created as expired have an indetermine time point in
+    the past as their deadline, so the above calculation may not work.
+
+    \sa remainingTime(), deadlineNSecs(), setDeadline()
+*/
+
+/*!
+    Returns true if this QDeadlineTimer object never expires, false otherwise.
+    For timers that never expire, remainingTime() always returns -1 and
+    deadline() returns the maximum value.
+
+    \sa ForeverConstant, hasExpired(), remainingTime()
+*/
+bool QDeadlineTimer::isForever() const Q_DECL_NOTHROW
+{
+    return t1 == (std::numeric_limits<qint64>::max)();
+}
+
+/*!
+    Returns true if this QDeadlineTimer object has expired, false if there
+    remains time left. For objects that have expired, remainingTime() will
+    return zero and deadline() will return a time point in the past.
+
+    QDeadlineTimer objects created with the \ref{ForeverConstant} never expire
+    and this function always returns false for them.
+
+    \sa isForever(), remainingTime()
+*/
+bool QDeadlineTimer::hasExpired() const Q_DECL_NOTHROW
+{
+    if (isForever())
+        return false;
+    return *this <= current(timerType());
+}
+
+/*!
+    \fn Qt::TimerType QDeadlineTimer::timerType() const Q_DECL_NOTHROW
+
+    Returns the timer type is active for this object.
+
+    \sa setTimerType()
+*/
+
+/*!
+    Changes the timer type for this object to \a timerType.
+
+    The behavior for each possible value of \a timerType is operating-system
+    dependent. Qt::PreciseTimer will use the most precise timer that Qt can
+    find, with resolution of 1 millisecond or better, whereas QDeadlineTimer
+    will try to use a more coarse timer for Qt::CoarseTimer and
+    Qt::VeryCoarseTimer.
+
+    \sa timerType()
+ */
+void QDeadlineTimer::setTimerType(Qt::TimerType timerType)
+{
+    type = timerType;
+}
+
+/*!
+    Returns the remaining time in this QDeadlineTimer object in milliseconds.
+    If the timer has already expired, this function will return zero and it is
+    not possible to obtain the amount of time overdue with this function (to do
+    that, see deadline()). If the timer was set to never expire, this function
+    returns -1.
+
+    This function is suitable for use in Qt APIs that take a millisecond
+    timeout, such as the many \ref QIODevice \c waitFor functions or the timed
+    lock functions in \ref QMutex, \ref QWaitCondition, \ref QSemaphore, or
+    \ref QReadWriteLock. For example:
+
+    \code
+        mutex.tryLock(deadline.remainingTime());
+    \code
+
+    \sa remainingTimeNSecs(), isForever(), hasExpired()
+*/
+qint64 QDeadlineTimer::remainingTime() const Q_DECL_NOTHROW
+{
+    qint64 ns = remainingTimeNSecs();
+    return ns <= 0 ? ns : ns / (1000 * 1000);
+}
+
+/*!
+    Returns the remaining time in this QDeadlineTimer object in nanoseconds. If
+    the timer has already expired, this function will return zero and it is not
+    possible to obtain the amount of time overdue with this function. If the
+    timer was set to never expire, this function returns -1.
+
+    \sa remainingTime(), isForever(), hasExpired()
+*/
+qint64 QDeadlineTimer::remainingTimeNSecs() const Q_DECL_NOTHROW
+{
+    if (isForever())
+        return -1;
+    qint64 raw = rawRemainingTimeNSecs();
+    return raw < 0 ? 0 : raw;
+}
+
+/*!
+    \internal
+    Same as remainingTimeNSecs, but may return negative remaining times. Does
+    not deal with Forever.
+*/
+qint64 QDeadlineTimer::rawRemainingTimeNSecs() const Q_DECL_NOTHROW
+{
+    QDeadlineTimer now = current(timerType());
+    if (QDeadlineTimerNanosecondsInT2)
+        return (t1 - now.t1) * (1000*1000*1000) + t2 - now.t2;
+    return t1 - now.t1;
+}
+
+/*!
+    Returns the absolute time point for the deadline stored in QDeadlineTimer
+    object, calculated in milliseconds relative to the reference clock, the
+    same as QElapsedTimer::msecsSinceReference(). The value will be in the past
+    if this QDeadlineTimer has expired.
+
+    If this QDeadlineTimer never expires, this function returns
+    \c{std::numeric_limits<qint64>::max()}.
+
+    This function can be used to calculate the amount of time a timer is
+    overdue, by subtracting QDeadlineTimer::current() or
+    QElapsedTimer::msecsSinceReference(), as in the following example:
+
+    \code
+        qint64 realTimeLeft = deadline.deadline();
+        if (realTimeLeft != (std::numeric_limits<qint64>::max)()) {
+            realTimeLeft -= QDeadlineTimer::current().deadline();
+            // or:
+            //QElapsedTimer timer;
+            //timer.start();
+            //realTimeLeft -= timer.msecsSinceReference();
+        }
+    \endcode
+
+    \note Timers that were created as expired have an indetermine time point in
+    the past as their deadline, so the above calculation may not work.
+
+    \sa remainingTime(), deadlineNSecs(), setDeadline()
+*/
+qint64 QDeadlineTimer::deadline() const Q_DECL_NOTHROW
+{
+    if (isForever())
+        return t1;
+    return deadlineNSecs() / (1000 * 1000);
+}
+
+/*!
+    Returns the absolute time point for the deadline stored in QDeadlineTimer
+    object, calculated in nanoseconds relative to the reference clock, the
+    same as QElapsedTimer::msecsSinceReference(). The value will be in the past
+    if this QDeadlineTimer has expired.
+
+    If this QDeadlineTimer never expires, this function returns
+    \c{std::numeric_limits<qint64>::max()}.
+
+    This function can be used to calculate the amount of time a timer is
+    overdue, by subtracting QDeadlineTimer::current(), as in the following
+    example:
+
+    \code
+        qint64 realTimeLeft = deadline.deadlineNSecs();
+        if (realTimeLeft != std::numeric_limits<qint64>::max())
+            realTimeLeft -= QDeadlineTimer::current().deadlineNSecs();
+    \endcode
+
+    \note Timers that were created as expired have an indetermine time point in
+    the past as their deadline, so the above calculation may not work.
+
+    \sa remainingTime(), deadlineNSecs()
+*/
+qint64 QDeadlineTimer::deadlineNSecs() const Q_DECL_NOTHROW
+{
+    if (isForever())
+        return t1;
+    if (QDeadlineTimerNanosecondsInT2)
+        return t1 * 1000 * 1000 * 1000 + t2;
+    return t1;
+}
+
+/*!
+    Sets the deadline for this QDeadlineTimer object to be the \a msecs
+    absolute time point, counted in milliseconds since the reference clock (the
+    same as QElapsedTimer::msecsSinceReference()), and the timer type to \a
+    timerType. If the value is in the past, this QDeadlineTimer will be marked
+    as expired.
+
+    If \a msecs is \c{std::numeric_limits<qint64>::max()}, this QDeadlineTimer
+    will be set to never expire.
+
+    \sa setPreciseDeadline(), deadline(), deadlineNSecs(), setRemainingTime()
+*/
+void QDeadlineTimer::setDeadline(qint64 msecs, Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    if (msecs == (std::numeric_limits<qint64>::max)()) {
+        setPreciseDeadline(msecs, 0, timerType);    // msecs == MAX implies Forever
+    } else {
+        setPreciseDeadline(msecs / 1000, msecs % 1000 * 1000 * 1000, timerType);
+    }
+}
+
+/*!
+    Sets the deadline for this QDeadlineTimer object to be \a secs seconds and
+    \a nsecs nanoseconds since the reference clock epoch (the same as
+    QElapsedTimer::msecsSinceReference()), and the timer type to \a timerType.
+    If the value is in the past, this QDeadlineTimer will be marked as expired.
+
+    If \a secs or \a nsecs is \c{std::numeric_limits<qint64>::max()}, this
+    QDeadlineTimer will be set to never expire. If \a nsecs is more than 1
+    billion nanoseconds (1 second), then \a secs will be adjusted accordingly.
+
+    \sa setDeadline(), deadline(), deadlineNSecs(), setRemainingTime()
+*/
+void QDeadlineTimer::setPreciseDeadline(qint64 secs, qint64 nsecs, Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    type = timerType;
+    if (secs == (std::numeric_limits<qint64>::max)() || nsecs == (std::numeric_limits<qint64>::max)()) {
+        *this = QDeadlineTimer(Forever, timerType);
+    } else if (QDeadlineTimerNanosecondsInT2) {
+        t1 = secs + toSecsAndNSecs(nsecs).first;
+        t2 = toSecsAndNSecs(nsecs).second;
+    } else {
+        t1 = secs * (1000*1000*1000) + nsecs;
+    }
+}
+
+/*!
+    Returns a QDeadlineTimer object whose deadline is extended from \a dt's
+    deadline by \a nsecs nanoseconds. If \a dt was set to never expire, this
+    function returns a QDeadlineTimer that will not expire either.
+
+    \note if \a dt was created as expired, its deadline is indeterminate and
+    adding an amount of time may or may not cause it to become unexpired.
+*/
+QDeadlineTimer QDeadlineTimer::addNSecs(QDeadlineTimer dt, qint64 nsecs) Q_DECL_NOTHROW
+{
+    if (dt.isForever() || nsecs == (std::numeric_limits<qint64>::max)()) {
+        dt = QDeadlineTimer(Forever, dt.timerType());
+    } else if (QDeadlineTimerNanosecondsInT2) {
+        dt.t1 += toSecsAndNSecs(nsecs).first;
+        dt.t2 += toSecsAndNSecs(nsecs).second;
+        if (dt.t2 > 1000*1000*1000) {
+            dt.t2 -= 1000*1000*1000;
+            ++dt.t1;
+        }
+    } else {
+        dt.t1 += nsecs;
+    }
+    return dt;
+}
+
+/*!
+    \fn QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType)
+
+    Returns a QDeadlineTimer that is expired but is guaranteed to contain the
+    current time. Objects created by this function can participate in the
+    calculation of how long a timer is overdue, using the deadline() function.
+
+    The QDeadlineTimer object will be constructed with a timer type of \a
+    timerType.
+*/
+
+/*!
+    \fn qint64 QDeadlineTimer::resolution(Qt::TimerType timerType)
+
+    Returns the resolution in nanoseconds of the system clock that backs timers
+    of type \a timerType, or 0 if the resolution could not be determined.
+
+    The resolution is not a guarantee that applications will get time values
+    with an accuracy down to that level. It is only the minimum change value
+    that can be expected.
+*/
+
+/*!
+    \fn bool operator==(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 and the deadline in \a d2 are the
+    same, false otherwise. The timer type used to create the two deadlines is
+    ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() == d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator!=(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 and the deadline in \a d2 are
+    diferent, false otherwise. The timer type used to create the two deadlines
+    is ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() != d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator<(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 is earlier than the deadline in \a
+    d2, false otherwise. The timer type used to create the two deadlines is
+    ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() < d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator<=(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 is earlier than or the same as the
+    deadline in \a d2, false otherwise. The timer type used to create the two
+    deadlines is ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() <= d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator>(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 is later than the deadline in \a
+    d2, false otherwise. The timer type used to create the two deadlines is
+    ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() > d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn bool operator>=(QDeadlineTimer d1, QDeadlineTimer d2)
+    \related QDeadlineTimer
+
+    Returns true if the deadline on \a d1 is later than or the same as the
+    deadline in \a d2, false otherwise. The timer type used to create the two
+    deadlines is ignored. This function is equivalent to:
+
+    \code
+        return d1.deadlineNSecs() >= d2.deadlineNSecs();
+    \endcode
+
+    \note comparing QDeadlineTimer objects with different timer types is
+    not supported and may result in unpredictable behavior.
+*/
+
+/*!
+    \fn QDeadlineTimer operator+(QDeadlineTimer dt, qint64 msecs)
+    \related QDeadlineTimer
+
+    Returns a QDeadlineTimer object whose deadline is \a msecs later than the
+    deadline stored in \a dt. If \a dt is set to never expire, this function
+    returns a QDeadlineTimer that does not expire either.
+
+    To add times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+/*!
+    \fn QDeadlineTimer operator+(qint64 msecs, QDeadlineTimer dt)
+    \related QDeadlineTimer
+
+    Returns a QDeadlineTimer object whose deadline is \a msecs later than the
+    deadline stored in \a dt. If \a dt is set to never expire, this function
+    returns a QDeadlineTimer that does not expire either.
+
+    To add times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+/*!
+    \fn QDeadlineTimer operator-(QDeadlineTimer dt, qint64 msecs)
+    \related QDeadlineTimer
+
+    Returns a QDeadlineTimer object whose deadline is \a msecs before the
+    deadline stored in \a dt. If \a dt is set to never expire, this function
+    returns a QDeadlineTimer that does not expire either.
+
+    To subtract times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+/*!
+    \fn QDeadlineTimer &QDeadlineTimer::operator+=(qint64 msecs)
+
+    Extends this QDeadlineTimer object by \a msecs milliseconds and returns
+    itself. If this object is set to never expire, this function does nothing.
+
+    To add times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+/*!
+    \fn QDeadlineTimer &QDeadlineTimer::operator-=(qint64 msecs)
+
+    Shortens this QDeadlineTimer object by \a msecs milliseconds and returns
+    itself. If this object is set to never expire, this function does nothing.
+
+    To subtract times of precision greater than 1 millisecond, use addNSecs().
+*/
+
+// the rest of the functions are in qelapsedtimer_xxx.cpp
+
+QT_END_NAMESPACE
diff --git a/src/corelib/kernel/qdeadlinetimer.h b/src/corelib/kernel/qdeadlinetimer.h
new file mode 100644
index 0000000000..ac8a09ba97
--- /dev/null
+++ b/src/corelib/kernel/qdeadlinetimer.h
@@ -0,0 +1,190 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Intel Corporation.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDEADLINETIMER_H
+#define QDEADLINETIMER_H
+
+#include <QtCore/qelapsedtimer.h>
+#include <QtCore/qmetatype.h>
+#include <QtCore/qnamespace.h>
+
+#ifdef max
+// un-pollute the namespace. We need std::numeric_limits::max() and std::chrono::duration::max()
+#  undef max
+#endif
+
+#include <limits>
+
+#if QT_HAS_INCLUDE(<chrono>)
+#  include <chrono>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class Q_CORE_EXPORT QDeadlineTimer
+{
+public:
+    enum ForeverConstant { Forever };
+
+    Q_DECL_CONSTEXPR QDeadlineTimer(Qt::TimerType type_ = Qt::CoarseTimer) Q_DECL_NOTHROW
+        : t1(0), t2(0), type(type_) {}
+    Q_DECL_CONSTEXPR QDeadlineTimer(ForeverConstant, Qt::TimerType type_ = Qt::CoarseTimer) Q_DECL_NOTHROW
+        : t1(std::numeric_limits<qint64>::max()), t2(0), type(type_) {}
+    explicit QDeadlineTimer(qint64 msecs, Qt::TimerType type = Qt::CoarseTimer) Q_DECL_NOTHROW;
+
+    void swap(QDeadlineTimer &other)
+    { qSwap(t1, other.t1); qSwap(t2, other.t2); qSwap(type, other.type); }
+
+    bool isForever() const Q_DECL_NOTHROW;
+    bool hasExpired() const Q_DECL_NOTHROW;
+
+    Qt::TimerType timerType() const Q_DECL_NOTHROW
+    { return Qt::TimerType(type & 0xff); }
+    void setTimerType(Qt::TimerType type);
+
+    qint64 remainingTime() const Q_DECL_NOTHROW;
+    qint64 remainingTimeNSecs() const Q_DECL_NOTHROW;
+    void setRemainingTime(qint64 msecs, Qt::TimerType type = Qt::CoarseTimer) Q_DECL_NOTHROW;
+    void setPreciseRemainingTime(qint64 secs, qint64 nsecs = 0,
+                                 Qt::TimerType type = Qt::CoarseTimer) Q_DECL_NOTHROW;
+
+    qint64 deadline() const Q_DECL_NOTHROW Q_DECL_PURE_FUNCTION;
+    qint64 deadlineNSecs() const Q_DECL_NOTHROW Q_DECL_PURE_FUNCTION;
+    void setDeadline(qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer) Q_DECL_NOTHROW;
+    void setPreciseDeadline(qint64 secs, qint64 nsecs = 0,
+                            Qt::TimerType type = Qt::CoarseTimer) Q_DECL_NOTHROW;
+
+    static QDeadlineTimer addNSecs(QDeadlineTimer dt, qint64 nsecs) Q_DECL_NOTHROW Q_DECL_PURE_FUNCTION;
+    static QDeadlineTimer current(Qt::TimerType timerType = Qt::CoarseTimer) Q_DECL_NOTHROW;
+
+    friend bool operator==(QDeadlineTimer d1, QDeadlineTimer d2)
+    { return d1.t1 == d2.t1 && d1.t2 == d2.t2; }
+    friend bool operator!=(QDeadlineTimer d1, QDeadlineTimer d2)
+    { return !(d1 == d2); }
+    friend bool operator<(QDeadlineTimer d1, QDeadlineTimer d2)
+    { return d1.t1 < d2.t1 || (d1.t1 == d2.t1 && d1.t2 < d2.t2); }
+    friend bool operator<=(QDeadlineTimer d1, QDeadlineTimer d2)
+    { return d1 == d2 || d1 < d2; }
+    friend bool operator>(QDeadlineTimer d1, QDeadlineTimer d2)
+    { return d2 < d1; }
+    friend bool operator>=(QDeadlineTimer d1, QDeadlineTimer d2)
+    { return !(d1 < d2); }
+
+    friend QDeadlineTimer operator+(QDeadlineTimer dt, qint64 msecs)
+    { return QDeadlineTimer::addNSecs(dt, msecs * 1000 * 1000); }
+    friend QDeadlineTimer operator+(qint64 msecs, QDeadlineTimer dt)
+    { return dt + msecs; }
+    friend QDeadlineTimer operator-(QDeadlineTimer dt, qint64 msecs)
+    { return dt + (-msecs); }
+    friend qint64 operator-(QDeadlineTimer dt1, QDeadlineTimer dt2)
+    { return (dt1.deadlineNSecs() - dt2.deadlineNSecs()) / (1000 * 1000); }
+    QDeadlineTimer &operator+=(qint64 msecs)
+    { *this = *this + msecs; return *this; }
+    QDeadlineTimer &operator-=(qint64 msecs)
+    { *this = *this + (-msecs); return *this; }
+
+#if QT_HAS_INCLUDE(<chrono>) || defined(Q_QDOC)
+    template <class Clock, class Duration>
+    QDeadlineTimer(std::chrono::time_point<Clock, Duration> deadline_,
+                   Qt::TimerType type_ = Qt::CoarseTimer) : t2(0)
+    { setDeadline(deadline_, type_); }
+    template <class Clock, class Duration>
+    QDeadlineTimer &operator=(std::chrono::time_point<Clock, Duration> deadline_)
+    { setDeadline(deadline_); return *this; }
+
+    template <class Clock, class Duration>
+    void setDeadline(std::chrono::time_point<Clock, Duration> deadline_,
+                     Qt::TimerType type_ = Qt::CoarseTimer)
+    { setRemainingTime(deadline_ == deadline_.max() ? Duration::max() : deadline_ - Clock::now(), type_); }
+
+    template <class Clock, class Duration = typename Clock::duration>
+    std::chrono::time_point<Clock, Duration> deadline() const
+    {
+        auto val = std::chrono::nanoseconds(rawRemainingTimeNSecs()) + Clock::now();
+        return std::chrono::time_point_cast<Duration>(val);
+    }
+
+    template <class Rep, class Period>
+    QDeadlineTimer(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type_ = Qt::CoarseTimer)
+        : t2(0)
+    { setRemainingTime(remaining, type_); }
+
+    template <class Rep, class Period>
+    QDeadlineTimer &operator=(std::chrono::duration<Rep, Period> remaining)
+    { setRemainingTime(remaining); return *this; }
+
+    template <class Rep, class Period>
+    void setRemainingTime(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type_ = Qt::CoarseTimer)
+    {
+        if (remaining == remaining.max())
+            *this = QDeadlineTimer(Forever, type_);
+        else
+            setPreciseRemainingTime(0, std::chrono::nanoseconds(remaining).count(), type_);
+    }
+
+    std::chrono::nanoseconds remainingTimeAsDuration() const Q_DECL_NOTHROW
+    {
+        if (isForever())
+            return std::chrono::nanoseconds::max();
+        qint64 nsecs = rawRemainingTimeNSecs();
+        if (nsecs <= 0)
+            return std::chrono::nanoseconds::zero();
+        return std::chrono::nanoseconds(nsecs);
+    }
+
+    template <class Rep, class Period>
+    friend QDeadlineTimer operator+(QDeadlineTimer dt, std::chrono::duration<Rep, Period> value)
+    { return QDeadlineTimer::addNSecs(dt, std::chrono::duration_cast<std::chrono::nanoseconds>(value).count()); }
+    template <class Rep, class Period>
+    friend QDeadlineTimer operator+(std::chrono::duration<Rep, Period> value, QDeadlineTimer dt)
+    { return dt + value; }
+    template <class Rep, class Period>
+    friend QDeadlineTimer operator+=(QDeadlineTimer &dt, std::chrono::duration<Rep, Period> value)
+    { return dt = dt + value; }
+#endif
+
+private:
+    qint64 t1;
+    unsigned t2;
+    unsigned type;
+
+    qint64 rawRemainingTimeNSecs() const Q_DECL_NOTHROW;
+};
+
+Q_DECLARE_SHARED(QDeadlineTimer)
+
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(QDeadlineTimer)
+
+#endif // QDEADLINETIMER_H
diff --git a/src/corelib/kernel/qdeadlinetimer_p.h b/src/corelib/kernel/qdeadlinetimer_p.h
new file mode 100644
index 0000000000..46e12de6c1
--- /dev/null
+++ b/src/corelib/kernel/qdeadlinetimer_p.h
@@ -0,0 +1,70 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDEADLINETIMER_P_H
+#define QDEADLINETIMER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtCore/qglobal.h>
+
+QT_BEGIN_NAMESPACE
+
+enum {
+#if defined(Q_OS_UNIX) && !defined(Q_OS_DARWIN)
+    // t1 contains seconds and t2 contains nanoseconds
+    QDeadlineTimerNanosecondsInT2 = 1
+#else
+    // t1 contains nanoseconds, t2 is always zero
+    QDeadlineTimerNanosecondsInT2 = 0
+#endif
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/corelib/kernel/qelapsedtimer.cpp b/src/corelib/kernel/qelapsedtimer.cpp
index 2eabb4c3a3..5e9d1317ac 100644
--- a/src/corelib/kernel/qelapsedtimer.cpp
+++ b/src/corelib/kernel/qelapsedtimer.cpp
@@ -83,6 +83,9 @@ QT_BEGIN_NAMESPACE
 
     \snippet qelapsedtimer/main.cpp 2
 
+    It is often more convenient to use \ref{QDeadlineTimer} in this case, which
+    counts towards a timeout in the future instead of tracking elapsed time.
+
     \section1 Reference Clocks
 
     QElapsedTimer will use the platform's monotonic reference clock in all
@@ -120,7 +123,7 @@ QT_BEGIN_NAMESPACE
     The information on which clocks types may overflow and how to remedy that
     issue is documented along with the clock types.
 
-    \sa QTime, QTimer
+    \sa QTime, QTimer, QDeadlineTimer
 */
 
 /*!
@@ -137,7 +140,7 @@ QT_BEGIN_NAMESPACE
     \value SystemTime         The human-readable system time. This clock is not monotonic.
     \value MonotonicClock     The system's monotonic clock, usually found in Unix systems. This clock is monotonic and does not overflow.
     \value TickCounter        The system's tick counter, used on Windows systems. This clock may overflow.
-    \value MachAbsoluteTime   The Mach kernel's absolute time (OS X and iOS). This clock is monotonic and does not overflow.
+    \value MachAbsoluteTime   The Mach kernel's absolute time (\macos and iOS). This clock is monotonic and does not overflow.
     \value PerformanceCounter The high-resolution performance counter provided by Windows. This clock is monotonic and does not overflow.
 
     \section2 SystemTime
@@ -179,8 +182,8 @@ QT_BEGIN_NAMESPACE
     \section2 MachAbsoluteTime
 
     This clock type is based on the absolute time presented by Mach kernels,
-    such as that found on OS X. This clock type is presented separately
-    from MonotonicClock since OS X and iOS are also Unix systems and may support
+    such as that found on \macos. This clock type is presented separately
+    from MonotonicClock since \macos and iOS are also Unix systems and may support
     a POSIX monotonic clock with values differing from the Mach absolute
     time.
 
@@ -255,7 +258,7 @@ bool QElapsedTimer::isValid() const Q_DECL_NOTHROW
     The value of \a timeout can be -1 to indicate that this timer does not
     expire, in which case this function will always return false.
 
-    \sa elapsed()
+    \sa elapsed(), QDeadlineTimer
 */
 bool QElapsedTimer::hasExpired(qint64 timeout) const Q_DECL_NOTHROW
 {
diff --git a/src/corelib/kernel/qelapsedtimer_generic.cpp b/src/corelib/kernel/qelapsedtimer_generic.cpp
index 8c724247be..fdeb385188 100644
--- a/src/corelib/kernel/qelapsedtimer_generic.cpp
+++ b/src/corelib/kernel/qelapsedtimer_generic.cpp
@@ -38,6 +38,7 @@
 ****************************************************************************/
 
 #include "qelapsedtimer.h"
+#include "qdeadlinetimer.h"
 #include "qdatetime.h"
 
 QT_BEGIN_NAMESPACE
@@ -145,7 +146,7 @@ qint64 QElapsedTimer::elapsed() const Q_DECL_NOTHROW
     number of milliseconds since January 1st, 1970 at 0:00 UTC (that is, it
     is the Unix time expressed in milliseconds).
 
-    On Linux, Windows and OS X/iOS systems, this value is usually the time
+    On Linux, Windows and Apple platforms, this value is usually the time
     since the system boot, though it usually does not include the time the
     system has spent in sleep states.
 
@@ -201,4 +202,12 @@ bool operator<(const QElapsedTimer &v1, const QElapsedTimer &v2) Q_DECL_NOTHROW
     return v1.t1 < v2.t1;
 }
 
+QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    QDeadlineTimer result;
+    result.t1 = QDateTime::currentMSecsSinceEpoch() * 1000 * 1000;
+    result.type = timerType;
+    return result;
+}
+
 QT_END_NAMESPACE
diff --git a/src/corelib/kernel/qelapsedtimer_mac.cpp b/src/corelib/kernel/qelapsedtimer_mac.cpp
index 886e0f41b2..7490693991 100644
--- a/src/corelib/kernel/qelapsedtimer_mac.cpp
+++ b/src/corelib/kernel/qelapsedtimer_mac.cpp
@@ -41,6 +41,8 @@
 #define _POSIX_C_SOURCE 200809L
 
 #include "qelapsedtimer.h"
+#include "qdeadlinetimer.h"
+#include "qdeadlinetimer_p.h"
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
@@ -50,6 +52,12 @@
 
 QT_BEGIN_NAMESPACE
 
+#ifdef __LP64__
+typedef __int128_t LargeInt;
+#else
+typedef qint64 LargeInt;
+#endif
+
 QElapsedTimer::ClockType QElapsedTimer::clockType() Q_DECL_NOTHROW
 {
     return MachAbsoluteTime;
@@ -65,13 +73,13 @@ static qint64 absoluteToNSecs(qint64 cpuTime)
 {
     if (info.denom == 0)
         mach_timebase_info(&info);
-#ifdef __LP64__
-    __uint128_t nsecs = static_cast<__uint128_t>(cpuTime) * info.numer / info.denom;
-    return static_cast<qint64>(nsecs);
-#else
-    qint64 nsecs = cpuTime * info.numer / info.denom;
+
+    // don't do multiplication & division if those are equal
+    // (mathematically it would be the same, but it's computationally expensive)
+    if (info.numer == info.denom)
+        return cpuTime;
+    qint64 nsecs = LargeInt(cpuTime) * info.numer / info.denom;
     return nsecs;
-#endif
 }
 
 static qint64 absoluteToMSecs(qint64 cpuTime)
@@ -146,4 +154,13 @@ bool operator<(const QElapsedTimer &v1, const QElapsedTimer &v2) Q_DECL_NOTHROW
     return v1.t1 < v2.t1;
 }
 
+QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    Q_STATIC_ASSERT(!QDeadlineTimerNanosecondsInT2);
+    QDeadlineTimer result;
+    result.type = timerType;
+    result.t1 = absoluteToNSecs(mach_absolute_time());
+    return result;
+}
+
 QT_END_NAMESPACE
diff --git a/src/corelib/kernel/qelapsedtimer_unix.cpp b/src/corelib/kernel/qelapsedtimer_unix.cpp
index e2c3ae6280..e166d4e3d2 100644
--- a/src/corelib/kernel/qelapsedtimer_unix.cpp
+++ b/src/corelib/kernel/qelapsedtimer_unix.cpp
@@ -39,6 +39,8 @@
 ****************************************************************************/
 
 #include "qelapsedtimer.h"
+#include "qdeadlinetimer.h"
+#include "qdeadlinetimer_p.h"
 #if defined(Q_OS_VXWORKS)
 #include "qfunctions_vxworks.h"
 #else
@@ -248,4 +250,16 @@ bool operator<(const QElapsedTimer &v1, const QElapsedTimer &v2) Q_DECL_NOTHROW
     return v1.t1 < v2.t1 || (v1.t1 == v2.t1 && v1.t2 < v2.t2);
 }
 
+QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    Q_STATIC_ASSERT(QDeadlineTimerNanosecondsInT2);
+    QDeadlineTimer result;
+    qint64 cursec, curnsec;
+    do_gettime(&cursec, &curnsec);
+    result.t1 = cursec;
+    result.t2 = curnsec;
+    result.type = timerType;
+    return result;
+}
+
 QT_END_NAMESPACE
diff --git a/src/corelib/kernel/qelapsedtimer_win.cpp b/src/corelib/kernel/qelapsedtimer_win.cpp
index 520126d262..0c380b2f6a 100644
--- a/src/corelib/kernel/qelapsedtimer_win.cpp
+++ b/src/corelib/kernel/qelapsedtimer_win.cpp
@@ -38,6 +38,8 @@
 ****************************************************************************/
 
 #include "qelapsedtimer.h"
+#include "qdeadlinetimer.h"
+#include "qdeadlinetimer_p.h"
 #include <qt_windows.h>
 
 QT_BEGIN_NAMESPACE
@@ -76,6 +78,17 @@ static inline qint64 ticksToNanoseconds(qint64 ticks)
     }
 }
 
+static inline qint64 nanosecondsToTicks(qint64 nsec)
+{
+    if (counterFrequency > 0) {
+        // QueryPerformanceCounter uses an arbitrary frequency
+        return double(nsec) * counterFrequency / 1000000000.;
+    } else {
+        // GetTickCount(64) uses milliseconds
+        return nsec / 1000000;
+    }
+}
+
 static quint64 getTickCount()
 {
     resolveCounterFrequency();
@@ -161,4 +174,13 @@ bool operator<(const QElapsedTimer &v1, const QElapsedTimer &v2) Q_DECL_NOTHROW
     return (v1.t1 - v2.t1) < 0;
 }
 
+QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType) Q_DECL_NOTHROW
+{
+    Q_STATIC_ASSERT(!QDeadlineTimerNanosecondsInT2);
+    QDeadlineTimer result;
+    result.t1 = ticksToNanoseconds(getTickCount());
+    result.type = timerType;
+    return result;
+}
+
 QT_END_NAMESPACE
diff --git a/src/corelib/kernel/qeventdispatcher_cf.mm b/src/corelib/kernel/qeventdispatcher_cf.mm
index 437e4062ad..eecc72fd94 100644
--- a/src/corelib/kernel/qeventdispatcher_cf.mm
+++ b/src/corelib/kernel/qeventdispatcher_cf.mm
@@ -51,6 +51,8 @@
 
 #ifdef Q_OS_OSX
 #  include <AppKit/NSApplication.h>
+#elif defined(Q_OS_WATCHOS)
+#  include <WatchKit/WatchKit.h>
 #else
 #  include <UIKit/UIApplication.h>
 #endif
@@ -75,6 +77,8 @@ QT_USE_NAMESPACE
             name:nil
 #ifdef Q_OS_OSX
             object:[NSApplication sharedApplication]];
+#elif defined(Q_OS_WATCHOS)
+            object:[WKExtension sharedExtension]];
 #else
             object:[UIApplication sharedApplication]];
 #endif
diff --git a/src/corelib/kernel/qobject.cpp b/src/corelib/kernel/qobject.cpp
index 26c3ce2443..e901d8cefa 100644
--- a/src/corelib/kernel/qobject.cpp
+++ b/src/corelib/kernel/qobject.cpp
@@ -4248,7 +4248,7 @@ QDebug operator<<(QDebug dbg, const QObject *o)
 
     This macro registers an enum type with the meta-object system.
     It must be placed after the enum declaration in a class that has the Q_OBJECT or the
-    Q_GADGET macro.
+    Q_GADGET macro. For namespaces use \l Q_ENUM_NS instead.
 
     For example:
 
@@ -4275,7 +4275,7 @@ QDebug operator<<(QDebug dbg, const QObject *o)
     This macro registers a single \l{QFlags}{flags type} with the
     meta-object system. It is typically used in a class definition to declare
     that values of a given enum can be used as flags and combined using the
-    bitwise OR operator.
+    bitwise OR operator. For namespaces use \l Q_FLAG_NS instead.
 
     The macro must be placed after the enum declaration.
 
@@ -4294,6 +4294,48 @@ QDebug operator<<(QDebug dbg, const QObject *o)
     \sa {Qt's Property System}
 */
 
+/*!
+    \macro Q_ENUM_NS(...)
+    \since 5.8
+
+    This macro registers an enum type with the meta-object system.
+    It must be placed after the enum declaration in a namespace that
+    has the Q_NAMESPACE macro. It is the same as \l Q_ENUM but in a
+    namespace.
+
+    Enumerations that are declared with Q_ENUM_NS have their QMetaEnum
+    registered in the enclosing QMetaObject. You can also use
+    QMetaEnum::fromType() to get the QMetaEnum.
+
+    Registered enumerations are automatically registered also to the Qt meta
+    type system, making them known to QMetaType without the need to use
+    Q_DECLARE_METATYPE(). This will enable useful features; for example, if
+    used in a QVariant, you can convert them to strings. Likewise, passing them
+    to QDebug will print out their names.
+
+    \sa {Qt's Property System}
+*/
+
+
+/*!
+    \macro Q_FLAG_NS(...)
+    \since 5.8
+
+    This macro registers a single \l{QFlags}{flags type} with the
+    meta-object system. It is used in a namespace that has the
+    Q_NAMESPACE macro, to declare that values of a given enum can be
+    used as flags and combined using the bitwise OR operator.
+    It is the same as \l Q_FLAG but in a namespace.
+
+    The macro must be placed after the enum declaration.
+
+    \note The Q_FLAG_NS macro takes care of registering individual flag
+    values with the meta-object system, so it is unnecessary to use
+    Q_ENUM_NS() in addition to this macro.
+
+    \sa {Qt's Property System}
+*/
+
 
 /*!
     \macro Q_OBJECT
@@ -4335,6 +4377,21 @@ QDebug operator<<(QDebug dbg, const QObject *o)
 */
 
 /*!
+    \macro Q_NAMESPACE
+    \since 5.8
+
+    The Q_NAMESPACE macro can be used to add QMetaObject capabilities
+    to a namespace.
+
+    Q_NAMESPACEs can have Q_CLASSINFO, Q_ENUM_NS, Q_FLAG_NS, but they
+    cannot have Q_ENUM, Q_FLAG, Q_PROPERTY, Q_INVOKABLE, signals nor slots.
+
+    Q_NAMESPACE makes an external variable, \c{staticMetaObject}, available.
+    \c{staticMetaObject} is of type QMetaObject and provides access to the
+    enums declared with Q_ENUM_NS/Q_FLAG_NS.
+*/
+
+/*!
     \macro Q_SIGNALS
     \relates QObject
 
diff --git a/src/corelib/kernel/qobjectdefs.h b/src/corelib/kernel/qobjectdefs.h
index 3660d1c0e1..7ed6088d3b 100644
--- a/src/corelib/kernel/qobjectdefs.h
+++ b/src/corelib/kernel/qobjectdefs.h
@@ -124,6 +124,11 @@ class QString;
     friend Q_DECL_CONSTEXPR const char *qt_getEnumName(ENUM) Q_DECL_NOEXCEPT { return #ENUM; }
 #define Q_ENUM(x) Q_ENUMS(x) Q_ENUM_IMPL(x)
 #define Q_FLAG(x) Q_FLAGS(x) Q_ENUM_IMPL(x)
+#define Q_ENUM_NS_IMPL(ENUM) \
+    inline Q_DECL_CONSTEXPR const QMetaObject *qt_getEnumMetaObject(ENUM) Q_DECL_NOEXCEPT { return &staticMetaObject; } \
+    inline Q_DECL_CONSTEXPR const char *qt_getEnumName(ENUM) Q_DECL_NOEXCEPT { return #ENUM; }
+#define Q_ENUM_NS(x) Q_ENUMS(x) Q_ENUM_NS_IMPL(x)
+#define Q_FLAG_NS(x) Q_FLAGS(x) Q_ENUM_NS_IMPL(x)
 #define Q_SCRIPTABLE QT_ANNOTATE_FUNCTION(qt_scriptable)
 #define Q_INVOKABLE  QT_ANNOTATE_FUNCTION(qt_invokable)
 #define Q_SIGNAL QT_ANNOTATE_FUNCTION(qt_signal)
@@ -227,6 +232,12 @@ private: \
     QT_WARNING_POP \
     QT_ANNOTATE_CLASS(qt_qgadget, "") \
     /*end*/
+
+#define Q_NAMESPACE \
+    extern const QMetaObject staticMetaObject; \
+    QT_ANNOTATE_CLASS(qt_qnamespace, "") \
+    /*end*/
+
 #endif // QT_NO_META_MACROS
 
 #else // Q_MOC_RUN
diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp
index d21529d124..72ae3b063f 100644
--- a/src/corelib/kernel/qvariant.cpp
+++ b/src/corelib/kernel/qvariant.cpp
@@ -2722,7 +2722,7 @@ qlonglong QVariant::toLongLong(bool *ok) const
 }
 
 /*!
-    Returns the variant as as an unsigned long long int if the
+    Returns the variant as an unsigned long long int if the
     variant has type() \l QMetaType::ULongLong, \l QMetaType::Bool,
     \l QMetaType::QByteArray, \l QMetaType::QChar, \l QMetaType::Double,
     \l QMetaType::Int, \l QMetaType::LongLong, \l QMetaType::QString, or
@@ -3560,6 +3560,8 @@ int QVariant::compare(const QVariant &v) const
         return v1.toTime() < v2.toTime() ? -1 : 1;
     case QVariant::DateTime:
         return v1.toDateTime() < v2.toDateTime() ? -1 : 1;
+    case QVariant::StringList:
+        return v1.toStringList() < v2.toStringList() ? -1 : 1;
     }
     int r = v1.toString().compare(v2.toString(), Qt::CaseInsensitive);
     if (r == 0) {