Merge remote-tracking branch 'origin/5.9' into 5.10

Conflicts: .qmake.conf mkspecs/win32-g++/qmake.conf src/corelib/global/qglobal_p.h src/corelib/global/qoperatingsystemversion_p.h src/corelib/io/qfilesystemengine_win.cpp src/network/bearer/qbearerengine.cpp src/platformsupport/input/libinput/qlibinputpointer.cpp src/sql/doc/snippets/code/doc_src_sql-driver.cpp src/widgets/kernel/qwidget_p.h src/widgets/kernel/qwidgetwindow.cpp src/widgets/styles/qfusionstyle.cpp tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp Change-Id: I80e2722f481b12fff5d967c28f89208c0e9a1dd8
2017-12-29 15:56:33 +01:00 · 2017-12-29 15:56:33 +01:00 · db92f2f3aa
commit db92f2f3aa
parent dd61a1d98e 44da5b8635
153 changed files with 2669 additions and 819 deletions
--- a/config_help.txt
+++ b/config_help.txt
@ -9,6 +9,12 @@ ICU_PREFIX=/opt/icu42 ICU_LIBS="-licui18n -licuuc -licudata".
 It is also possible to manipulate any QMAKE_* variable, to amend the values
 from the mkspec for the build of Qt itself, e.g., QMAKE_CXXFLAGS+=-g3.

+Note that the *_LIBS* and QMAKE_* assignments manipulate lists, so items
+containing meta characters (spaces in particular) need to be quoted according
+to qmake rules. On top of that, the assignments as a whole need to be quoted
+according to shell rules. It is recommended to use single quotes for the inner
+quoting and double quotes for the outer quoting.
+
 Top-level installation directories:
  -prefix <dir> ...... The deployment directory, as seen on the target device.
                       [/usr/local/Qt-$QT_VERSION, $PWD if -developer-build]
@ -60,8 +66,10 @@ Configure meta:
  -redo ................ Re-configure with previously used options.
                         Additional options may be passed, but will not be
                         saved for later use by -redo.
-  -recheck ............. Discard cached negative configure test results.
+  -recheck [test,...] .. Discard cached negative configure test results.
                         Use this after installing missing dependencies.
+                         Alternatively, if tests are specified, only their
+                         results are discarded.
  -recheck-all ......... Discard all cached configure test results.

  -feature-<feature> ... Enable <feature>
--- a/configure.pri
+++ b/configure.pri
@ -557,7 +557,7 @@ defineTest(qtConfOutput_prepareOptions) {
                else: \
                    qtConfFatalError("Cannot detect the Android host." \
                                     "Please use -android-ndk-host option to specify one.")
-                qtConfAddNotice("Available Android host does not match host architecture.")
+                qtConfAddNote("Available Android host does not match host architecture.")
            }
        } else {
            !exists($$ndk_tc_pfx/$$ndk_host/*): \
--- a/mkspecs/common/msvc-desktop.conf
+++ b/mkspecs/common/msvc-desktop.conf
@ -15,7 +15,7 @@
 MAKEFILE_GENERATOR      = MSVC.NET
 QMAKE_PLATFORM          = win32
 QMAKE_COMPILER          = msvc
-CONFIG                 += incremental flat precompile_header autogen_precompile_source debug_and_release debug_and_release_target embed_manifest_dll embed_manifest_exe
+CONFIG                 += incremental flat debug_and_release debug_and_release_target precompile_header autogen_precompile_source embed_manifest_dll embed_manifest_exe
 DEFINES                += UNICODE _UNICODE WIN32
 QMAKE_COMPILER_DEFINES += _WIN32
 contains(QMAKE_TARGET.arch, x86_64) {
@ -35,7 +35,7 @@ QMAKE_CFLAGS            = -nologo -Zc:wchar_t
 QMAKE_CFLAGS_WARN_ON    = -W3
 QMAKE_CFLAGS_WARN_OFF   = -W0
 QMAKE_CFLAGS_RELEASE    = $$QMAKE_CFLAGS_OPTIMIZE -MD
-QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_OPTIMIZE -MD -Zi
+QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_OPTIMIZE -Zi -MD
 QMAKE_CFLAGS_DEBUG      = -Zi -MDd
 QMAKE_CFLAGS_YACC       =
 QMAKE_CFLAGS_LTCG       = -GL
@ -100,7 +100,6 @@ QMAKE_LIBS_OPENGL       = glu32.lib opengl32.lib gdi32.lib user32.lib
 QMAKE_LIBS_OPENGL_ES2   = gdi32.lib user32.lib
 QMAKE_LIBS_OPENGL_ES2_DEBUG = gdi32.lib user32.lib
 QMAKE_LIBS_COMPAT       = advapi32.lib shell32.lib comdlg32.lib user32.lib gdi32.lib ws2_32.lib
-
 QMAKE_LIBS_QT_ENTRY     = -lqtmain

 QMAKE_IDL               = midl /NOLOGO
--- a/mkspecs/devices/integrity-armv8-msm8996au/qmake.conf
+++ b/mkspecs/devices/integrity-armv8-msm8996au/qmake.conf
@ -0,0 +1,57 @@
+#
+# qmake configuration for INTEGRITY Qualcomm s820 Snapdragon MSM8996AU
+#
+
+load(device_config)
+
+include(../../common/ghs-integrity-armv8.conf)
+
+QT_QPA_DEFAULT_PLATFORM  = eglfs
+EGLFS_DEVICE_INTEGRATION = eglfs_openwfd
+
+bsp_name = $$(INTEGRITY_BSP)
+isEmpty(bsp_name): \
+    error("This qmakespec requires $INTEGRITY_BSP to be set")
+
+os_directory = $$(INTEGRITY_DIR)
+isEmpty(os_directory): \
+    error("This qmakespec requires $INTEGRITY_DIR to be set")
+
+qclibs_directory = $$(QCLIBS_DIR)
+isEmpty(qclibs_directory): \
+    error("This qmakespec requires $QCLIBS_DIR to be set")
+
+qc_multimedia_inc_directory = $$(QC_MULTIMEDIA_INC_DIR)
+isEmpty(qc_multimedia_inc_directory): \
+    error("This qmakespec requires $QC_MULTIMEDIA_INC_DIR to be set")
+
+gl_inc_directory = $$(GL_INC_DIR)
+isEmpty(gl_inc_directory): \
+    error("This qmakespec requires $GL_INC_DIR to be set")
+
+gl_lib_directory = $$(GL_LIB_DIR)
+isEmpty(gl_lib_directory): \
+    error("This qmakespec requires $GL_LIB_DIR to be set")
+
+QMAKE_LIBDIR            += $$(QCLIBS_DIR)/base
+QMAKE_LIBDIR            += $$(QCLIBS_DIR)/multimedia/display
+
+QMAKE_INCDIR            += $$(QC_MULTIMEDIA_INC_DIR)
+
+QMAKE_LIBS_EGL          += -lESXEGL_Adreno -lESXGLESv2_Adreno -ladreno_utils -lGSLUser -lOSUser -lpanel -livfs -lposix -lpmem -ltzbsp -lpaged_alloc -lglnext-llvm -lopenwfd
+QMAKE_LIBS_OPENGL_ES2   += $${QMAKE_LIBS_EGL}
+
+QMAKE_CFLAGS            += -DINTEGRITY
+QMAKE_CXXFLAGS          += -DINTEGRITY
+
+QMAKE_CFLAGS            += -bigswitch
+QMAKE_CXXFLAGS          += -bigswitch
+QMAKE_LFLAGS            += -bigswitch
+
+# OpenGL libraries have a dependency on libEGL
+QMAKE_INCDIR_EGL = $$(GL_INC_DIR)
+QMAKE_LIBDIR_EGL = $$(GL_LIB_DIR)
+QMAKE_INCDIR_OPENGL_ES2 = $$(GL_INC_DIR)
+QMAKE_LIBDIR_OPENGL_ES2 = $$(GL_LIB_DIR)
+
+load(qt_config)
--- a/mkspecs/devices/integrity-armv8-msm8996au/qplatformdefs.h
+++ b/mkspecs/devices/integrity-armv8-msm8996au/qplatformdefs.h
@ -0,0 +1,45 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the qmake spec 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 QPLATFORMDEFS_H
+#define QPLATFORMDEFS_H
+
+#include "../../common/integrity/qplatformdefs.h"
+
+#endif // QPLATFORMDEFS_H
--- a/mkspecs/features/data/configure.json
+++ b/mkspecs/features/data/configure.json
@ -9,7 +9,7 @@

            "continue": "void",

-            "recheck": { "type": "void", "name": "cache_use", "value": "positive" },
+            "recheck": { "type": "optionalString", "name": "cache_recheck" },
            "recheck-all": { "type": "void", "name": "cache_use", "value": "none" },

            "redo": { "type": "redo" },
--- a/mkspecs/features/default_pre.prf
+++ b/mkspecs/features/default_pre.prf
@ -2,6 +2,9 @@
 # Note that evaluating variable assignments from the command line
 # still happens in between these two steps.

+# In early configure setup; nothing useful to be done here.
+isEmpty(QMAKE_CXX): return()
+
 load(exclusive_builds)
 CONFIG = \
    lex yacc debug exceptions depend_includepath \
--- a/mkspecs/features/qt_configure.prf
+++ b/mkspecs/features/qt_configure.prf
@ -499,30 +499,37 @@ defineTest(qtConfLibrary_inline) {
    # to make them recognize the same input variables.
    input = $$eval($${2}.alias)

-    # direct libs. overwrites inline libs.
-    defined(config.input.$${input}.libs, var) {
-        $${1}.libs = $$eval(config.input.$${input}.libs)
-        export($${1}.libs)
-    }
-
    # build-specific direct libs. overwrites inline libs.
    vars =
    any = false
    all = true
-    for (b, $${1}.builds._KEYS_) {
+    for (b, $$list(debug release)) {
        iv = $${input}.libs.$${b}
        vars += $$eval(config.commandline.rev_assignments.$${iv})
        defined(config.input.$${iv}, var) {
-            $${1}.builds.$${b}.libs = $$eval(config.input.$${iv})
-            export($${1}.builds.$${b}.libs)
+            $${1}.builds.$${b} = $$eval(config.input.$${iv})
+            export($${1}.builds.$${b})
+            $${1}.builds._KEYS_ *= $${b}
            any = true
        } else {
            all = false
        }
    }
-    $$any:!$$all {
-        qtConfAddError("Either none or all of $$join(vars, ", ", [, ]) must be specified.")
-        return(false)
+    $$any {
+        !$$all {
+            qtConfAddError("Either none or all of $$join(vars, ", ", [, ]) must be specified.")
+            return(false)
+        }
+        export($${1}.builds._KEYS_)
+        # we also reset the generic libs, to avoid surprises.
+        $${1}.libs =
+        export($${1}.libs)
+    }
+
+    # direct libs. overwrites inline libs.
+    defined(config.input.$${input}.libs, var) {
+        $${1}.libs = $$eval(config.input.$${input}.libs)
+        export($${1}.libs)
    }

    # prefix. prepends to (possibly overwritten) inline libs.
@ -670,9 +677,10 @@ defineTest(qtConfExportLibrary) {
    NAME = $$upper($$name)
    # LIBS is emitted even if empty, as this allows the library to be "seen".
    qtConfOutputVar(assign, $$output, QMAKE_LIBS_$$NAME, $$libs)
-    for (b, $${spfx}.builds._KEYS_): \
-        qtConfOutputVar(assign, $$output, QMAKE_LIBS_$${NAME}_$$upper($$b), \
-                                          $$eval($${spfx}.builds.$${b}))
+    for (b, $${spfx}.builds._KEYS_) {
+        eval(blibs = $$eval($${spfx}.builds.$${b}))
+        qtConfOutputVar(assign, $$output, QMAKE_LIBS_$${NAME}_$$upper($$b), $$blibs)
+    }
    !isEmpty(defines): qtConfOutputVar(assign, $$output, QMAKE_DEFINES_$$NAME, $$defines)
    !isEmpty(includes): qtConfOutputVar(assign, $$output, QMAKE_INCDIR_$$NAME, $$includes)
    !isEmpty($${currentConfig}.module): \
@ -1044,8 +1052,13 @@ defineTest(qtConfSaveResult) {
        return()
    keys = result $$eval($${1}.cache)
    cont = "cache.$${2}._KEYS_ = $$keys"
-    for (k, keys): \
+    cache.$${2}._KEYS_ = $$keys
+    export(cache.$${2}._KEYS_)
+    for (k, keys) {
        cont += "cache.$${2}.$${k} = $$val_escape($${1}.$${k})"
+        cache.$${2}.$${k} = $$eval($${1}.$${k})
+        export(cache.$${2}.$${k})
+    }
    write_file($$QMAKE_CONFIG_CACHE, cont, append)|error()
 }

@ -2033,14 +2046,28 @@ qtConfCheckErrors()

 QMAKE_CONFIG_CACHE = $$OUT_PWD/config.cache
 QMAKE_CONFIG_CACHE_USE = $$eval(config.input.cache_use)
+cache_recheck = $$eval(config.input.cache_recheck)
+equals(cache_recheck, yes) {
+    QMAKE_CONFIG_CACHE_USE = positive
+    cache_recheck =
+}
 isEmpty(QMAKE_CONFIG_CACHE_USE): \
    QMAKE_CONFIG_CACHE_USE = all
 !equals(QMAKE_CONFIG_CACHE_USE, none) {
    include($$QMAKE_CONFIG_CACHE, , true)
    # this crudely determines when to discard the cache. this also catches the case
    # of no cache being there in the first place.
-    !equals(cache.platform, $$[QMAKE_SPEC])|!equals(cache.xplatform, $$[QMAKE_XSPEC]): \
+    !equals(cache.platform, $$[QMAKE_SPEC])|!equals(cache.xplatform, $$[QMAKE_XSPEC]) {
        QMAKE_CONFIG_CACHE_USE = none
+    } else: !isEmpty(cache_recheck) {
+        for (cr, $$list($$split(cache_recheck, ","))) {
+            !isEmpty(cache.$${cr}._KEYS_) {
+                cache.$${cr}._KEYS_ =
+            } else {
+                qtConfAddWarning("Attempting to discard non-cached result '$$cr'.")
+            }
+        }
+    }
 }
 equals(QMAKE_CONFIG_CACHE_USE, none) {
    cont = \
--- a/mkspecs/features/qt_plugin.prf
+++ b/mkspecs/features/qt_plugin.prf
@ -48,7 +48,7 @@ CONFIG(static, static|shared)|prefix_build {

    !build_pass {
        qt_plugin_deps = $$QT $$QT_PRIVATE
-        qt_plugin_deps = s,-private$,_private,g
+        qt_plugin_deps ~= s,-private$,_private,g

        MODULE_PRI_CONT = \
            "QT_PLUGIN.$${MODULE}.TYPE = $$PLUGIN_TYPE" \
--- a/mkspecs/features/toolchain.prf
+++ b/mkspecs/features/toolchain.prf
@ -1,7 +1,4 @@

-# In early configure setup; nothing useful to be done here.
-isEmpty(QMAKE_CXX): return()
-
 defineReplace(qtMakeExpand) {
    out = "$$1"
    for(ever) {
@ -19,7 +16,13 @@ defineTest(qtCompilerErrror) {
        what = " host"
    else: \
        what = " target"
-    error("Cannot run$$what compiler '$$1'. Maybe you forgot to setup the environment?")
+    msg = \
+        "Cannot run$$what compiler '$$1'. Output:" \
+        "===================" \
+        $$2 \
+        "===================" \
+        "Maybe you forgot to setup the environment?"
+    error($$join(msg, $$escape_expand(\\n)))
 }

 cross_compile:host_build: \
@ -64,7 +67,7 @@ isEmpty($${target_prefix}.INCDIRS) {
            cxx_flags += -E -v

        output = $$system("$$cmd_prefix $$QMAKE_CXX $$qtMakeExpand($$cxx_flags) -xc++ - 2>&1 $$cmd_suffix", lines, ec)
-        !equals(ec, 0): qtCompilerErrror($$QMAKE_CXX)
+        !equals(ec, 0): qtCompilerErrror($$QMAKE_CXX, $$output)

        rim_qcc {
            for (line, output) {
@ -124,7 +127,7 @@ isEmpty($${target_prefix}.INCDIRS) {
            # What's more, -print-search-dirs can't be used on clang on Apple because it
            # won't print all the library paths (only the clang-internal ones).
            output = $$system("$$cmd_prefix $$QMAKE_CXX -print-search-dirs", lines, ec)
-            !equals(ec, 0): qtCompilerErrror($$QMAKE_CXX)
+            !equals(ec, 0): qtCompilerErrror($$QMAKE_CXX, $$output)

            for (line, output) {
                contains(line, "^libraries: .*") {
@ -166,14 +169,14 @@ isEmpty($${target_prefix}.INCDIRS) {

 defineReplace(qtVariablesFromMSVC) {
    ret = $$system("$$1 -nologo -E $$2 $$system_quote($$PWD/data/macros.cpp) <NUL 2>NUL", lines, ec)
-    !equals(ec, 0): qtCompilerErrror($$1)
+    !equals(ec, 0): qtCompilerErrror($$1, $$ret)
    return($$ret)
 }

 defineReplace(qtVariablesFromGCC) {
    ret = $$system("$$1 -E $$system_quote($$PWD/data/macros.cpp) \
        <$$QMAKE_SYSTEM_NULL_DEVICE 2>$$QMAKE_SYSTEM_NULL_DEVICE", lines, ec)
-    !equals(ec, 0): qtCompilerErrror($$1)
+    !equals(ec, 0): qtCompilerErrror($$1, $$ret)
    return($$ret)
 }

--- a/mkspecs/features/uikit/xcodebuild.mk
+++ b/mkspecs/features/uikit/xcodebuild.mk
@ -90,7 +90,7 @@ DESTINATION_MESSAGE = "Running $(call tolower,$(CONFIGURATION)) $(ACTION) \

 xcodebuild-%:
 		@$(if $(DESTINATION_NAME), echo $(DESTINATION_MESSAGE),)
-		xcodebuild $(ACTION) $(XCODEBUILD_FLAGS) -project $(TARGET).xcodeproj -scheme $(TARGET) $(if $(SDK), -sdk $(SDK),) $(if $(CONFIGURATION), -configuration $(CONFIGURATION),) $(if $(DESTINATION), -destination $(DESTINATION) -destination-timeout 1,) $(if $(INSTALL_ROOT), DSTROOT=$(INSTALL_ROOT),)
+		xcodebuild $(ACTION) $(XCODEBUILD_FLAGS) -project $(TARGET).xcodeproj -scheme $(TARGET) $(if $(SDK), -sdk $(SDK),) $(if $(CONFIGURATION), -configuration $(CONFIGURATION),) $(if $(DESTINATION), -destination $(DESTINATION) -destination-timeout 1,) $(if $(DESTINATION_ID),, ENABLE_ONLY_ACTIVE_RESOURCES=NO) $(if $(INSTALL_ROOT), DSTROOT=$(INSTALL_ROOT),)

 xcodebuild-check-device_%: DESTINATION_ID=$(lastword $(subst _, ,$@))

--- a/mkspecs/integrity-armv8-rcar/qmake.conf
+++ b/mkspecs/integrity-armv8-rcar/qmake.conf
@ -0,0 +1,33 @@
+#
+# qmake configuration for INTEGRITY armv7 targets
+#
+
+# armv7 common includes work for armv8-A as well
+include(../common/ghs-integrity-armv7.conf)
+
+DEFINES += INTEGRITY
+
+# This define is used because the RCar INTEGRITY EGL library expects same
+# parameter types as Symbian. The parameter types are defined in eglplatform.h.
+DEFINES += __WINSCW__
+
+QTPLUGIN.platforms += qeglfs
+QT_QPA_DEFAULT_PLATFORM = eglfs
+
+QMAKE_LIBS_EGL         += -lEGL -lIMGegl -lsrv_um -lsrv_init -lpvrWSEGL_WM -lncg_usr.a -lmmgr_usr -lwm_usr -lprr_usr
+QMAKE_LIBS_OPENGL_ES2  += -lGLESv2 -lIMGegl -lglslcompiler -lusc -lsrv_um -lsrv_init -lpvrWSEGL_WM -lncg_usr.a -lmmgr_usr -lwm_usr -lprr_usr
+QMAKE_LIBS_GUI          = -lmmgr_usr -lwm_usr -lprr_usr
+
+QMAKE_CFLAGS += -bigswitch
+QMAKE_CXXFLAGS += -bigswitch
+QMAKE_LFLAGS += -bigswitch
+
+EGLFS_DEVICE_INTEGRATION = eglfs_rcar
+
+# OpenGL libraries have a dependency on libEGL
+dirs = $$(GL_INC_DIR)
+QMAKE_INCDIR_EGL = $$split(dirs, $$QMAKE_DIRLIST_SEP)
+QMAKE_INCDIR_OPENGL_ES2 = $$QMAKE_INCDIR_EGL
+dirs = $$(GL_LIB_DIR)
+QMAKE_LIBDIR_EGL = $$split(dirs, $$QMAKE_DIRLIST_SEP)
+QMAKE_LIBDIR_OPENGL_ES2 = $$QMAKE_LIBDIR_EGL
--- a/mkspecs/integrity-armv8-rcar/qplatformdefs.h
+++ b/mkspecs/integrity-armv8-rcar/qplatformdefs.h
@ -0,0 +1,39 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Green Hills Software. All rights reserved.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the qmake spec 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 QPLATFORMDEFS_H
+#define QPLATFORMDEFS_H
+
+#include "../common/integrity/qplatformdefs.h"
+
+#endif // QPLATFORMDEFS_H
--- a/mkspecs/win32-g++/qmake.conf
+++ b/mkspecs/win32-g++/qmake.conf
@ -8,18 +8,17 @@
 #

 load(device_config)
+include(../common/gcc-base.conf)
 include(../common/g++-base.conf)

+# modifications to gcc-base.conf and g++-base.conf
+
 MAKEFILE_GENERATOR      = MINGW
 QMAKE_PLATFORM          = win32 mingw
 CONFIG                 += debug_and_release debug_and_release_target precompile_header
 DEFINES                += UNICODE _UNICODE
 QMAKE_COMPILER_DEFINES += __GNUC__ WIN32

-QMAKE_EXT_OBJ           = .o
-QMAKE_EXT_RES           = _res.o
-
-
 QMAKE_CC                = $${CROSS_COMPILE}gcc
 QMAKE_LEX               = flex
 QMAKE_LEXFLAGS          =
@ -27,12 +26,12 @@ QMAKE_YACC              = bison -y
 QMAKE_YACCFLAGS         = -d
 QMAKE_CFLAGS           += -fno-keep-inline-dllexport
 QMAKE_CFLAGS_WARN_ON   += -Wextra
+
 QMAKE_CFLAGS_SSE2      += -mstackrealign
 QMAKE_CFLAGS_AESNI      = -maes
 QMAKE_CFLAGS_SHANI      = -msha

 QMAKE_CXX               = $${CROSS_COMPILE}g++
-QMAKE_CXXFLAGS_THREAD   = $$QMAKE_CFLAGS_THREAD
 QMAKE_CXXFLAGS_RTTI_ON  = -frtti
 QMAKE_CXXFLAGS_RTTI_OFF = -fno-rtti
 QMAKE_CXXFLAGS_EXCEPTIONS_ON = -fexceptions -mthreads
@ -56,6 +55,8 @@ equals(QMAKE_HOST.os, Windows) {
    QMAKE_LINK_OBJECT_MAX = 10
    QMAKE_LINK_OBJECT_SCRIPT = object_script
 }
+QMAKE_EXT_OBJ           = .o
+QMAKE_EXT_RES           = _res.o
 QMAKE_PREFIX_SHLIB      =
 QMAKE_EXTENSION_SHLIB   = dll
 QMAKE_PREFIX_STATICLIB  = lib
--- a/mkspecs/win32-icc/qmake.conf
+++ b/mkspecs/win32-icc/qmake.conf
@ -17,9 +17,10 @@ QMAKE_CC                = icl
 QMAKE_CFLAGS            = -nologo -Zm200 /Qprec /Qwd1744,1738,809,3373
 QMAKE_CFLAGS_WARN_ON    = -W3 /Qwd673
 QMAKE_CFLAGS_WARN_OFF   = -W0 /Qwd673
-QMAKE_CFLAGS_DEBUG      = -Zi -MDd -Od
+QMAKE_CFLAGS_DEBUG      = -Od -Zi -MDd
 QMAKE_CFLAGS_LTCG       = -Qipo
 QMAKE_CFLAGS_DISABLE_LTCG = -Qno-ipo
+
 QMAKE_CFLAGS_SSE2       = -QxSSE2
 QMAKE_CFLAGS_SSE3       = -QxSSE3
 QMAKE_CFLAGS_SSSE3      = -QxSSSE3
@ -50,16 +51,10 @@ QMAKE_CXXFLAGS_LTCG     = $$QMAKE_CFLAGS_LTCG
 QMAKE_CXXFLAGS_DISABLE_LTCG = $$QMAKE_CFLAGS_DISABLE_LTCG

 QMAKE_LINK              = xilink
-QMAKE_LFLAGS            = /NOLOGO
-QMAKE_LFLAGS_RELEASE    =
-QMAKE_LFLAGS_RELEASE_WITH_DEBUGINFO =
-QMAKE_LFLAGS_DEBUG      = /DEBUG
 QMAKE_LFLAGS_LTCG       = $$QMAKE_CFLAGS_LTCG

 QMAKE_LIB               = xilib /NOLOGO

-DSP_EXTENSION           = .dsp
-
 include(../common/angle.conf)
 include(../common/windows-vulkan.conf)

--- a/qmake/Makefile.unix.mingw
+++ b/qmake/Makefile.unix.mingw
@ -9,7 +9,7 @@
 # sh-compatible shell. This is not a problem, because configure.bat
 # will not do that.
 ifeq ($(SHELL), sh.exe)
-    ifeq ($(wildcard $(CURDIR)/sh.exe), )
+    ifeq ($(wildcard ./sh.exe), )
        SH = 0
    else
        SH = 1
--- a/qmake/generators/mac/pbuilder_pbx.cpp
+++ b/qmake/generators/mac/pbuilder_pbx.cpp
@ -280,8 +280,6 @@ ProjectBuilderMakefileGenerator::writeSubDirs(QTextStream &t)

        QMap<QString, QString> settings;
        settings.insert("COPY_PHASE_STRIP", (as_release ? "YES" : "NO"));
-        if(as_release)
-            settings.insert("GCC_GENERATE_DEBUGGING_SYMBOLS", "NO");
        if(project->isActiveConfig("sdk") && !project->isEmpty("QMAKE_MAC_SDK"))
            settings.insert("SDKROOT", project->first("QMAKE_MAC_SDK").toQString());
        {
@ -1499,7 +1497,6 @@ ProjectBuilderMakefileGenerator::writeMakeParts(QTextStream &t)
        settings.insert("APPLICATION_EXTENSION_API_ONLY", project->isActiveConfig("app_extension_api_only") ? "YES" : "NO");
        // required for tvOS (and watchos), optional on iOS (deployment target >= iOS 6.0)
        settings.insert("ENABLE_BITCODE", project->isActiveConfig("bitcode") ? "YES" : "NO");
-        settings.insert("GCC_GENERATE_DEBUGGING_SYMBOLS", as_release ? "NO" : "YES");
        if(!as_release)
            settings.insert("GCC_OPTIMIZATION_LEVEL", "0");
        if(project->isActiveConfig("sdk") && !project->isEmpty("QMAKE_MAC_SDK"))
--- a/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
+++ b/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
@ -707,15 +707,15 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
    d3d11::PositionTexCoordVertex *vertices = static_cast<d3d11::PositionTexCoordVertex*>(mappedResource.pData);

    // Create a quad in homogeneous coordinates
-    float x1 = (x / float(mWidth)) * 2.0f - 1.0f;
-    float y1 = (y / float(mHeight)) * 2.0f - 1.0f;
-    float x2 = ((x + width) / float(mWidth)) * 2.0f - 1.0f;
-    float y2 = ((y + height) / float(mHeight)) * 2.0f - 1.0f;
+    float x1 = (x / float(width)) * 2.0f - 1.0f;
+    float y1 = (y / float(height)) * 2.0f - 1.0f;
+    float x2 = ((x + width) / float(width)) * 2.0f - 1.0f;
+    float y2 = ((y + height) / float(height)) * 2.0f - 1.0f;

-    float u1 = x / float(mWidth);
-    float v1 = y / float(mHeight);
-    float u2 = (x + width) / float(mWidth);
-    float v2 = (y + height) / float(mHeight);
+    float u1 = x / float(width);
+    float v1 = y / float(height);
+    float u2 = (x + width) / float(width);
+    float v2 = (y + height) / float(height);

    // Invert the quad vertices depending on the surface orientation.
    if ((mOrientation & EGL_SURFACE_ORIENTATION_INVERT_X_ANGLE) != 0)
@ -760,8 +760,8 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
    D3D11_VIEWPORT viewport;
    viewport.TopLeftX = 0;
    viewport.TopLeftY = 0;
-    viewport.Width = static_cast<FLOAT>(mWidth);
-    viewport.Height = static_cast<FLOAT>(mHeight);
+    viewport.Width = static_cast<FLOAT>(width);
+    viewport.Height =  static_cast<FLOAT>(height);
    viewport.MinDepth = 0.0f;
    viewport.MaxDepth = 1.0f;
    deviceContext->RSSetViewports(1, &viewport);
--- a/src/3rdparty/freetype/qt_attribution.json
+++ b/src/3rdparty/freetype/qt_attribution.json
@ -9,7 +9,7 @@
        "Homepage": "http://www.freetype.org",
        "License": "Freetype Project License or GNU General Public License v2.0 only",
        "LicenseId": "FTL OR GPL-2.0",
-        "LicenseFile": "LICENSE.TXT",
+        "LicenseFile": "LICENSE.txt",
        "Copyright": "Copyright 2006-2015 by David Turner, Robert Wilhelm, and Werner Lemberg."
    },
    {
@ -22,7 +22,7 @@
        "Homepage": "http://www.freetype.org",
        "License": "zlib License",
        "LicenseId": "Zlib",
-        "LicenseFile": "ZLIB-LICENSE.TXT",
+        "LicenseFile": "ZLIB-LICENSE.txt",
        "Copyright": "Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler"
    },
    {
@ -35,7 +35,7 @@
        "Homepage": "http://www.freetype.org",
        "License": "MIT License",
        "LicenseId": "MIT",
-        "LicenseFile": "BDF-LICENSE.TXT",
+        "LicenseFile": "BDF-LICENSE.txt",
        "Copyright": "Copyright (C) 2001-2002 by Francesco Zappa Nardelli
 Copyright 2000 Computing Research Labs, New Mexico State University
 Copyright 2001-2002, 2011 Francesco Zappa Nardelli"
@ -50,7 +50,7 @@ Copyright 2001-2002, 2011 Francesco Zappa Nardelli"
        "Homepage": "http://www.freetype.org",
        "License": "MIT License",
        "LicenseId": "MIT",
-        "LicenseFile": "PCF-LICENSE.TXT",
+        "LicenseFile": "PCF-LICENSE.txt",
        "Copyright": "Copyright (C) 2000 by Francesco Zappa Nardelli"
    }
 ]
--- a/src/android/jar/src/org/qtproject/qt5/android/QtActivityDelegate.java
+++ b/src/android/jar/src/org/qtproject/qt5/android/QtActivityDelegate.java
@ -1156,7 +1156,7 @@ public class QtActivityDelegate
            return false;

        m_metaState = MetaKeyKeyListener.handleKeyDown(m_metaState, keyCode, event);
-        int c = event.getUnicodeChar(MetaKeyKeyListener.getMetaState(m_metaState));
+        int c = event.getUnicodeChar(MetaKeyKeyListener.getMetaState(m_metaState) | event.getMetaState());
        int lc = c;
        m_metaState = MetaKeyKeyListener.adjustMetaAfterKeypress(m_metaState);

--- a/src/angle/patches/0016-ANGLE-Fix-resizing-of-windows.patch
+++ b/src/angle/patches/0016-ANGLE-Fix-resizing-of-windows.patch
@ -0,0 +1,57 @@
+From 55821d34b2208e7858dbba5648760b83c66b58a5 Mon Sep 17 00:00:00 2001
+From: Oliver Wolff <oliver.wolff@qt.io>
+Date: Mon, 29 Aug 2016 09:48:28 +0200
+Subject: [PATCH] ANGLE: Fix resizing of windows
+
+Use the correct height/width values when calculating
+the vector for resizing the window content and the
+new size as viewport size.
+
+Task-number: QTBUG-62475
+Change-Id: I33a8dc1379a908e991b04bc31dfc6254a6d005c9
+---
+ .../libANGLE/renderer/d3d/d3d11/SwapChain11.cpp    | 35 +++++++++++-----------
+ 1 file changed, 17 insertions(+), 18 deletions(-)
+
+diff --git a/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp b/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
+index 785a83cd77..fe72bc935d 100644
+--- a/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
+++ b/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
+@@ -707,15 +706,15 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
+     d3d11::PositionTexCoordVertex *vertices = static_cast<d3d11::PositionTexCoordVertex*>(mappedResource.pData);
+ 
+     // Create a quad in homogeneous coordinates
+-    float x1 = (x / float(mWidth)) * 2.0f - 1.0f;
+-    float y1 = (y / float(mHeight)) * 2.0f - 1.0f;
+-    float x2 = ((x + width) / float(mWidth)) * 2.0f - 1.0f;
+-    float y2 = ((y + height) / float(mHeight)) * 2.0f - 1.0f;
+    float x1 = (x / float(width)) * 2.0f - 1.0f;
+    float y1 = (y / float(height)) * 2.0f - 1.0f;
+    float x2 = ((x + width) / float(width)) * 2.0f - 1.0f;
+    float y2 = ((y + height) / float(height)) * 2.0f - 1.0f;
+ 
+-    float u1 = x / float(mWidth);
+-    float v1 = y / float(mHeight);
+-    float u2 = (x + width) / float(mWidth);
+-    float v2 = (y + height) / float(mHeight);
+    float u1 = x / float(width);
+    float v1 = y / float(height);
+    float u2 = (x + width) / float(width);
+    float v2 = (y + height) / float(height);
+ 
+     // Invert the quad vertices depending on the surface orientation.
+     if ((mOrientation & EGL_SURFACE_ORIENTATION_INVERT_X_ANGLE) != 0)
+@@ -760,8 +759,8 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
+     D3D11_VIEWPORT viewport;
+     viewport.TopLeftX = 0;
+     viewport.TopLeftY = 0;
+-    viewport.Width = static_cast<FLOAT>(mWidth);
+-    viewport.Height = static_cast<FLOAT>(mHeight);
+    viewport.Width = static_cast<FLOAT>(width);
+    viewport.Height =  static_cast<FLOAT>(height);
+     viewport.MinDepth = 0.0f;
+     viewport.MaxDepth = 1.0f;
+     deviceContext->RSSetViewports(1, &viewport);
+-- 
+2.15.0.windows.1
+
--- a/src/corelib/animation/qabstractanimation.cpp
+++ b/src/corelib/animation/qabstractanimation.cpp
@ -299,13 +299,13 @@ void QUnifiedTimer::stopAnimationDriver()
    driver->stop();
 }

-void QUnifiedTimer::updateAnimationTimers(qint64)
+void QUnifiedTimer::updateAnimationTimers(qint64 currentTick)
 {
    //setCurrentTime can get this called again while we're the for loop. At least with pauseAnimations
    if(insideTick)
        return;

-    qint64 totalElapsed = elapsed();
+    qint64 totalElapsed = currentTick > 0 ? currentTick : elapsed();

    // ignore consistentTiming in case the pause timer is active
    qint64 delta = (consistentTiming && !pauseTimer.isActive()) ?
--- a/src/corelib/configure.json
+++ b/src/corelib/configure.json
@ -178,7 +178,7 @@
        "slog2": {
            "label": "slog2",
            "test": {
-                "include": "slog2.h",
+                "include": "sys/slog2.h",
                "main": "slog2_set_default_buffer((slog2_buffer_t)-1);"
            },
            "export": "",
@ -608,7 +608,7 @@
            "label": "PPS",
            "emitIf": "config.qnx",
            "condition": "libs.pps",
-            "output": [ "privateConfig" ]
+            "output": [ "privateFeature" ]
        },
        "qeventtransition": {
            "label": "QEventTransition class",
--- a/src/corelib/doc/snippets/qstring/main.cpp
+++ b/src/corelib/doc/snippets/qstring/main.cpp
@ -750,7 +750,6 @@ void Widget::sizeFunction()
    int n = str.size();         // n == 5
    str.data()[0];              // returns 'W'
    str.data()[4];              // returns 'd'
-    str.data()[5];              // returns '\0'
    //! [58]
 }

--- a/src/corelib/global/global.pri
+++ b/src/corelib/global/global.pri
@ -42,7 +42,10 @@ SOURCES += \
 VERSIONTAGGING_SOURCES = global/qversiontagging.cpp

 darwin: SOURCES += global/qoperatingsystemversion_darwin.mm
-win32: SOURCES += global/qoperatingsystemversion_win.cpp
+win32 {
+    SOURCES += global/qoperatingsystemversion_win.cpp
+    HEADERS += global/qoperatingsystemversion_win_p.h
+}

 # qlibraryinfo.cpp includes qconfig.cpp
 INCLUDEPATH += $$QT_BUILD_TREE/src/corelib/global
--- a/src/corelib/global/qfloat16_p.h
+++ b/src/corelib/global/qfloat16_p.h
@ -61,9 +61,9 @@ static inline bool qt_is_inf(qfloat16 d) Q_DECL_NOTHROW
    bool is_inf;
    uchar *ch = (uchar *)&d;
    if (QSysInfo::ByteOrder == QSysInfo::BigEndian)
-        is_inf = (ch[0] & 0x7c) == 0x7c;
+        is_inf = (ch[0] & 0x7c) == 0x7c && (ch[0] & 0x02) == 0;
    else
-        is_inf = (ch[1] & 0x7c) == 0x7c;
+        is_inf = (ch[1] & 0x7c) == 0x7c && (ch[1] & 0x02) == 0;
    return is_inf;
 }

--- a/src/corelib/global/qglobal.cpp
+++ b/src/corelib/global/qglobal.cpp
@ -46,6 +46,9 @@
 #include "qdatetime.h"
 #include "qoperatingsystemversion.h"
 #include "qoperatingsystemversion_p.h"
+#if defined(Q_OS_WIN) || defined(Q_OS_CYGWIN) || defined(Q_OS_WINRT)
+#include "qoperatingsystemversion_win_p.h"
+#endif
 #include <private/qlocale_tools_p.h>

 #include <qmutex.h>
--- a/src/corelib/global/qlogging.cpp
+++ b/src/corelib/global/qlogging.cpp
@ -61,7 +61,7 @@
 #include <qt_windows.h>
 #endif
 #if QT_CONFIG(slog2)
-#include <slog2.h>
+#include <sys/slog2.h>
 #endif
 #if QT_HAS_INCLUDE(<paths.h>)
 #include <paths.h>
--- a/src/corelib/global/qnamespace.h
+++ b/src/corelib/global/qnamespace.h
@ -477,6 +477,8 @@ public:

        WA_TabletTracking = 129,

+        WA_ContentsMarginsRespectsSafeArea = 130,
+
        // Add new attributes before this line
        WA_AttributeCount
    };
--- a/src/corelib/global/qoperatingsystemversion_win.cpp
+++ b/src/corelib/global/qoperatingsystemversion_win.cpp
@ -37,7 +37,10 @@
 **
 ****************************************************************************/

+#include "qoperatingsystemversion_win_p.h"
+
 #include "qoperatingsystemversion_p.h"
+
 #include <qt_windows.h>
 #include <qbytearray.h>

--- a/src/corelib/global/qoperatingsystemversion_win_p.h
+++ b/src/corelib/global/qoperatingsystemversion_win_p.h
@ -0,0 +1,63 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 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 QOPERATINGSYSTEMVERSION_WIN_P_H
+#define QOPERATINGSYSTEMVERSION_WIN_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>
+#include <qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+OSVERSIONINFOEX qWindowsVersionInfo();
+
+QT_END_NAMESPACE
+
+#endif // QOPERATINGSYSTEMVERSION_WIN_P_H
--- a/src/corelib/io/qfilesystemengine_win.cpp
+++ b/src/corelib/io/qfilesystemengine_win.cpp
@ -160,6 +160,7 @@ static TRUSTEE_W currentUserTrusteeW;
 static TRUSTEE_W worldTrusteeW;
 static PSID currentUserSID = 0;
 static PSID worldSID = 0;
+static HANDLE currentUserImpersonatedToken = nullptr;

 QT_BEGIN_NAMESPACE

@ -180,6 +181,11 @@ GlobalSid::~GlobalSid()
        ::FreeSid(worldSID);
        worldSID = 0;
    }
+
+    if (currentUserImpersonatedToken) {
+        ::CloseHandle(currentUserImpersonatedToken);
+        currentUserImpersonatedToken = nullptr;
+    }
 }

 GlobalSid::GlobalSid()
@ -210,6 +216,12 @@ GlobalSid::GlobalSid()
                ::CloseHandle(token);
            }

+            token = nullptr;
+            if (::OpenProcessToken(hnd, TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_DUPLICATE | STANDARD_RIGHTS_READ, &token)) {
+                ::DuplicateToken(token, SecurityImpersonation, &currentUserImpersonatedToken);
+                ::CloseHandle(token);
+            }
+
            {
                // Create TRUSTEE for Everyone (World)
                SID_IDENTIFIER_AUTHORITY worldAuth = { SECURITY_WORLD_SID_AUTHORITY };
@ -724,15 +736,49 @@ bool QFileSystemEngine::fillPermissions(const QFileSystemEntry &entry, QFileSyst
                ACCESS_MASK access_mask;
                TRUSTEE_W trustee;
                if (what & QFileSystemMetaData::UserPermissions) { // user
-                    data.knownFlagsMask |= QFileSystemMetaData::UserPermissions;
-                    if (GetEffectiveRightsFromAcl(pDacl, &currentUserTrusteeW, &access_mask) != ERROR_SUCCESS)
-                        access_mask = (ACCESS_MASK)-1;
-                    if(access_mask & ReadMask)
-                        data.entryFlags |= QFileSystemMetaData::UserReadPermission;
-                    if(access_mask & WriteMask)
-                        data.entryFlags|= QFileSystemMetaData::UserWritePermission;
-                    if(access_mask & ExecMask)
-                        data.entryFlags|= QFileSystemMetaData::UserExecutePermission;
+                    // Using AccessCheck because GetEffectiveRightsFromAcl doesn't account for elevation
+                    if (currentUserImpersonatedToken) {
+                        GENERIC_MAPPING mapping = {FILE_GENERIC_READ, FILE_GENERIC_WRITE, FILE_GENERIC_EXECUTE, FILE_ALL_ACCESS};
+                        PRIVILEGE_SET privileges;
+                        DWORD grantedAccess;
+                        BOOL result;
+
+                        data.knownFlagsMask |= QFileSystemMetaData::UserPermissions;
+                        DWORD genericAccessRights = GENERIC_READ;
+                        ::MapGenericMask(&genericAccessRights, &mapping);
+
+                        DWORD privilegesLength = sizeof(privileges);
+                        if (::AccessCheck(pSD, currentUserImpersonatedToken, genericAccessRights,
+                                          &mapping, &privileges, &privilegesLength, &grantedAccess, &result) && result) {
+                            data.entryFlags |= QFileSystemMetaData::UserReadPermission;
+                        }
+
+                        privilegesLength = sizeof(privileges);
+                        genericAccessRights = GENERIC_WRITE;
+                        ::MapGenericMask(&genericAccessRights, &mapping);
+                        if (::AccessCheck(pSD, currentUserImpersonatedToken, genericAccessRights,
+                                          &mapping, &privileges, &privilegesLength, &grantedAccess, &result) && result) {
+                            data.entryFlags |= QFileSystemMetaData::UserWritePermission;
+                        }
+
+                        privilegesLength = sizeof(privileges);
+                        genericAccessRights = GENERIC_EXECUTE;
+                        ::MapGenericMask(&genericAccessRights, &mapping);
+                        if (::AccessCheck(pSD, currentUserImpersonatedToken, genericAccessRights,
+                                          &mapping, &privileges, &privilegesLength, &grantedAccess, &result) && result) {
+                            data.entryFlags |= QFileSystemMetaData::UserExecutePermission;
+                        }
+                    } else { // fallback to GetEffectiveRightsFromAcl
+                        data.knownFlagsMask |= QFileSystemMetaData::UserPermissions;
+                        if (GetEffectiveRightsFromAclW(pDacl, &currentUserTrusteeW, &access_mask) != ERROR_SUCCESS)
+                            access_mask = ACCESS_MASK(-1);
+                        if (access_mask & ReadMask)
+                            data.entryFlags |= QFileSystemMetaData::UserReadPermission;
+                        if (access_mask & WriteMask)
+                            data.entryFlags|= QFileSystemMetaData::UserWritePermission;
+                        if (access_mask & ExecMask)
+                            data.entryFlags|= QFileSystemMetaData::UserExecutePermission;
+                    }
                }
                if (what & QFileSystemMetaData::OwnerPermissions) { // owner
                    data.knownFlagsMask |= QFileSystemMetaData::OwnerPermissions;
--- a/src/corelib/io/qloggingregistry.cpp
+++ b/src/corelib/io/qloggingregistry.cpp
@ -255,7 +255,7 @@ void QLoggingSettingsParser::parseNextLine(QStringRef line)
 QLoggingRegistry::QLoggingRegistry()
    : categoryFilter(defaultCategoryFilter)
 {
-    initalizeRules(); // Init on first use
+    initializeRules(); // Init on first use
 }

 static bool qtLoggingDebug()
@ -284,7 +284,7 @@ static QVector<QLoggingRule> loadRulesFromFile(const QString &filePath)
    Initializes the rules database by loading
    $QT_LOGGING_CONF, $QT_LOGGING_RULES, and .config/QtProject/qtlogging.ini.
 */
-void QLoggingRegistry::initalizeRules()
+void QLoggingRegistry::initializeRules()
 {
    QVector<QLoggingRule> er, qr, cr;
    // get rules from environment
--- a/src/corelib/io/qloggingregistry_p.h
+++ b/src/corelib/io/qloggingregistry_p.h
@ -113,7 +113,7 @@ class Q_AUTOTEST_EXPORT QLoggingRegistry
 public:
    QLoggingRegistry();

-    void initalizeRules();
+    void initializeRules();

    void registerCategory(QLoggingCategory *category, QtMsgType enableForLevel);
    void unregisterCategory(QLoggingCategory *category);
--- a/src/corelib/io/qurl.cpp
+++ b/src/corelib/io/qurl.cpp
@ -90,11 +90,6 @@
    fromPercentEncoding() and toPercentEncoding() which deal with
    percent encoding and decoding of QString objects.

-    Calling isRelative() will tell whether or not the URL is
-    relative. A relative URL can be resolved by passing it as argument
-    to resolved(), which returns an absolute URL. isParentOf() is used
-    for determining whether one URL is a parent of another.
-
    fromLocalFile() constructs a QUrl by parsing a local
    file path. toLocalFile() converts a URL to a local file path.

@ -116,6 +111,37 @@
    from freedesktop.org, provided that the locale encodes file names using
    UTF-8 (required by IDN).

+    \section2 Relative URLs vs Relative Paths
+
+    Calling isRelative() will return whether or not the URL is relative.
+    A relative URL has no \l {scheme}. For example:
+
+    \code
+    qDebug() << QUrl("main.qml").isRelative();          // true: no scheme
+    qDebug() << QUrl("qml/main.qml").isRelative();      // true: no scheme
+    qDebug() << QUrl("file:main.qml").isRelative();     // false: has "file" scheme
+    qDebug() << QUrl("file:qml/main.qml").isRelative(); // false: has "file" scheme
+    \endcode
+
+    Notice that a URL can be absolute while containing a relative path, and
+    vice versa:
+
+    \code
+    // Absolute URL, relative path
+    QUrl url("file:file.txt");
+    qDebug() << url.isRelative();                 // false: has "file" scheme
+    qDebug() << QDir::isAbsolutePath(url.path()); // false: relative path
+
+    // Relative URL, absolute path
+    url = QUrl("/home/user/file.txt");
+    qDebug() << url.isRelative();                 // true: has no scheme
+    qDebug() << QDir::isAbsolutePath(url.path()); // true: absolute path
+    \endcode
+
+    A relative URL can be resolved by passing it as an argument to resolved(),
+    which returns an absolute URL. isParentOf() is used for determining whether
+    one URL is a parent of another.
+
    \section2 Error checking

    QUrl is capable of detecting many errors in URLs while parsing it or when
@ -2539,6 +2565,12 @@ void QUrl::setPath(const QString &path, ParsingMode mode)
 /*!
    Returns the path of the URL.

+    \code
+    qDebug() << QUrl("file:file.txt").path();                   // "file.txt"
+    qDebug() << QUrl("/home/user/file.txt").path();             // "/home/user/file.txt"
+    qDebug() << QUrl("http://www.example.com/test/123").path(); // "/test/123"
+    \endcode
+
    The \a options argument controls how to format the path component. All
    values produce an unambiguous result. With QUrl::FullyDecoded, all
    percent-encoded sequences are decoded; otherwise, the returned value may
@ -2549,6 +2581,31 @@ void QUrl::setPath(const QString &path, ParsingMode mode)
    sequences are present. It is recommended to use that value when the result
    will be used in a non-URL context, such as sending to an FTP server.

+    An example of data loss is when you have non-Unicode percent-encoded sequences
+    and use FullyDecoded (the default):
+
+    \code
+    qDebug() << QUrl("/foo%FFbar").path();
+    \endcode
+
+    In this example, there will be some level of data loss because the \c %FF cannot
+    be converted.
+
+    Data loss can also occur when the path contains sub-delimiters (such as \c +):
+
+    \code
+    qDebug() << QUrl("/foo+bar%2B").path(); // "/foo+bar+"
+    \endcode
+
+    Other decoding examples:
+
+    \code
+    const QUrl url("/tmp/Mambo %235%3F.mp3");
+    qDebug() << url.path(QUrl::FullyDecoded);  // "/tmp/Mambo #5?.mp3"
+    qDebug() << url.path(QUrl::PrettyDecoded); // "/tmp/Mambo #5?.mp3"
+    qDebug() << url.path(QUrl::FullyEncoded);  // "/tmp/Mambo%20%235%3F.mp3"
+    \endcode
+
    \sa setPath()
 */
 QString QUrl::path(ComponentFormattingOptions options) const
@ -3257,6 +3314,8 @@ QUrl QUrl::resolved(const QUrl &relative) const
    equivalent to calling scheme().isEmpty().

    Relative references are defined in RFC 3986 section 4.2.
+
+    \sa {Relative URLs vs Relative Paths}
 */
 bool QUrl::isRelative() const
 {
@ -3796,6 +3855,41 @@ bool QUrl::isDetached() const

    An empty \a localFile leads to an empty URL (since Qt 5.4).

+    \code
+    qDebug() << QUrl::fromLocalFile("file.txt");            // QUrl("file:file.txt")
+    qDebug() << QUrl::fromLocalFile("/home/user/file.txt"); // QUrl("file:///home/user/file.txt")
+    qDebug() << QUrl::fromLocalFile("file:file.txt");       // doesn't make sense; expects path, not url with scheme
+    \endcode
+
+    In the first line in snippet above, a file URL is constructed from a
+    local, relative path. A file URL with a relative path only makes sense
+    if there is a base URL to resolve it against. For example:
+
+    \code
+    QUrl url = QUrl::fromLocalFile("file.txt");
+    QUrl baseUrl = QUrl("file:/home/user/");
+    // wrong: prints QUrl("file:file.txt"), as url already has a scheme
+    qDebug() << baseUrl.resolved(url);
+    \endcode
+
+    To resolve such a URL, it's necessary to remove the scheme beforehand:
+
+    \code
+    // correct: prints QUrl("file:///home/user/file.txt")
+    url.setScheme(QString());
+    qDebug() << baseUrl.resolved(url);
+    \endcode
+
+    For this reason, it is better to use a relative URL (that is, no scheme)
+    for relative file paths:
+
+    \code
+    QUrl url = QUrl("file.txt");
+    QUrl baseUrl = QUrl("file:/home/user/");
+    // prints QUrl("file:///home/user/file.txt")
+    qDebug() << baseUrl.resolved(url);
+    \endcode
+
    \sa toLocalFile(), isLocalFile(), QDir::toNativeSeparators()
 */
 QUrl QUrl::fromLocalFile(const QString &localFile)
@ -3840,6 +3934,12 @@ QUrl QUrl::fromLocalFile(const QString &localFile)
    returned value in the form found on SMB networks (for example,
    "//servername/path/to/file.txt").

+    \code
+    qDebug() << QUrl("file:file.txt").toLocalFile();            // "file:file.txt"
+    qDebug() << QUrl("file:/home/user/file.txt").toLocalFile(); // "file:///home/user/file.txt"
+    qDebug() << QUrl("file.txt").toLocalFile();                 // ""; wasn't a local file as it had no scheme
+    \endcode
+
    Note: if the path component of this URL contains a non-UTF-8 binary
    sequence (such as %80), the behaviour of this function is undefined.

--- a/src/corelib/kernel/kernel.pri
+++ b/src/corelib/kernel/kernel.pri
@ -188,7 +188,7 @@ vxworks {
                kernel/qfunctions_vxworks.h
 }

-qqnx_pps {
+qnx:qtConfig(qqnx_pps) {
        QMAKE_USE_PRIVATE += pps
        SOURCES += \
                kernel/qppsattribute.cpp \
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@ -2196,11 +2196,11 @@ QString QCoreApplication::applicationFilePath()
    QCoreApplicationPrivate *d = self->d_func();

    if (d->argc) {
-        static const char *procName = d->argv[0];
-        if (qstrcmp(procName, d->argv[0]) != 0) {
+        static QByteArray procName = QByteArray(d->argv[0]);
+        if (procName != d->argv[0]) {
            // clear the cache if the procname changes, so we reprocess it.
            QCoreApplicationPrivate::clearApplicationFilePath();
-            procName = d->argv[0];
+            procName = QByteArray(d->argv[0]);
        }
    }

--- a/src/corelib/kernel/qobject.cpp
+++ b/src/corelib/kernel/qobject.cpp
@ -4796,7 +4796,7 @@ QMetaObject::Connection QObjectPrivate::connectImpl(const QObject *sender, int s
                                             QtPrivate::QSlotObjectBase *slotObj, Qt::ConnectionType type,
                                             const int *types, const QMetaObject *senderMetaObject)
 {
-    if (!sender || !slotObj || !senderMetaObject) {
+    if (!sender || !receiver || !slotObj || !senderMetaObject) {
        qWarning("QObject::connect: invalid null parameter");
        if (slotObj)
            slotObj->destroyIfLastRef();
--- a/src/corelib/kernel/qppsobjectprivate_p.h
+++ b/src/corelib/kernel/qppsobjectprivate_p.h
@ -57,13 +57,15 @@
 #include <QDebug>

 #include <sys/pps.h>
+#include <private/qobject_p.h>

 QT_BEGIN_NAMESPACE

 class QSocketNotifier;

-class QPpsObjectPrivate
+class QPpsObjectPrivate : public QObjectPrivate
 {
+    Q_DECLARE_PUBLIC(QPpsObject)
 public:
    explicit QPpsObjectPrivate(const QString &path);

--- a/src/corelib/statemachine/qstatemachine.cpp
+++ b/src/corelib/statemachine/qstatemachine.cpp
@ -3096,10 +3096,12 @@ int QSignalEventGenerator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)

 void QSignalEventGenerator::execute(void **_a)
 {
+    auto machinePrivate = QStateMachinePrivate::get(qobject_cast<QStateMachine*>(parent()));
+    if (machinePrivate->state != QStateMachinePrivate::Running)
+        return;
    int signalIndex = senderSignalIndex();
    Q_ASSERT(signalIndex != -1);
-    QStateMachine *machine = qobject_cast<QStateMachine*>(parent());
-    QStateMachinePrivate::get(machine)->handleTransitionSignal(sender(), signalIndex, _a);
+    machinePrivate->handleTransitionSignal(sender(), signalIndex, _a);
 }

 QSignalEventGenerator::QSignalEventGenerator(QStateMachine *parent)
--- a/src/corelib/thread/qfuturewatcher.h
+++ b/src/corelib/thread/qfuturewatcher.h
@ -115,7 +115,7 @@ template <typename T>
 class QFutureWatcher : public QFutureWatcherBase
 {
 public:
-    explicit QFutureWatcher(QObject *_parent = 0)
+    explicit QFutureWatcher(QObject *_parent = nullptr)
        : QFutureWatcherBase(_parent)
    { }
    ~QFutureWatcher()
--- a/src/corelib/tools/qmap.h
+++ b/src/corelib/tools/qmap.h
@ -115,9 +115,9 @@ struct QMapNode : public QMapNodeBase
    inline QMapNode *leftNode() const { return static_cast<QMapNode *>(left); }
    inline QMapNode *rightNode() const { return static_cast<QMapNode *>(right); }

-    inline const QMapNode *nextNode() const { return static_cast<const QMapNode *>(QMapNodeBase::nextNode()); }
+    inline const QMapNode *nextNode() const { return reinterpret_cast<const QMapNode *>(QMapNodeBase::nextNode()); }
    inline const QMapNode *previousNode() const { return static_cast<const QMapNode *>(QMapNodeBase::previousNode()); }
-    inline QMapNode *nextNode() { return static_cast<QMapNode *>(QMapNodeBase::nextNode()); }
+    inline QMapNode *nextNode() { return reinterpret_cast<QMapNode *>(QMapNodeBase::nextNode()); }
    inline QMapNode *previousNode() { return static_cast<QMapNode *>(QMapNodeBase::previousNode()); }

    QMapNode<Key, T> *copy(QMapData<Key, T> *d) const;
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@ -5517,14 +5517,9 @@ QString& QString::fill(QChar ch, int size)

    Returns the number of characters in this string.

-    The last character in the string is at position size() - 1. In
-    addition, QString ensures that the character at position size()
-    is always '\\0', so that you can use the return value of data()
-    and constData() as arguments to functions that expect
-    '\\0'-terminated strings.
+    The last character in the string is at position size() - 1.

    Example:
-
    \snippet qstring/main.cpp 58

    \sa isEmpty(), resize()
@ -6042,10 +6037,13 @@ int QString::localeAwareCompare_helper(const QChar *data1, int length1,
 /*!
    \fn const QChar *QString::unicode() const

-    Returns a '\\0'-terminated Unicode representation of the string.
+    Returns a Unicode representation of the string.
    The result remains valid until the string is modified.

-    \sa utf16()
+    \note The returned string may not be '\\0'-terminated.
+    Use size() to determine the length of the array.
+
+    \sa utf16(), fromRawData()
 */

 /*!
@ -8515,7 +8513,10 @@ bool QString::isRightToLeft() const

    Returns a pointer to the data stored in the QString. The pointer
    can be used to access and modify the characters that compose the
-    string. For convenience, the data is '\\0'-terminated.
+    string.
+
+    Unlike constData() and unicode(), the returned data is always
+    '\\0'-terminated.

    Example:

@ -8531,18 +8532,25 @@ bool QString::isRightToLeft() const
 /*! \fn const QChar *QString::data() const

    \overload
+
+    \note The returned string may not be '\\0'-terminated.
+    Use size() to determine the length of the array.
+
+    \sa fromRawData()
 */

 /*! \fn const QChar *QString::constData() const

    Returns a pointer to the data stored in the QString. The pointer
-    can be used to access the characters that compose the string. For
-    convenience, the data is '\\0'-terminated.
+    can be used to access the characters that compose the string.

    Note that the pointer remains valid only as long as the string is
    not modified.

-    \sa data(), operator[]()
+    \note The returned string may not be '\\0'-terminated.
+    Use size() to determine the length of the array.
+
+    \sa data(), operator[](), fromRawData()
 */

 /*! \fn void QString::push_front(const QString &other)
--- a/src/corelib/tools/qunicodetables.cpp
+++ b/src/corelib/tools/qunicodetables.cpp
@ -6083,9 +6083,9 @@ static const Properties uc_properties[] = {
    { 18, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 7, 8, 13, 7 },
    { 25, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 8, 8, 12, 7 },
    { 25, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 12, 0, 12, 7 },
-    { 10, 5, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 3, 4, 4, 12, 8 },
-    { 10, 5, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 3, 4, 4, 12, 8 },
-    { 10, 5, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 3, 4, 4, 12, 2 },
+    { 10, 5, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 3, 4, 4, 12, 8 },
+    { 10, 5, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 3, 4, 4, 12, 8 },
+    { 10, 5, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 3, 4, 4, 12, 2 },
    { 26, 10, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 12, 8 },
    { 26, 13, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 12, 8 },
    { 25, 4, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 10, 8 },
@ -6146,7 +6146,7 @@ static const Properties uc_properties[] = {
    { 18, 13, 0, 3, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 8, 8, 12, 8 },
    { 25, 13, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 12, 6, 8 },
    { 0, 17, 230, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 4, 4, 21, 8 },
-    { 10, 5, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 4, 4, 12, 2 },
+    { 10, 5, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 4, 4, 12, 2 },
    { 29, 10, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 12, 8 },
    { 0, 17, 220, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 4, 4, 21, 8 },
    { 17, 13, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 8, 8, 12, 8 },
@ -6749,7 +6749,7 @@ static const Properties uc_properties[] = {
    { 25, 10, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 12, 6, 33 },
    { 25, 10, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 12, 33 },
    { 0, 17, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 4, 4, 4, 21, 33 },
-    { 10, 18, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 3, 4, 4, 4, 33 },
+    { 10, 18, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 3, 4, 4, 4, 33 },
    { 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 14, 9, 11, 33 },
    { 3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 14, 9, 11, 33 },
    { 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 14, 9, 11, 33 },
@ -7058,7 +7058,7 @@ static const Properties uc_properties[] = {
    { 6, 9, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 80, 0, 0, 5, 17, 2 },
    { 6, 9, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 80, 0, 0, 5, 4, 2 },
    { 10, 18, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 0, 4, 20, 2 },
-    { 10, 18, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 4, 4, 21, 1 },
+    { 10, 18, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 4, 4, 21, 1 },
    { 10, 18, 0, 1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 4, 4, 4, 21, 1 },
    { 10, 0, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 4, 4, 21, 2 },
    { 10, 1, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 4, 4, 21, 2 },
@ -7108,10 +7108,10 @@ static const Properties uc_properties[] = {
    { 10, 18, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 3, 4, 4, 12, 2 },
    { 10, 18, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 3, 4, 4, 12, 2 },
    { 13, 18, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 12, 0 },
-    { 10, 19, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 3, 4, 4, 21, 2 },
-    { 10, 20, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 3, 4, 4, 21, 2 },
-    { 10, 21, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 3, 4, 4, 21, 2 },
-    { 10, 22, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 3, 4, 4, 21, 2 },
+    { 10, 19, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 3, 4, 4, 21, 2 },
+    { 10, 20, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 3, 4, 4, 21, 2 },
+    { 10, 21, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 3, 4, 4, 21, 2 },
+    { 10, 22, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 3, 4, 4, 21, 2 },
    { 10, 18, 0, 5, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 4, 4, 21, 2 },
    { 5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 80, 0, 0, 0, 12, 2 },
    { 17, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 80, 0, 8, 6, 12, 3 },
--- a/src/corelib/tools/qunicodetables_p.h
+++ b/src/corelib/tools/qunicodetables_p.h
@ -50,11 +50,11 @@
 // We mean it.
 //

-#include <QtCore/private/qglobal_p.h>
-
 #ifndef QUNICODETABLES_P_H
 #define QUNICODETABLES_P_H

+#include <QtCore/private/qglobal_p.h>
+
 #include <QtCore/qchar.h>

 QT_BEGIN_NAMESPACE
--- a/src/corelib/xml/qxmlstream.cpp
+++ b/src/corelib/xml/qxmlstream.cpp
@ -3706,7 +3706,6 @@ void QXmlStreamWriter::writeEntityReference(const QString &name)
 void QXmlStreamWriter::writeNamespace(const QString &namespaceUri, const QString &prefix)
 {
    Q_D(QXmlStreamWriter);
-    Q_ASSERT(!namespaceUri.isEmpty());
    Q_ASSERT(prefix != QLatin1String("xmlns"));
    if (prefix.isEmpty()) {
        d->findNamespace(namespaceUri, d->inStartElement);
--- a/src/gui/configure.json
+++ b/src/gui/configure.json
@ -722,6 +722,33 @@
            },
            "use": "egl"
        },
+        "egl-openwfd": {
+            "label": "OpenWFD EGL",
+            "type": "compile",
+            "test": {
+                "include": [ "wfd.h" ],
+                "main": [
+                    "wfdEnumerateDevices(nullptr, 0, nullptr);"
+                ]
+            },
+            "use": "egl"
+        },
+        "egl-rcar": {
+            "label": "RCAR EGL",
+            "type": "compile",
+            "test": {
+                "include": [ "EGL/egl.h" ],
+                "tail": [
+                    "extern \"C\" {",
+                    "extern unsigned long PVRGrfxServerInit(void);",
+                    "}"
+                ],
+                "main": [
+                    "PVRGrfxServerInit();"
+                ]
+            },
+            "use": "egl opengl_es2"
+        },
        "evdev": {
            "label": "evdev",
            "type": "compile",
@ -952,7 +979,7 @@
            "label": "IMF",
            "emitIf": "config.qnx",
            "condition": "libs.imf",
-            "output": [ "privateConfig" ]
+            "output": [ "privateFeature" ]
        },
        "integrityfb": {
            "label": "INTEGRITY framebuffer",
@ -1119,11 +1146,21 @@
            "condition": "features.eglfs && tests.egl-viv",
            "output": [ "privateFeature" ]
        },
+        "eglfs_rcar": {
+            "label": "EGLFS RCAR",
+            "condition": "config.integrity && features.eglfs && tests.egl-rcar",
+            "output": [ "privateFeature" ]
+        },
        "eglfs_viv_wl": {
            "label": "EGLFS i.Mx6 Wayland",
            "condition": "features.eglfs_viv && libs.wayland_server",
            "output": [ "privateFeature" ]
        },
+        "eglfs_openwfd": {
+            "label": "EGLFS OpenWFD",
+            "condition": "config.integrity && features.eglfs && tests.egl-openwfd",
+            "output": [ "privateFeature" ]
+        },
        "gif": {
            "label": "GIF",
            "condition": "features.imageformatplugin",
@ -1610,7 +1647,7 @@ QMAKE_LIBDIR_OPENGL[_ES2] and QMAKE_LIBS_OPENGL[_ES2] in the mkspec for your pla
                    "section": "EGLFS details",
                    "condition": "features.eglfs",
                    "entries": [
-                        "eglfs_viv", "eglfs_viv_wl", "eglfs_egldevice", "eglfs_gbm", "eglfs_mali", "eglfs_brcm", "egl_x11"
+                        "eglfs_openwfd", "eglfs_viv", "eglfs_viv_wl", "eglfs_rcar", "eglfs_egldevice", "eglfs_gbm", "eglfs_mali", "eglfs_brcm", "egl_x11"
                    ]
                },
                "linuxfb", "vnc", "mirclient",
--- a/src/gui/kernel/qguiapplication.cpp
+++ b/src/gui/kernel/qguiapplication.cpp
@ -1767,6 +1767,9 @@ void QGuiApplicationPrivate::processWindowSystemEvent(QWindowSystemInterfacePriv
    case QWindowSystemInterfacePrivate::WindowScreenChanged:
        QGuiApplicationPrivate::processWindowScreenChangedEvent(static_cast<QWindowSystemInterfacePrivate::WindowScreenChangedEvent *>(e));
        break;
+    case QWindowSystemInterfacePrivate::SafeAreaMarginsChanged:
+        QGuiApplicationPrivate::processSafeAreaMarginsChangedEvent(static_cast<QWindowSystemInterfacePrivate::SafeAreaMarginsChangedEvent *>(e));
+        break;
    case QWindowSystemInterfacePrivate::ApplicationStateChanged: {
        QWindowSystemInterfacePrivate::ApplicationStateChangedEvent * changeEvent = static_cast<QWindowSystemInterfacePrivate::ApplicationStateChangedEvent *>(e);
        QGuiApplicationPrivate::setApplicationState(changeEvent->newState, changeEvent->forcePropagate); }
@ -2220,6 +2223,17 @@ void QGuiApplicationPrivate::processWindowScreenChangedEvent(QWindowSystemInterf
    }
 }

+void QGuiApplicationPrivate::processSafeAreaMarginsChangedEvent(QWindowSystemInterfacePrivate::SafeAreaMarginsChangedEvent *wse)
+{
+    if (wse->window.isNull())
+        return;
+
+    // Handle by forwarding directly to QWindowPrivate, instead of sending spontaneous
+    // QEvent like most other functions, as there's no QEvent type for the safe area
+    // change, and we don't want to add one until we know that this is a good API.
+    qt_window_private(wse->window)->processSafeAreaMarginsChanged();
+}
+
 void QGuiApplicationPrivate::processThemeChanged(QWindowSystemInterfacePrivate::ThemeChangeEvent *tce)
 {
    if (self)
@ -2887,7 +2901,7 @@ QPlatformDragQtResponse QGuiApplicationPrivate::processDrag(QWindow *w, const QM
    static QPointer<QWindow> currentDragWindow;
    static Qt::DropAction lastAcceptedDropAction = Qt::IgnoreAction;
    QPlatformDrag *platformDrag = platformIntegration()->drag();
-    if (!platformDrag) {
+    if (!platformDrag || (w && w->d_func()->blockedByModalWindow)) {
        lastAcceptedDropAction = Qt::IgnoreAction;
        return QPlatformDragQtResponse(false, lastAcceptedDropAction, QRect());
    }
--- a/src/gui/kernel/qguiapplication_p.h
+++ b/src/gui/kernel/qguiapplication_p.h
@ -133,6 +133,8 @@ public:
    static void processWindowStateChangedEvent(QWindowSystemInterfacePrivate::WindowStateChangedEvent *e);
    static void processWindowScreenChangedEvent(QWindowSystemInterfacePrivate::WindowScreenChangedEvent *e);

+    static void processSafeAreaMarginsChangedEvent(QWindowSystemInterfacePrivate::SafeAreaMarginsChangedEvent *e);
+
    static void processWindowSystemEvent(QWindowSystemInterfacePrivate::WindowSystemEvent *e);

    static void updateFilteredScreenOrientation(QScreen *screen);
--- a/src/gui/kernel/qinputdevicemanager.cpp
+++ b/src/gui/kernel/qinputdevicemanager.cpp
@ -92,4 +92,48 @@ void QInputDeviceManager::setCursorPos(const QPoint &pos)
    emit cursorPositionChangeRequested(pos);
 }

+/*!
+    \return the keyboard modifier state stored in the QInputDeviceManager object.
+
+    Keyboard input handlers are expected to keep this up-to-date via
+    setKeyboardModifiers().
+
+    Querying the state via this function (e.g. from a mouse handler that needs
+    to include the modifier state in mouse events) is the preferred alternative
+    over QGuiApplication::keyboardModifiers() since the latter may not report
+    the current state due to asynchronous QPA event processing.
+ */
+Qt::KeyboardModifiers QInputDeviceManager::keyboardModifiers() const
+{
+    Q_D(const QInputDeviceManager);
+    return d->keyboardModifiers;
+}
+
+void QInputDeviceManager::setKeyboardModifiers(Qt::KeyboardModifiers modsBeforeEvent, int key)
+{
+    Q_D(QInputDeviceManager);
+    Qt::KeyboardModifiers mods;
+    switch (key) {
+    case Qt::Key_Shift:
+        mods = Qt::KeyboardModifiers(modsBeforeEvent ^ Qt::ShiftModifier);
+        break;
+    case Qt::Key_Control:
+        mods = Qt::KeyboardModifiers(modsBeforeEvent ^ Qt::ControlModifier);
+        break;
+    case Qt::Key_Alt:
+        mods = Qt::KeyboardModifiers(modsBeforeEvent ^ Qt::AltModifier);
+        break;
+    case Qt::Key_Meta:
+        mods = Qt::KeyboardModifiers(modsBeforeEvent ^ Qt::MetaModifier);
+        break;
+    case Qt::Key_AltGr:
+        mods = Qt::KeyboardModifiers(modsBeforeEvent ^ Qt::GroupSwitchModifier);
+        break;
+    default:
+        mods = modsBeforeEvent;
+        break;
+    }
+    d->keyboardModifiers = mods;
+}
+
 QT_END_NAMESPACE
--- a/src/gui/kernel/qinputdevicemanager_p.h
+++ b/src/gui/kernel/qinputdevicemanager_p.h
@ -78,6 +78,9 @@ public:

    void setCursorPos(const QPoint &pos);

+    Qt::KeyboardModifiers keyboardModifiers() const;
+    void setKeyboardModifiers(Qt::KeyboardModifiers modsBeforeEvent, int key);
+
 signals:
    void deviceListChanged(QInputDeviceManager::DeviceType type);
    void cursorPositionChangeRequested(const QPoint &pos);
--- a/src/gui/kernel/qinputdevicemanager_p_p.h
+++ b/src/gui/kernel/qinputdevicemanager_p_p.h
@ -69,6 +69,8 @@ public:
    void setDeviceCount(QInputDeviceManager::DeviceType type, int count);

    QMap<QInputDeviceManager::DeviceType, int> m_deviceCount;
+
+    Qt::KeyboardModifiers keyboardModifiers;
 };

 QT_END_NAMESPACE
--- a/src/gui/kernel/qopenglcontext.cpp
+++ b/src/gui/kernel/qopenglcontext.cpp
@ -937,7 +937,9 @@ GLuint QOpenGLContext::defaultFramebufferObject() const

 /*!
    Makes the context current in the current thread, against the given
-    \a surface. Returns \c true if successful.
+    \a surface. Returns \c true if successful; otherwise returns \c false.
+    The latter may happen if the surface is not exposed, or the graphics
+    hardware is not available due to e.g. the application being suspended.

    If \a surface is 0 this is equivalent to calling doneCurrent().

--- a/src/gui/kernel/qplatformwindow.cpp
+++ b/src/gui/kernel/qplatformwindow.cpp
@ -165,6 +165,16 @@ QMargins QPlatformWindow::frameMargins() const
    return QMargins();
 }

+/*!
+    The safe area margins of a window represent the area that is safe to
+    place content within, without intersecting areas of the screen where
+    system UI is placed, or where a screen bezel may cover the content.
+*/
+QMargins QPlatformWindow::safeAreaMargins() const
+{
+    return QMargins();
+}
+
 /*!
    Reimplemented in subclasses to show the surface
    if \a visible is \c true, and hide it if \a visible is \c false.
--- a/src/gui/kernel/qplatformwindow.h
+++ b/src/gui/kernel/qplatformwindow.h
@ -88,6 +88,7 @@ public:
    virtual QRect normalGeometry() const;

    virtual QMargins frameMargins() const;
+    virtual QMargins safeAreaMargins() const;

    virtual void setVisible(bool visible);
    virtual void setWindowFlags(Qt::WindowFlags flags);
--- a/src/gui/kernel/qwindow_p.h
+++ b/src/gui/kernel/qwindow_p.h
@ -155,6 +155,8 @@ public:
    virtual void clearFocusObject();
    virtual QRectF closestAcceptableGeometry(const QRectF &rect) const;

+    virtual void processSafeAreaMarginsChanged() {};
+
    bool isPopup() const { return (windowFlags & Qt::WindowType_Mask) == Qt::Popup; }

    static QWindowPrivate *get(QWindow *window) { return window->d_func(); }
--- a/src/gui/kernel/qwindowsysteminterface.cpp
+++ b/src/gui/kernel/qwindowsysteminterface.cpp
@ -265,6 +265,13 @@ void QWindowSystemInterface::handleWindowScreenChanged(QWindow *window, QScreen
    QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
 }

+QT_DEFINE_QPA_EVENT_HANDLER(void, handleSafeAreaMarginsChanged, QWindow *window)
+{
+    QWindowSystemInterfacePrivate::SafeAreaMarginsChangedEvent *e =
+        new QWindowSystemInterfacePrivate::SafeAreaMarginsChangedEvent(window);
+    QWindowSystemInterfacePrivate::handleWindowSystemEvent<Delivery>(e);
+}
+
 QT_DEFINE_QPA_EVENT_HANDLER(void, handleApplicationStateChanged, Qt::ApplicationState newState, bool forcePropagate)
 {
    Q_ASSERT(QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ApplicationState));
--- a/src/gui/kernel/qwindowsysteminterface.h
+++ b/src/gui/kernel/qwindowsysteminterface.h
@ -180,6 +180,9 @@ public:
    static void handleWindowStateChanged(QWindow *window, Qt::WindowStates newState, int oldState = -1);
    static void handleWindowScreenChanged(QWindow *window, QScreen *newScreen);

+    template<typename Delivery = QWindowSystemInterface::DefaultDelivery>
+    static void handleSafeAreaMarginsChanged(QWindow *window);
+
    template<typename Delivery = QWindowSystemInterface::DefaultDelivery>
    static void handleApplicationStateChanged(Qt::ApplicationState newState, bool forcePropagate = false);

--- a/src/gui/kernel/qwindowsysteminterface_p.h
+++ b/src/gui/kernel/qwindowsysteminterface_p.h
@ -98,7 +98,8 @@ public:
 #endif
        ApplicationStateChanged = 0x19,
        FlushEvents = 0x20,
-        WindowScreenChanged = 0x21
+        WindowScreenChanged = 0x21,
+        SafeAreaMarginsChanged = 0x22
    };

    class WindowSystemEvent {
@ -185,6 +186,15 @@ public:
        QPointer<QScreen> screen;
    };

+    class SafeAreaMarginsChangedEvent : public WindowSystemEvent {
+    public:
+        SafeAreaMarginsChangedEvent(QWindow *w)
+            : WindowSystemEvent(SafeAreaMarginsChanged), window(w)
+        { }
+
+        QPointer<QWindow> window;
+    };
+
    class ApplicationStateChangedEvent : public WindowSystemEvent {
    public:
        ApplicationStateChangedEvent(Qt::ApplicationState newState, bool forcePropagate = false)
--- a/src/gui/painting/qcolor.cpp
+++ b/src/gui/painting/qcolor.cpp
@ -853,7 +853,7 @@ QString QColor::name(NameFormat format) const
        return QLatin1Char('#') + QString::number(rgba() | 0x1000000, 16).rightRef(6);
    case HexArgb:
        // it's called rgba() but it does return AARRGGBB
-        return QLatin1Char('#') + QString::number(rgba() | 0x100000000, 16).rightRef(8);
+        return QLatin1Char('#') + QString::number(rgba() | Q_INT64_C(0x100000000), 16).rightRef(8);
    }
    return QString();
 }
--- a/src/gui/painting/qcoregraphics_p.h
+++ b/src/gui/painting/qcoregraphics_p.h
@ -56,13 +56,15 @@
 #include <QtGui/qpalette.h>

 #include <CoreGraphics/CoreGraphics.h>
-#ifdef Q_OS_MACOS
+
+#if defined(__OBJC__) && defined(Q_OS_MACOS)
 #include <AppKit/AppKit.h>
+#define HAVE_APPKIT
 #endif

 QT_BEGIN_NAMESPACE

-#ifdef Q_OS_MACOS
+#ifdef HAVE_APPKIT
 Q_GUI_EXPORT NSImage *qt_mac_create_nsimage(const QPixmap &pm);
 Q_GUI_EXPORT NSImage *qt_mac_create_nsimage(const QIcon &icon, int defaultSize = 0);
 Q_GUI_EXPORT QPixmap qt_mac_toQPixmap(const NSImage *image, const QSizeF &size);
@ -78,7 +80,7 @@ Q_GUI_EXPORT CGColorSpaceRef qt_mac_colorSpaceForDeviceType(const QPaintDevice *

 Q_GUI_EXPORT void qt_mac_clip_cg(CGContextRef hd, const QRegion &rgn, CGAffineTransform *orig_xform);

-#ifdef Q_OS_MACOS
+#ifdef HAVE_APPKIT
 Q_GUI_EXPORT QColor qt_mac_toQColor(const NSColor *color);
 Q_GUI_EXPORT QBrush qt_mac_toQBrush(const NSColor *color, QPalette::ColorGroup colorGroup = QPalette::Normal);
 #endif
@ -124,4 +126,6 @@ private:

 QT_END_NAMESPACE

+#undef HAVE_APPKIT
+
 #endif // QCOREGRAPHICS_P_H
--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
@ -1881,7 +1881,8 @@ void QNetworkAccessManagerPrivate::_q_networkSessionStateChanged(QNetworkSession
        emit q->networkSessionConnected();
    lastSessionState = state;

-    if (online && state == QNetworkSession::Disconnected) {
+    if (online && (state == QNetworkSession::Disconnected
+                   || state == QNetworkSession::NotAvailable)) {
        const auto cfgs = networkConfigurationManager.allConfigurations();
        for (const QNetworkConfiguration &cfg : cfgs) {
            if (cfg.state().testFlag(QNetworkConfiguration::Active)) {
@ -1923,9 +1924,9 @@ void QNetworkAccessManagerPrivate::_q_onlineStateChanged(bool isOnline)
        online = (networkConfiguration.state() & QNetworkConfiguration::Active);
    } else {
        if (online != isOnline) {
+            online = isOnline;
            _q_networkSessionClosed();
            createSession(q->configuration());
-            online = isOnline;
        }
    }
    if (online) {
--- a/src/network/bearer/qbearerengine.cpp
+++ b/src/network/bearer/qbearerengine.cpp
@ -93,7 +93,8 @@ bool QBearerEngine::configurationsInUse() const
        || hasUsedConfiguration(userChoiceConfigurations);
 }

+QT_END_NAMESPACE
+
 #include "moc_qbearerengine_p.cpp"

-QT_END_NAMESPACE
 #endif // QT_NO_BEARERMANAGEMENT
--- a/src/network/bearer/qnetworkconfigmanager.cpp
+++ b/src/network/bearer/qnetworkconfigmanager.cpp
@ -378,8 +378,8 @@ void QNetworkConfigurationManager::updateConfigurations()
        priv->performAsyncConfigurationUpdate();
 }

-#include "moc_qnetworkconfigmanager.cpp"
-
 QT_END_NAMESPACE

+#include "moc_qnetworkconfigmanager.cpp"
+
 #endif // QT_NO_BEARERMANAGEMENT
--- a/src/network/bearer/qnetworksession.cpp
+++ b/src/network/bearer/qnetworksession.cpp
@ -749,8 +749,8 @@ void QNetworkSession::disconnectNotify(const QMetaMethod &signal)
        d->setALREnabled(false);
 }

-#include "moc_qnetworksession.cpp"
-
 QT_END_NAMESPACE

+#include "moc_qnetworksession.cpp"
+
 #endif // QT_NO_BEARERMANAGEMENT
--- a/src/network/configure.json
+++ b/src/network/configure.json
@ -69,18 +69,10 @@
                {
                    "comment": "placeholder for OPENSSL_{PATH,LIBS{,_{DEBUG,RELEASE}}}",
                    "libs": "",
-                    "builds": {
-                        "debug": "",
-                        "release": ""
-                    },
                    "condition": "config.win32 && !features.shared"
                },
                {
                    "libs": "-lssleay32 -llibeay32",
-                    "builds": {
-                        "debug": "",
-                        "release": ""
-                    },
                    "condition": "config.win32 && features.shared"
                },
                { "libs": "-lssl -lcrypto", "condition": "!config.win32" }
--- a/src/network/kernel/qdnslookup_unix.cpp
+++ b/src/network/kernel/qdnslookup_unix.cpp
@ -42,6 +42,7 @@
 #if QT_CONFIG(library)
 #include <qlibrary.h>
 #endif
+#include <qvarlengtharray.h>
 #include <qscopedpointer.h>
 #include <qurl.h>
 #include <private/qnativesocketengine_p.h>
@ -58,6 +59,8 @@
 #  include <gnu/lib-names.h>
 #endif

+#include <cstring>
+
 QT_BEGIN_NAMESPACE

 #if QT_CONFIG(library)
@ -137,7 +140,7 @@ void QDnsLookupRunnable::query(const int requestType, const QByteArray &requestN

    // Initialize state.
    struct __res_state state;
-    memset(&state, 0, sizeof(state));
+    std::memset(&state, 0, sizeof(state));
    if (local_res_ninit(&state) < 0) {
        reply->error = QDnsLookup::ResolverError;
        reply->errorString = tr("Resolver initialization failed");
@ -189,11 +192,25 @@ void QDnsLookupRunnable::query(const int requestType, const QByteArray &requestN
    QScopedPointer<struct __res_state, QDnsLookupStateDeleter> state_ptr(&state);

    // Perform DNS query.
-    unsigned char response[PACKETSZ];
-    memset(response, 0, sizeof(response));
-    const int responseLength = local_res_nquery(&state, requestName, C_IN, requestType, response, sizeof(response));
+    QVarLengthArray<unsigned char, PACKETSZ> buffer(PACKETSZ);
+    std::memset(buffer.data(), 0, buffer.size());
+    int responseLength = local_res_nquery(&state, requestName, C_IN, requestType, buffer.data(), buffer.size());
+    if (Q_UNLIKELY(responseLength > PACKETSZ)) {
+        buffer.resize(responseLength);
+        std::memset(buffer.data(), 0, buffer.size());
+        responseLength = local_res_nquery(&state, requestName, C_IN, requestType, buffer.data(), buffer.size());
+        if (Q_UNLIKELY(responseLength > buffer.size())) {
+            // Ok, we give up.
+            reply->error = QDnsLookup::ResolverError;
+            reply->errorString.clear(); // We cannot be more specific, alas.
+            return;
+        }
+    }

-    // Check the response header.
+    unsigned char *response = buffer.data();
+    // Check the response header. Though res_nquery returns -1 as a
+    // responseLength in case of error, we still can extract the
+    // exact error code from the response.
    HEADER *header = (HEADER*)response;
    const int answerCount = ntohs(header->ancount);
    switch (header->rcode) {
--- a/src/network/ssl/qsslkey_qt.cpp
+++ b/src/network/ssl/qsslkey_qt.cpp
@ -94,7 +94,7 @@ static OidLengthMap createOidMap()
    oids.insert(oids.cend(), QByteArrayLiteral("1.3.132.0.8"), 160); // secp160r1
    oids.insert(oids.cend(), QByteArrayLiteral("1.3.132.0.9"), 160); // secp160k1
    oids.insert(oids.cend(), QByteArrayLiteral("1.3.36.3.3.2.8.1.1.11"), 384); // brainpoolP384r1
-    oids.insert(oids.cend(), QByteArrayLiteral("1.3.36.3.3.2.8.1.1.13"), 521); // brainpoolP512r1
+    oids.insert(oids.cend(), QByteArrayLiteral("1.3.36.3.3.2.8.1.1.13"), 512); // brainpoolP512r1
    oids.insert(oids.cend(), QByteArrayLiteral("1.3.36.3.3.2.8.1.1.7"), 256); // brainpoolP256r1
    return oids;
 }
--- a/src/network/ssl/qsslsocket_mac.cpp
+++ b/src/network/ssl/qsslsocket_mac.cpp
@ -47,6 +47,7 @@
 #include "qsslkey_p.h"

 #include <QtCore/qmessageauthenticationcode.h>
+#include <QtCore/qoperatingsystemversion.h>
 #include <QtCore/qcryptographichash.h>
 #include <QtCore/qdatastream.h>
 #include <QtCore/qsysinfo.h>
@ -1245,13 +1246,17 @@ bool QSslSocketBackendPrivate::verifyPeerTrust()
    // actual system CA certificate list (which most use-cases need) other than
    // by letting SecTrustEvaluate fall through to the system list; so, in this case
    // (even though the client code may have provided its own certs), we retain
-    // the default behavior.
+    // the default behavior. Note, with macOS SDK below 10.12 using 'trust my
+    // anchors only' may result in some valid chains rejected, apparently the
+    // ones containing intermediated certificates; so we use this functionality
+    // on more recent versions only.
+
+    bool anchorsFromConfigurationOnly = false;

 #ifdef Q_OS_MACOS
-    const bool anchorsFromConfigurationOnly = true;
-#else
-    const bool anchorsFromConfigurationOnly = false;
-#endif
+    if (QOperatingSystemVersion::current() >= QOperatingSystemVersion::MacOSSierra)
+        anchorsFromConfigurationOnly = true;
+#endif // Q_OS_MACOS

    SecTrustSetAnchorCertificatesOnly(trust, anchorsFromConfigurationOnly);

--- a/src/network/ssl/qsslsocket_winrt.cpp
+++ b/src/network/ssl/qsslsocket_winrt.cpp
@ -47,6 +47,7 @@
 #include <QtCore/QSysInfo>
 #include <QtCore/qfunctions_winrt.h>
 #include <private/qnativesocketengine_winrt_p.h>
+#include <private/qeventdispatcher_winrt_p.h>

 #include <windows.networking.h>
 #include <windows.networking.sockets.h>
@ -443,8 +444,11 @@ void QSslSocketBackendPrivate::continueHandshake()
        return;
    }

-    hr = op->put_Completed(Callback<IAsyncActionCompletedHandler>(
-                               this, &QSslSocketBackendPrivate::onSslUpgrade).Get());
+    hr = QEventDispatcherWinRT::runOnXamlThread([this, op]() {
+        HRESULT hr = op->put_Completed(Callback<IAsyncActionCompletedHandler>(
+            this, &QSslSocketBackendPrivate::onSslUpgrade).Get());
+        return hr;
+    });
    Q_ASSERT_SUCCEEDED(hr);
 }

--- a/src/platformsupport/eglconvenience/qeglpbuffer.cpp
+++ b/src/platformsupport/eglconvenience/qeglpbuffer.cpp
@ -62,7 +62,7 @@ QEGLPbuffer::QEGLPbuffer(EGLDisplay display, const QSurfaceFormat &format, QOffs
    , m_display(display)
    , m_pbuffer(EGL_NO_SURFACE)
 {
-    bool hasSurfaceless = !flags.testFlag(QEGLPlatformContext::NoSurfaceless)
+    m_hasSurfaceless = !flags.testFlag(QEGLPlatformContext::NoSurfaceless)
        && q_hasEglExtension(display, "EGL_KHR_surfaceless_context");

    // Disable surfaceless contexts on Mesa for now. As of 10.6.0 and Intel at least, some
@ -72,9 +72,9 @@ QEGLPbuffer::QEGLPbuffer(EGLDisplay display, const QSurfaceFormat &format, QOffs
    // read/draw surface in the Intel backend.
    const char *vendor = eglQueryString(display, EGL_VENDOR); // hard to check for GL_ strings here, so blacklist all Mesa
    if (vendor && strstr(vendor, "Mesa"))
-        hasSurfaceless = false;
+        m_hasSurfaceless = false;

-    if (hasSurfaceless)
+    if (m_hasSurfaceless)
        return;

    EGLConfig config = q_configFromGLFormat(m_display, m_format, false, EGL_PBUFFER_BIT);
@ -100,4 +100,9 @@ QEGLPbuffer::~QEGLPbuffer()
        eglDestroySurface(m_display, m_pbuffer);
 }

+bool QEGLPbuffer::isValid() const
+{
+    return m_pbuffer != EGL_NO_SURFACE || m_hasSurfaceless;
+}
+
 QT_END_NAMESPACE
--- a/src/platformsupport/eglconvenience/qeglpbuffer_p.h
+++ b/src/platformsupport/eglconvenience/qeglpbuffer_p.h
@ -64,7 +64,7 @@ public:
    ~QEGLPbuffer();

    QSurfaceFormat format() const Q_DECL_OVERRIDE { return m_format; }
-    bool isValid() const Q_DECL_OVERRIDE { return m_pbuffer != EGL_NO_SURFACE; }
+    bool isValid() const Q_DECL_OVERRIDE;

    EGLSurface pbuffer() const { return m_pbuffer; }

@ -72,6 +72,7 @@ private:
    QSurfaceFormat m_format;
    EGLDisplay m_display;
    EGLSurface m_pbuffer;
+    bool m_hasSurfaceless;
 };

 QT_END_NAMESPACE
--- a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm
+++ b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm
@ -416,7 +416,19 @@ extern CGAffineTransform qt_transform_from_fontdef(const QFontDef &fontDef);
 template <>
 QFontEngine *QCoreTextFontDatabaseEngineFactory<QCoreTextFontEngine>::fontEngine(const QFontDef &fontDef, void *usrPtr)
 {
-    CTFontDescriptorRef descriptor = static_cast<CTFontDescriptorRef>(usrPtr);
+    QCFType<CTFontDescriptorRef> descriptor = QCFType<CTFontDescriptorRef>::constructFromGet(
+        static_cast<CTFontDescriptorRef>(usrPtr));
+
+    // CoreText will sometimes invalidate information in font descriptors that refer
+    // to system fonts in certain function calls or application states. While the descriptor
+    // looks the same from the outside, some internal plumbing is different, causing the results
+    // of creating CTFonts from those descriptors unreliable. The work-around for this
+    // is to copy the attributes of those descriptors each time we make a new CTFont
+    // from them instead of referring to the original, as that may trigger the CoreText bug.
+    if (m_systemFontDescriptors.contains(descriptor)) {
+        QCFType<CFDictionaryRef> attributes = CTFontDescriptorCopyAttributes(descriptor);
+        descriptor = CTFontDescriptorCreateWithAttributes(attributes);
+    }

    // Since we do not pass in the destination DPI to CoreText when making
    // the font, we need to pass in a point size which is scaled to include
@ -427,14 +439,10 @@ QFontEngine *QCoreTextFontDatabaseEngineFactory<QCoreTextFontEngine>::fontEngine
    qreal scaledPointSize = fontDef.pixelSize;

    CGAffineTransform matrix = qt_transform_from_fontdef(fontDef);
-    CTFontRef font = CTFontCreateWithFontDescriptor(descriptor, scaledPointSize, &matrix);
-    if (font) {
-        QFontEngine *engine = new QCoreTextFontEngine(font, fontDef);
-        CFRelease(font);
-        return engine;
-    }
+    if (QCFType<CTFontRef> font = CTFontCreateWithFontDescriptor(descriptor, scaledPointSize, &matrix))
+        return new QCoreTextFontEngine(font, fontDef);

-    return NULL;
+    return nullptr;
 }

 #ifndef QT_NO_FREETYPE
--- a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase_p.h
+++ b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase_p.h
@ -87,12 +87,14 @@ public:
    QFont *themeFont(QPlatformTheme::Font) const;
    const QHash<QPlatformTheme::Font, QFont *> &themeFonts() const;

+protected:
+    mutable QSet<CTFontDescriptorRef> m_systemFontDescriptors;
+
 private:
    void populateFromDescriptor(CTFontDescriptorRef font, const QString &familyName = QString());

    mutable QString defaultFontName;

-    mutable QSet<CTFontDescriptorRef> m_systemFontDescriptors;
    mutable QHash<QPlatformTheme::Font, QFont *> m_themeFonts;
    bool m_hasPopulatedAliases;
 };
--- a/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler.cpp
+++ b/src/platformsupport/input/evdevkeyboard/qevdevkeyboardhandler.cpp
@ -49,6 +49,9 @@
 #include <qpa/qwindowsysteminterface.h>
 #include <private/qcore_unix_p.h>

+#include <QtGui/private/qguiapplication_p.h>
+#include <QtGui/private/qinputdevicemanager_p.h>
+
 #ifdef Q_OS_FREEBSD
 #include <dev/evdev/input.h>
 #else
@ -222,6 +225,8 @@ void QEvdevKeyboardHandler::readKeycode()
 void QEvdevKeyboardHandler::processKeyEvent(int nativecode, int unicode, int qtcode,
                                            Qt::KeyboardModifiers modifiers, bool isPress, bool autoRepeat)
 {
+    QGuiApplicationPrivate::inputDeviceManager()->setKeyboardModifiers(modifiers, qtcode);
+
    QWindowSystemInterface::handleExtendedKeyEvent(0, (isPress ? QEvent::KeyPress : QEvent::KeyRelease),
                                                   qtcode, modifiers, nativecode + 8, 0, int(modifiers),
                                                   (unicode != 0xffff ) ? QString(unicode) : QString(), autoRepeat);
@ -403,6 +408,8 @@ QEvdevKeyboardHandler::KeycodeAction QEvdevKeyboardHandler::processKeycode(quint
            Qt::KeyboardModifiers qtmods = Qt::KeyboardModifiers(qtcode & modmask);
            qtcode &= ~modmask;

+            // qtmods here is the modifier state before the event, i.e. not
+            // including the current key in case it is a modifier.
            qCDebug(qLcEvdevKeyMap, "Processing: uni=%04x, qt=%08x, qtmod=%08x", unicode, qtcode, int(qtmods));

            // If NumLockOff and keypad key pressed remap event sent
--- a/src/platformsupport/input/libinput/qlibinputkeyboard.cpp
+++ b/src/platformsupport/input/libinput/qlibinputkeyboard.cpp
@ -40,6 +40,8 @@
 #include "qlibinputkeyboard_p.h"
 #include <QtCore/QTextCodec>
 #include <QtCore/QLoggingCategory>
+#include <QtGui/private/qguiapplication_p.h>
+#include <QtGui/private/qinputdevicemanager_p.h>
 #include <qpa/qwindowsysteminterface.h>
 #include <libinput.h>
 #ifndef QT_NO_XKBCOMMON_EVDEV
@ -196,6 +198,8 @@ void QLibInputKeyboard::processKey(libinput_event_keyboard *e)

    const xkb_keysym_t sym = xkb_state_key_get_one_sym(m_state, k);

+    // mods here is the modifier state before the event, i.e. not
+    // including the current key in case it is a modifier.
    Qt::KeyboardModifiers mods = Qt::NoModifier;
    const int qtkey = keysymToQtKey(sym, &mods, text);

@ -211,6 +215,8 @@ void QLibInputKeyboard::processKey(libinput_event_keyboard *e)

    xkb_state_update_key(m_state, k, pressed ? XKB_KEY_DOWN : XKB_KEY_UP);

+    QGuiApplicationPrivate::inputDeviceManager()->setKeyboardModifiers(mods, qtkey);
+
    QWindowSystemInterface::handleExtendedKeyEvent(Q_NULLPTR,
                                                   pressed ? QEvent::KeyPress : QEvent::KeyRelease,
                                                   qtkey, mods, k, sym, mods, text);
--- a/src/platformsupport/input/libinput/qlibinputpointer.cpp
+++ b/src/platformsupport/input/libinput/qlibinputpointer.cpp
@ -41,6 +41,8 @@
 #include <libinput.h>
 #include <QtGui/QGuiApplication>
 #include <QtGui/QScreen>
+#include <QtGui/private/qguiapplication_p.h>
+#include <QtGui/private/qinputdevicemanager_p.h>
 #include <qpa/qwindowsysteminterface.h>
 #include <private/qhighdpiscaling_p.h>

@ -78,7 +80,8 @@ void QLibInputPointer::processButton(libinput_event_pointer *e)

    m_buttons.setFlag(button, pressed);

-    QWindowSystemInterface::handleMouseEvent(Q_NULLPTR, m_pos, m_pos, m_buttons, QGuiApplication::keyboardModifiers());
+    QWindowSystemInterface::handleMouseEvent(Q_NULLPTR, m_pos, m_pos, m_buttons,
+                                             QGuiApplicationPrivate::inputDeviceManager()->keyboardModifiers());
 }

 void QLibInputPointer::processMotion(libinput_event_pointer *e)
@ -91,7 +94,8 @@ void QLibInputPointer::processMotion(libinput_event_pointer *e)
    m_pos.setX(qBound(g.left(), qRound(m_pos.x() + dx), g.right()));
    m_pos.setY(qBound(g.top(), qRound(m_pos.y() + dy), g.bottom()));

-    QWindowSystemInterface::handleMouseEvent(Q_NULLPTR, m_pos, m_pos, m_buttons, QGuiApplication::keyboardModifiers());
+    QWindowSystemInterface::handleMouseEvent(Q_NULLPTR, m_pos, m_pos, m_buttons,
+                                             QGuiApplicationPrivate::inputDeviceManager()->keyboardModifiers());
 }

 void QLibInputPointer::processAxis(libinput_event_pointer *e)
--- a/src/plugins/bearer/bearer.pro
+++ b/src/plugins/bearer/bearer.pro
@ -6,11 +6,6 @@ QT_FOR_CONFIG += network-private
    SUBDIRS += connman networkmanager
 }

-#win32:SUBDIRS += nla
-win32:SUBDIRS += generic
-win32:!winrt: SUBDIRS += nativewifi
-darwin:qtConfig(corewlan): SUBDIRS += corewlan
-mac:SUBDIRS += generic
 android:SUBDIRS += android

 isEmpty(SUBDIRS):SUBDIRS = generic
--- a/src/plugins/platforms/android/androidjniaccessibility.cpp
+++ b/src/plugins/platforms/android/androidjniaccessibility.cpp
@ -106,7 +106,8 @@ namespace QtAndroidAccessibility
        QAccessibleInterface *iface = interfaceFromId(objectId);
        if (iface && iface->isValid()) {
            const int childCount = iface->childCount();
-            QVarLengthArray<jint, 8> ifaceIdArray(childCount);
+            QVarLengthArray<jint, 8> ifaceIdArray;
+            ifaceIdArray.reserve(childCount);
            for (int i = 0; i < childCount; ++i) {
                QAccessibleInterface *child = iface->child(i);
                if (child && child->isValid())
--- a/src/plugins/platforms/android/qandroidinputcontext.cpp
+++ b/src/plugins/platforms/android/qandroidinputcontext.cpp
@ -526,6 +526,10 @@ void QAndroidInputContext::updateCursorPosition()

 void QAndroidInputContext::updateSelectionHandles()
 {
+    static bool noHandles = qEnvironmentVariableIntValue("QT_QPA_NO_TEXT_HANDLES");
+    if (noHandles)
+        return;
+
    auto im = qGuiApp->inputMethod();
    if (!m_focusObject || (m_cursorHandleShown == CursorHandleNotShown)) {
        // Hide the handles
@ -843,11 +847,11 @@ jint QAndroidInputContext::getCursorCapsMode(jint /*reqModes*/)

    const uint qtInputMethodHints = query->value(Qt::ImHints).toUInt();

-    if (qtInputMethodHints & Qt::ImhPreferUppercase)
-        res = CAP_MODE_SENTENCES;
+    if (!(qtInputMethodHints & Qt::ImhLowercaseOnly) && !(qtInputMethodHints & Qt::ImhNoAutoUppercase))
+        res |= CAP_MODE_SENTENCES;

    if (qtInputMethodHints & Qt::ImhUppercaseOnly)
-        res = CAP_MODE_CHARACTERS;
+        res |= CAP_MODE_CHARACTERS;

    return res;
 }
--- a/src/plugins/platforms/cocoa/qcocoamenuloader.mm
+++ b/src/plugins/platforms/cocoa/qcocoamenuloader.mm
@ -43,6 +43,7 @@
 #include "qcocoahelpers.h"
 #include "qcocoamenubar.h"
 #include "qcocoamenuitem.h"
+#include "qcocoaintegration.h"

 #include <QtCore/private/qcore_mac_p.h>
 #include <QtCore/private/qthread_p.h>
@ -343,10 +344,13 @@

 - (BOOL)validateMenuItem:(NSMenuItem*)menuItem
 {
-    if ([menuItem action] == @selector(hide:)
-        || [menuItem action] == @selector(hideOtherApplications:)
+    if ([menuItem action] == @selector(hideOtherApplications:)
        || [menuItem action] == @selector(unhideAllApplications:)) {
        return [NSApp validateMenuItem:menuItem];
+    } else if ([menuItem action] == @selector(hide:)) {
+        if (QCocoaIntegration::instance()->activePopupWindow())
+            return NO;
+        return [NSApp validateMenuItem:menuItem];
    } else if ([menuItem tag]) {
        QCocoaMenuItem *cocoaItem = reinterpret_cast<QCocoaMenuItem *>([menuItem tag]);
        return cocoaItem->isEnabled();
--- a/src/plugins/platforms/eglfs/api/qeglfscontext_p.h
+++ b/src/plugins/platforms/eglfs/api/qeglfscontext_p.h
@ -52,6 +52,7 @@
 //

 #include "qeglfsglobal_p.h"
+#include "qeglfscursor_p.h"
 #include <QtEglSupport/private/qeglplatformcontext_p.h>
 #include <QtCore/QVariant>

@ -68,6 +69,8 @@ public:
    void runGLChecks() override;
    void swapBuffers(QPlatformSurface *surface) override;

+    QEglFSCursorData cursorData;
+
 private:
    EGLNativeWindowType m_tempWindow;
 };
--- a/src/plugins/platforms/eglfs/api/qeglfscursor.cpp
+++ b/src/plugins/platforms/eglfs/api/qeglfscursor.cpp
@ -40,10 +40,10 @@
 #include "qeglfscursor_p.h"
 #include "qeglfsintegration_p.h"
 #include "qeglfsscreen_p.h"
+#include "qeglfscontext_p.h"

 #include <qpa/qwindowsysteminterface.h>
 #include <QtGui/QOpenGLContext>
-#include <QtGui/QOpenGLShaderProgram>
 #include <QtCore/QFile>
 #include <QtCore/QJsonDocument>
 #include <QtCore/QJsonArray>
@ -115,13 +115,6 @@ void QEglFSCursorDeviceListener::onDeviceListChanged(QInputDeviceManager::Device

 void QEglFSCursor::resetResources()
 {
-    if (QOpenGLContext *ctx = QOpenGLContext::currentContext()) {
-        GraphicsContextData &gfx(m_gfx[ctx]);
-        delete gfx.program;
-        glDeleteTextures(1, &gfx.customCursorTexture);
-        glDeleteTextures(1, &gfx.atlasTexture);
-        gfx = GraphicsContextData();
-    }
    m_cursor.customCursorPending = !m_cursor.customCursorImage.isNull();
 }

@ -144,8 +137,8 @@ void QEglFSCursor::createShaderPrograms()
        "   gl_FragColor = texture2D(texture, textureCoord).bgra;\n"
        "}\n";

-    GraphicsContextData &gfx(m_gfx[QOpenGLContext::currentContext()]);
-    gfx.program = new QOpenGLShaderProgram;
+    QEglFSCursorData &gfx = static_cast<QEglFSContext*>(QOpenGLContext::currentContext()->handle())->cursorData;
+    gfx.program.reset(new QOpenGLShaderProgram);
    gfx.program->addCacheableShaderFromSourceCode(QOpenGLShader::Vertex, textureVertexProgram);
    gfx.program->addCacheableShaderFromSourceCode(QOpenGLShader::Fragment, textureFragmentProgram);
    gfx.program->bindAttributeLocation("vertexCoordEntry", 0);
@ -475,7 +468,7 @@ void QEglFSCursor::draw(const QRectF &r)
 {
    StateSaver stateSaver;

-    GraphicsContextData &gfx(m_gfx[QOpenGLContext::currentContext()]);
+    QEglFSCursorData &gfx = static_cast<QEglFSContext*>(QOpenGLContext::currentContext()->handle())->cursorData;
    if (!gfx.program) {
        // one time initialization
        initializeOpenGLFunctions();
--- a/src/plugins/platforms/eglfs/api/qeglfscursor_p.h
+++ b/src/plugins/platforms/eglfs/api/qeglfscursor_p.h
@ -56,6 +56,7 @@
 #include <qpa/qplatformscreen.h>
 #include <QtGui/QMatrix4x4>
 #include <QtGui/QOpenGLFunctions>
+#include <QtGui/QOpenGLShaderProgram>
 #include <QtGui/private/qinputdevicemanager_p.h>

 QT_BEGIN_NAMESPACE
@ -81,6 +82,15 @@ private:

 #if QT_CONFIG(opengl)

+struct QEglFSCursorData {
+    QScopedPointer<QOpenGLShaderProgram> program;
+    int textureEntry = 0;
+    int matEntry = 0;
+    uint customCursorTexture = 0;
+    uint atlasTexture = 0;
+    qint64 customCursorKey = 0;
+};
+
 class Q_EGLFS_EXPORT QEglFSCursor : public QPlatformCursor
                                  , protected QOpenGLFunctions
 {
@ -143,18 +153,6 @@ private:
    QEglFSCursorDeviceListener *m_deviceListener;
    bool m_updateRequested;
    QMatrix4x4 m_rotationMatrix;
-
-    struct GraphicsContextData {
-        GraphicsContextData() : program(nullptr), textureEntry(0), matEntry(0),
-            customCursorTexture(0), atlasTexture(0), customCursorKey(0) { }
-        QOpenGLShaderProgram *program;
-        int textureEntry;
-        int matEntry;
-        uint customCursorTexture;
-        uint atlasTexture;
-        qint64 customCursorKey;
-    };
-    QHash<QOpenGLContext *, GraphicsContextData> m_gfx;
 };
 #endif // QT_CONFIG(opengl)

--- a/src/plugins/platforms/eglfs/deviceintegration/deviceintegration.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/deviceintegration.pro
@ -7,8 +7,9 @@ qtConfig(eglfs_egldevice): SUBDIRS *= eglfs_kms_support eglfs_kms_egldevice
 qtConfig(eglfs_brcm): SUBDIRS += eglfs_brcm
 qtConfig(eglfs_mali): SUBDIRS += eglfs_mali
 qtConfig(eglfs_viv): SUBDIRS += eglfs_viv
+qtConfig(eglfs_rcar): SUBDIRS += eglfs_rcar
 qtConfig(eglfs_viv_wl): SUBDIRS += eglfs_viv_wl
-
+qtConfig(eglfs_openwfd): SUBDIRS += eglfs_openwfd
 qtConfig(opengl): SUBDIRS += eglfs_emu

 eglfs_kms_egldevice.depends = eglfs_kms_support
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/eglfs_openwfd.json
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/eglfs_openwfd.json
@ -0,0 +1,3 @@
+{
+    "Keys": [ "eglfs_openwfd" ]
+}
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/eglfs_openwfd.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/eglfs_openwfd.pro
@ -0,0 +1,17 @@
+TARGET = qeglfs-openwfd-integration
+
+QT += core-private gui-private eglfsdeviceintegration-private
+
+INCLUDEPATH += $$PWD/../../api
+CONFIG += egl
+
+SOURCES += $$PWD/qeglfsopenwfdmain.cpp \
+           $$PWD/qeglfsopenwfdintegration.cpp
+
+HEADERS += $$PWD/qeglfsopenwfdintegration.h
+
+OTHER_FILES += $$PWD/eglfs_openwfd.json
+
+PLUGIN_TYPE = egldeviceintegrations
+PLUGIN_CLASS_NAME = QEglFSOpenWFDIntegrationPlugin
+load(qt_plugin)
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/qeglfsopenwfdintegration.cpp
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/qeglfsopenwfdintegration.cpp
@ -0,0 +1,223 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins 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$
+**
+****************************************************************************/
+
+#include "qeglfsopenwfdintegration.h"
+
+#include "wfd.h"
+#include "wfdext2.h"
+
+QT_BEGIN_NAMESPACE
+
+#define MAX_NUM_OF_WFD_BUFFERS 3
+#define MAX_NUM_OF_WFD_DEVICES 4
+#define MAX_NUM_OF_WFD_PIPELINES 4
+#define MAX_NUM_OF_WFD_PORT_MODES 64
+#define MAX_NUM_OF_WFD_PORTS 4
+
+typedef struct wfd_buffer {
+    WFD_EGLImageType*   image;
+    WFDSource           source;
+} wfd_buffer_t;
+
+typedef struct wfd_window {
+    WFDDevice       dev;
+    WFDPort         port;
+    WFDPipeline     pipeline;
+    int             numBuffers;
+    wfd_buffer_t    buffers[MAX_NUM_OF_WFD_BUFFERS];
+} wfd_window_t;
+
+void QEglFSOpenWFDIntegration::platformInit()
+{
+    QEglFSDeviceIntegration::platformInit();
+
+    mNativeDisplay = EGL_DEFAULT_DISPLAY;
+
+    // Get device list
+    WFDint numDevs = wfdEnumerateDevices(nullptr, 0, nullptr);
+    WFDint devIds[MAX_NUM_OF_WFD_DEVICES];
+
+    if (numDevs > 0)
+        wfdEnumerateDevices(devIds, numDevs, nullptr);
+
+    // Create device
+    mDevice = wfdCreateDevice(WFD_DEFAULT_DEVICE_ID, nullptr);
+
+    if (WFD_INVALID_HANDLE == mDevice)
+        qFatal( "Failed to create wfd device");
+
+    // Get port list
+    WFDint portIds[MAX_NUM_OF_WFD_PORTS];
+    WFDint numPorts = wfdEnumeratePorts(mDevice, nullptr, 0, nullptr);
+    wfdEnumeratePorts(mDevice, portIds, numPorts, nullptr);
+
+    // Create port
+    mPort = wfdCreatePort(mDevice, portIds[0], nullptr);
+
+    if (WFD_INVALID_HANDLE == mPort)
+        qFatal("Failed to create wfd port");
+
+    // Get port modes
+    WFDint numPortModes = wfdGetPortModes(mDevice, mPort, nullptr, 0);
+    WFDPortMode portModes[MAX_NUM_OF_WFD_PORT_MODES];
+    wfdGetPortModes(mDevice, mPort, portModes, numPortModes);
+
+    // Get width and height
+    mScreenSize.setWidth(wfdGetPortModeAttribi(mDevice, mPort, portModes[0], WFD_PORT_MODE_WIDTH));
+    mScreenSize.setHeight(wfdGetPortModeAttribi(mDevice, mPort, portModes[0], WFD_PORT_MODE_HEIGHT));
+
+    // Set port mode
+    wfdSetPortMode(mDevice, mPort, portModes[0]);
+    WFDErrorCode eError = wfdGetError(mDevice);
+    if (WFD_ERROR_NONE != eError)
+        qFatal("Failed to set wfd port mode");
+
+    // Power on
+    wfdSetPortAttribi(mDevice, mPort, WFD_PORT_POWER_MODE, WFD_POWER_MODE_ON);
+    eError = wfdGetError(mDevice);
+    if (WFD_ERROR_NONE != eError)
+        qFatal("Failed to power on wfd port");
+}
+
+QSize QEglFSOpenWFDIntegration::screenSize() const
+{
+    return mScreenSize;
+}
+
+EGLNativeDisplayType QEglFSOpenWFDIntegration::platformDisplay() const
+{
+    return mNativeDisplay;
+}
+
+EGLNativeWindowType QEglFSOpenWFDIntegration::createNativeWindow(QPlatformWindow *window,
+                                                                 const QSize &size,
+                                                                 const QSurfaceFormat &format)
+{
+    Q_UNUSED(window);
+    Q_UNUSED(format);
+
+    // Get list of pipelines
+    WFDint numPipelines = wfdEnumeratePipelines(mDevice, nullptr, 0, nullptr);
+
+    WFDint pipelineIds[MAX_NUM_OF_WFD_PIPELINES];
+    wfdEnumeratePipelines(mDevice, pipelineIds, numPipelines, nullptr);
+
+    WFDint testId = 0;
+    testId = pipelineIds[0];
+    WFDPipeline pipeline = wfdCreatePipeline(mDevice, testId, nullptr);
+    if (WFD_INVALID_HANDLE == pipeline)
+        qFatal("Failed to create wfd pipeline");
+
+    wfdSetPipelineAttribi(mDevice, pipeline, WFD_PIPELINE_TRANSPARENCY_ENABLE,
+                          (WFD_TRANSPARENCY_SOURCE_ALPHA|WFD_TRANSPARENCY_GLOBAL_ALPHA));
+
+    WFDErrorCode eError = wfdGetError(mDevice);
+    if (WFD_ERROR_NONE != eError)
+        qFatal("Failed to set WFD_PIPELINE_TRANSPARENCY_ENABLE");
+
+    wfdSetPipelineAttribi(mDevice, pipeline, WFD_PIPELINE_GLOBAL_ALPHA, 255);
+    eError = wfdGetError(mDevice);
+    if (WFD_ERROR_NONE != eError)
+        qFatal("Failed to set WFD_PIPELINE_GLOBAL_ALPHA");
+
+    wfdBindPipelineToPort(mDevice, mPort, pipeline);
+    eError = wfdGetError(mDevice);
+    if (WFD_ERROR_NONE != eError)
+        qFatal("Failed to bind port to pipeline");
+
+    // Create buffers
+    WFDSource source[MAX_NUM_OF_WFD_BUFFERS] = {WFD_INVALID_HANDLE, WFD_INVALID_HANDLE,
+                                                WFD_INVALID_HANDLE};
+    WFDEGLImage eglImageHandles[MAX_NUM_OF_WFD_BUFFERS];
+    WFD_EGLImageType* wfdEglImages[MAX_NUM_OF_WFD_BUFFERS];
+
+    for (int i = 0; i < MAX_NUM_OF_WFD_BUFFERS; i++) {
+        wfdCreateWFDEGLImages(mDevice, mScreenSize.width(), mScreenSize.height(),
+                              WFD_FORMAT_RGBA8888, WFD_USAGE_OPENGL_ES2 | WFD_USAGE_DISPLAY,
+                              1, &(eglImageHandles[i]), 0);
+
+        wfdEglImages[i] = (WFD_EGLImageType *)(eglImageHandles[i]);
+        if (WFD_INVALID_HANDLE == wfdEglImages[i])
+            qFatal("Failed to create WDFEGLImages");
+
+        source[i] = wfdCreateSourceFromImage(mDevice, pipeline, eglImageHandles[i], nullptr);
+        if (WFD_INVALID_HANDLE == source[i])
+            qFatal("Failed to create source from EGLImage");
+    }
+
+    // Commit port
+    wfdDeviceCommit(mDevice, WFD_COMMIT_ENTIRE_PORT, mPort);
+    eError = wfdGetError(mDevice);
+    if (WFD_ERROR_NONE != eError)
+            qFatal("Failed to commit port");
+
+    // Create native window
+    wfd_window_t* nativeWindow = (wfd_window_t*)malloc(sizeof(wfd_window_t));
+    if (nullptr == nativeWindow)
+            qFatal("Failed to allocate memory for native window");
+
+    nativeWindow->dev = mDevice;
+    nativeWindow->port = mPort;
+    nativeWindow->pipeline = pipeline;
+    nativeWindow->numBuffers = MAX_NUM_OF_WFD_BUFFERS;
+
+    for (int i = 0; i < MAX_NUM_OF_WFD_BUFFERS; i++) {
+        nativeWindow->buffers[i].image  = wfdEglImages[i];
+        nativeWindow->buffers[i].source = source[i];
+    }
+
+    return (EGLNativeWindowType)nativeWindow;
+}
+
+QSurfaceFormat QEglFSOpenWFDIntegration::surfaceFormatFor(const QSurfaceFormat &inputFormat) const
+{
+    QSurfaceFormat format;
+    format.setRedBufferSize(8);
+    format.setGreenBufferSize(8);
+    format.setBlueBufferSize(8);
+    format.setAlphaBufferSize(8);
+    return format;
+}
+
+void QEglFSOpenWFDIntegration::destroyNativeWindow(EGLNativeWindowType window)
+{
+    free((void*)window);
+}
+
+QT_END_NAMESPACE
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/qeglfsopenwfdintegration.h
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/qeglfsopenwfdintegration.h
@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins 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 QEGLFSOPENWFDINTEGRATION_H
+#define QEGLFSOPENWFDINTEGRATION_H
+
+#include "private/qeglfsdeviceintegration_p.h"
+#define WFD_WFDEXT_PROTOTYPES
+#include "wfd.h"
+#include "wfdext2.h"
+
+QT_BEGIN_NAMESPACE
+
+class QEglFSOpenWFDIntegration : public QEglFSDeviceIntegration
+{
+public:
+    void platformInit() override;
+    QSize screenSize() const override;
+    EGLNativeWindowType createNativeWindow(QPlatformWindow *window, const QSize &size, const QSurfaceFormat &format) override;
+    void destroyNativeWindow(EGLNativeWindowType window) override;
+    EGLNativeDisplayType platformDisplay() const override;
+    virtual QSurfaceFormat surfaceFormatFor(const QSurfaceFormat &inputFormat) const;
+
+private:
+    QSize mScreenSize;
+    EGLNativeDisplayType mNativeDisplay;
+    WFDDevice mDevice;
+    WFDPort mPort;
+};
+
+QT_END_NAMESPACE
+
+#endif
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/qeglfsopenwfdmain.cpp
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_openwfd/qeglfsopenwfdmain.cpp
@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins 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$
+**
+****************************************************************************/
+
+#include "private/qeglfsdeviceintegration_p.h"
+#include "qeglfsopenwfdintegration.h"
+
+QT_BEGIN_NAMESPACE
+
+class QEglFSOpenWFDIntegrationPlugin : public QEglFSDeviceIntegrationPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID QEglFSDeviceIntegrationFactoryInterface_iid FILE "eglfs_openwfd.json")
+
+public:
+    QEglFSDeviceIntegration *create() override {
+        return new QEglFSOpenWFDIntegration;
+    }
+};
+
+QT_END_NAMESPACE
+
+#include "qeglfsopenwfdmain.moc"
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/eglfs_rcar.json
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/eglfs_rcar.json
@ -0,0 +1,3 @@
+{
+    "Keys": [ "eglfs_rcar" ]
+}
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/eglfs_rcar.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/eglfs_rcar.pro
@ -0,0 +1,19 @@
+TARGET = qeglfs-rcar-integration
+
+QT += core-private gui-private eglfsdeviceintegration-private
+
+INCLUDEPATH += $$PWD/../../api
+CONFIG += egl
+DEFINES += LINUX=1 EGL_API_FB=1
+QMAKE_LFLAGS += $$QMAKE_LFLAGS_NOUNDEF
+
+SOURCES += $$PWD/qeglfsrcarmain.cpp \
+           $$PWD/qeglfsrcarintegration.cpp
+
+HEADERS += $$PWD/qeglfsrcarintegration.h
+
+OTHER_FILES += $$PWD/eglfs_rcar.json
+
+PLUGIN_TYPE = egldeviceintegrations
+PLUGIN_CLASS_NAME = QEglFSRcarIntegrationPlugin
+load(qt_plugin)
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/qeglfsrcarintegration.cpp
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/qeglfsrcarintegration.cpp
@ -0,0 +1,159 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins 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$
+**
+****************************************************************************/
+
+#include <QDebug>
+#include <QtEglSupport/private/qeglconvenience_p.h>
+#include <EGL/egl.h>
+#include "INTEGRITY.h"
+#include "qeglfsrcarintegration.h"
+
+#define RCAR_DEFAULT_DISPLAY 1
+#define RCAR_DEFAULT_WM_LAYER 2
+
+extern "C" unsigned long PVRGrfxServerInit(void);
+
+QT_BEGIN_NAMESPACE
+
+void QEglFSRcarIntegration::platformInit()
+{
+    QEglFSDeviceIntegration::platformInit();
+
+    PVRGrfxServerInit();
+
+    mScreenSize = q_screenSizeFromFb(0);
+    mNativeDisplay = (NativeDisplayType)EGL_DEFAULT_DISPLAY;
+}
+
+QSize QEglFSRcarIntegration::screenSize() const
+{
+    return mScreenSize;
+}
+
+EGLNativeDisplayType QEglFSRcarIntegration::platformDisplay() const
+{
+    return mNativeDisplay;
+}
+
+static r_wm_WinColorFmt_t getWMColorFormat(const QSurfaceFormat &format)
+{
+    const int a = format.alphaBufferSize();
+    const int r = format.redBufferSize();
+    const int g = format.greenBufferSize();
+    const int b = format.blueBufferSize();
+
+    switch (r) {
+    case 4:
+        if (g == 4 && b == 4 && a == 4)
+            return R_WM_COLORFMT_ARGB4444;
+        break;
+    case 5:
+        if (g == 6 && b == 5 && a == 0)
+            return R_WM_COLORFMT_RGB565;
+        else if (g == 5 && b == 5 && a == 1)
+            return R_WM_COLORFMT_ARGB1555;
+        break;
+    case 8:
+        if (g == 8 && b == 8 && a == 0)
+            return R_WM_COLORFMT_RGB0888;
+        else if (g == 8 && b == 8 && a == 8)
+            return R_WM_COLORFMT_ARGB8888;
+        break;
+    }
+
+    qFatal("Unsupported color format: R:%d G:%d B:%d A:%d", r, g, b, a);
+    return R_WM_COLORFMT_LAST;
+}
+
+EGLNativeWindowType QEglFSRcarIntegration::createNativeWindow(QPlatformWindow *window, const QSize &size, const QSurfaceFormat &format)
+{
+    bool ok;
+
+    mNativeDisplayID = qEnvironmentVariableIntValue("QT_QPA_WM_DISP_ID", &ok);
+    if (!ok)
+        mNativeDisplayID = RCAR_DEFAULT_DISPLAY;
+
+    r_wm_Error_t wm_err = R_WM_DevInit(mNativeDisplayID);
+    if (wm_err != R_WM_ERR_OK)
+        qFatal("Failed to init WM Dev: %d, error: %d", mNativeDisplayID, wm_err);
+
+    mNativeWindow = (EGLNativeWindowTypeREL*)malloc(sizeof(EGLNativeWindowTypeREL));
+    memset(mNativeWindow, 0, sizeof(EGLNativeWindowTypeREL));
+
+    mNativeWindow->ColorFmt = getWMColorFormat(format);
+    mNativeWindow->PosX = 0;
+    mNativeWindow->PosY = 0;
+    mNativeWindow->PosZ = qEnvironmentVariableIntValue("QT_QPA_WM_LAYER", &ok);
+    if (!ok)
+        mNativeWindow->PosZ = RCAR_DEFAULT_WM_LAYER;
+    mNativeWindow->Pitch = size.width();
+    mNativeWindow->Width = size.width();
+    mNativeWindow->Height = size.height();
+    mNativeWindow->Alpha = format.alphaBufferSize();
+
+    if (format.swapBehavior() == QSurfaceFormat::DefaultSwapBehavior)
+        mNativeWindow->Surface.BufNum = 3;
+    else
+        mNativeWindow->Surface.BufNum = format.swapBehavior();
+
+    mNativeWindow->Surface.Type = R_WM_SURFACE_FB;
+    mNativeWindow->Surface.BufMode = R_WM_WINBUF_ALLOC_INTERNAL;
+
+    wm_err = R_WM_WindowCreate(mNativeDisplayID, mNativeWindow);
+    if (wm_err != R_WM_ERR_OK)
+        qFatal("Failed to create window layer: %d", wm_err);
+    wm_err = R_WM_DevEventRegister(mNativeDisplayID, R_WM_EVENT_VBLANK, 0);
+    if (wm_err != R_WM_ERR_OK)
+        qFatal("Failed to Register vsync event: %d", wm_err);
+    wm_err = R_WM_WindowEnable(mNativeDisplayID, mNativeWindow);
+    if (wm_err != R_WM_ERR_OK)
+        qFatal("Failed to Enable window surface: %d", wm_err);
+
+    return static_cast<EGLNativeWindowType>(mNativeWindow);
+}
+
+void QEglFSRcarIntegration::destroyNativeWindow(EGLNativeWindowType window)
+{
+    R_WM_WindowDisable(mNativeDisplayID, mNativeWindow);
+    usleep(100000); //Needed to allow Window Manager make the window transparent
+    R_WM_WindowDelete(mNativeDisplayID, mNativeWindow);
+    R_WM_DevDeinit(mNativeDisplayID);
+    free(mNativeWindow);
+}
+
+QT_END_NAMESPACE
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/qeglfsrcarintegration.h
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/qeglfsrcarintegration.h
@ -0,0 +1,66 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins 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 QEGLFSVIVINTEGRATION_H
+#define QEGLFSVIVINTEGRATION_H
+
+#include "private/qeglfsdeviceintegration_p.h"
+#include "EGL/eglext_REL.h"
+
+QT_BEGIN_NAMESPACE
+
+class QEglFSRcarIntegration : public QEglFSDeviceIntegration
+{
+public:
+    void platformInit() override;
+    QSize screenSize() const override;
+    EGLNativeWindowType createNativeWindow(QPlatformWindow *window, const QSize &size, const QSurfaceFormat &format) override;
+    void destroyNativeWindow(EGLNativeWindowType window) override;
+    EGLNativeDisplayType platformDisplay() const override;
+
+private:
+    QSize mScreenSize;
+    EGLNativeDisplayType mNativeDisplay;
+    EGLNativeWindowTypeREL *mNativeWindow;
+    int mNativeDisplayID;
+};
+
+QT_END_NAMESPACE
+
+#endif
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/qeglfsrcarmain.cpp
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_rcar/qeglfsrcarmain.cpp
@ -0,0 +1,57 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins 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$
+**
+****************************************************************************/
+
+#include "INTEGRITY.h"
+#include "private/qeglfsdeviceintegration_p.h"
+#include "qeglfsrcarintegration.h"
+
+QT_BEGIN_NAMESPACE
+
+class QEglFSRcarIntegrationPlugin : public QEglFSDeviceIntegrationPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID QEglFSDeviceIntegrationFactoryInterface_iid FILE "eglfs_rcar.json")
+
+public:
+    QEglFSDeviceIntegration *create() override { return new QEglFSRcarIntegration; }
+};
+
+QT_END_NAMESPACE
+
+#include "qeglfsrcarmain.moc"
--- a/src/plugins/platforms/integrity/integrity.pro
+++ b/src/plugins/platforms/integrity/integrity.pro
@ -8,13 +8,18 @@ QT += \
 SOURCES = \
    main.cpp \
    qintegrityfbintegration.cpp \
-    qintegrityfbscreen.cpp \
-    qintegrityhidmanager.cpp
+    qintegrityfbscreen.cpp

 HEADERS = \
    qintegrityfbintegration.h \
-    qintegrityfbscreen.h \
-    qintegrityhidmanager.h
+    qintegrityfbscreen.h
+
+qtConfig(integrityhid) {
+    SOURCES += \
+        qintegrityhidmanager.cpp
+    HEADERS += \
+        qintegrityhidmanager.h
+}

 OTHER_FILES += integrity.json

--- a/src/plugins/platforms/ios/qiosapplicationstate.h
+++ b/src/plugins/platforms/ios/qiosapplicationstate.h
@ -40,20 +40,24 @@
 #ifndef QIOSAPPLICATIONSTATE_H
 #define QIOSAPPLICATIONSTATE_H

-#include <QtCore/qglobal.h>
-#include <QtCore/qvector.h>
+#include <QtCore/qobject.h>

-Q_FORWARD_DECLARE_OBJC_CLASS(NSObject);
+#include <UIKit/UIApplication.h>

 QT_BEGIN_NAMESPACE

-class QIOSApplicationState
+class QIOSApplicationState : public QObject
 {
+    Q_OBJECT
 public:
    QIOSApplicationState();
-    ~QIOSApplicationState();
-private:
-    QVector<NSObject*> m_observers;
+
+    static void handleApplicationStateChanged(UIApplicationState state, const QString &reason);
+    static Qt::ApplicationState toQtApplicationState(UIApplicationState state);
+
+Q_SIGNALS:
+    void applicationStateWillChange(Qt::ApplicationState);
+    void applicationStateDidChange(Qt::ApplicationState);
 };

 QT_END_NAMESPACE
--- a/src/plugins/platforms/ios/qiosapplicationstate.mm
+++ b/src/plugins/platforms/ios/qiosapplicationstate.mm
@ -40,82 +40,77 @@
 #include "qiosapplicationstate.h"

 #include "qiosglobal.h"
+#include "qiosintegration.h"

 #include <qpa/qwindowsysteminterface.h>
 #include <QtCore/qcoreapplication.h>

 #include <QtGui/private/qguiapplication_p.h>

-#import <UIKit/UIKit.h>
-
-static Qt::ApplicationState qtApplicationState(UIApplicationState uiApplicationState)
-{
-    switch (uiApplicationState) {
-    case UIApplicationStateActive:
-        // The application is visible in front, and receiving events
-        return Qt::ApplicationActive;
-    case UIApplicationStateInactive:
-        // The app is running in the foreground but is not receiving events. This
-        // typically happens while transitioning to/from active/background, like
-        // upon app launch or when receiving incoming calls.
-        return Qt::ApplicationInactive;
-    case UIApplicationStateBackground:
-        // Normally the app would enter this state briefly before it gets
-        // suspeded (you have five seconds, according to Apple).
-        // You can request more time and start a background task, which would
-        // normally map closer to Qt::ApplicationHidden. But since we have no
-        // API for doing that yet, we handle this state as "about to be suspended".
-        // Note: A screen-shot for the SpringBoard will also be taken after this
-        // call returns.
-        return Qt::ApplicationSuspended;
-    }
-}
-
-static void handleApplicationStateChanged(UIApplicationState uiApplicationState)
-{
-    Qt::ApplicationState state = qtApplicationState(uiApplicationState);
-    qCDebug(lcQpaApplication) << "moved to" << state;
-    QWindowSystemInterface::handleApplicationStateChanged(state);
-}
-
 QT_BEGIN_NAMESPACE

-QIOSApplicationState::QIOSApplicationState()
+static void qRegisterApplicationStateNotifications()
 {
    NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];
+    NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];

-    m_observers.push_back([notificationCenter addObserverForName:UIApplicationDidBecomeActiveNotification
-        object:nil queue:[NSOperationQueue mainQueue] usingBlock:^(NSNotification *) {
-            handleApplicationStateChanged(UIApplicationStateActive);
-        }
-    ]);
+    // Map between notifications and corresponding application state. Note that
+    // there's no separate notification for moving to UIApplicationStateInactive,
+    // so we use UIApplicationWillResignActiveNotification as an intermediate.
+    static QMap<NSNotificationName, UIApplicationState> notifications {
+        { UIApplicationWillEnterForegroundNotification, UIApplicationStateInactive },
+        { UIApplicationDidBecomeActiveNotification, UIApplicationStateActive },
+        { UIApplicationWillResignActiveNotification, UIApplicationStateInactive },
+        { UIApplicationDidEnterBackgroundNotification, UIApplicationStateBackground },
+    };

-    m_observers.push_back([notificationCenter addObserverForName:UIApplicationWillResignActiveNotification
-        object:nil queue:[NSOperationQueue mainQueue] usingBlock:^(NSNotification *) {
-            // Note: UIApplication is still UIApplicationStateActive at this point,
-            // but since there is no separate notification for the inactive state,
-            // we report UIApplicationStateInactive now.
-            handleApplicationStateChanged(UIApplicationStateInactive);
-        }
-    ]);
-
-    m_observers.push_back([notificationCenter addObserverForName:UIApplicationDidEnterBackgroundNotification
-        object:nil queue:[NSOperationQueue mainQueue] usingBlock:^(NSNotification *) {
-            handleApplicationStateChanged(UIApplicationStateBackground);
-        }
-    ]);
+    for (auto i = notifications.constBegin(); i != notifications.constEnd(); ++i) {
+        [notificationCenter addObserverForName:i.key() object:nil queue:mainQueue
+            usingBlock:^void(NSNotification *notification) {
+                NSRange nameRange = NSMakeRange(2, notification.name.length - 14);
+                QString reason = QString::fromNSString([notification.name substringWithRange:nameRange]);
+                QIOSApplicationState::handleApplicationStateChanged(i.value(), reason);
+        }];
+    }

    // Initialize correct startup state, which may not be the Qt default (inactive)
    UIApplicationState startupState = [UIApplication sharedApplication].applicationState;
-    QGuiApplicationPrivate::applicationState = qtApplicationState(startupState);
+    QIOSApplicationState::handleApplicationStateChanged(startupState, QLatin1String("Application loaded"));
+}
+Q_CONSTRUCTOR_FUNCTION(qRegisterApplicationStateNotifications)
+
+QIOSApplicationState::QIOSApplicationState()
+{
+    UIApplicationState startupState = [UIApplication sharedApplication].applicationState;
+    QIOSApplicationState::handleApplicationStateChanged(startupState, QLatin1String("Application launched"));
 }

-QIOSApplicationState::~QIOSApplicationState()
+void QIOSApplicationState::handleApplicationStateChanged(UIApplicationState uiState, const QString &reason)
 {
-    NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];
-    foreach (const NSObject* observer, m_observers)
-        [notificationCenter removeObserver:observer];
+    Qt::ApplicationState state = toQtApplicationState(uiState);
+    qCDebug(lcQpaApplication) << qPrintable(reason)
+        << "- moving from" << QGuiApplication::applicationState() << "to" << state;
+
+    if (QIOSIntegration *integration = QIOSIntegration::instance()) {
+        emit integration->applicationState.applicationStateWillChange(state);
+        QWindowSystemInterface::handleApplicationStateChanged(state);
+        emit integration->applicationState.applicationStateDidChange(state);
+        qCDebug(lcQpaApplication) << "done moving to" << state;
+    } else {
+        qCDebug(lcQpaApplication) << "no platform integration yet, setting state directly";
+        QGuiApplicationPrivate::applicationState = state;
+    }
 }

+Qt::ApplicationState QIOSApplicationState::toQtApplicationState(UIApplicationState state)
+{
+    switch (state) {
+    case UIApplicationStateActive: return Qt::ApplicationActive;
+    case UIApplicationStateInactive: return Qt::ApplicationInactive;
+    case UIApplicationStateBackground: return Qt::ApplicationSuspended;
+    }
+}
+
+#include "moc_qiosapplicationstate.cpp"
+
 QT_END_NAMESPACE
-
--- a/src/plugins/platforms/ios/qioscontext.h
+++ b/src/plugins/platforms/ios/qioscontext.h
@ -87,6 +87,7 @@ private:
        bool isComplete;
    };

+    static bool verifyGraphicsHardwareAvailability();
    static void deleteBuffers(const FramebufferObject &framebufferObject);

    FramebufferObject &backingFramebufferObjectFor(QPlatformSurface *) const;
--- a/src/plugins/platforms/ios/qioscontext.mm
+++ b/src/plugins/platforms/ios/qioscontext.mm
@ -38,10 +38,13 @@
 ****************************************************************************/

 #include "qioscontext.h"
+
+#include "qiosintegration.h"
 #include "qioswindow.h"

 #include <dlfcn.h>

+#include <QtGui/QGuiApplication>
 #include <QtGui/QOpenGLContext>

 #import <OpenGLES/EAGL.h>
@ -136,6 +139,9 @@ bool QIOSContext::makeCurrent(QPlatformSurface *surface)
 {
    Q_ASSERT_IS_GL_SURFACE(surface);

+    if (!verifyGraphicsHardwareAvailability())
+        return false;
+
    [EAGLContext setCurrentContext:m_eaglContext];

    // For offscreen surfaces we don't prepare a default FBO
@ -214,18 +220,12 @@ void QIOSContext::swapBuffers(QPlatformSurface *surface)
 {
    Q_ASSERT_IS_GL_SURFACE(surface);

+    if (!verifyGraphicsHardwareAvailability())
+        return;
+
    if (surface->surface()->surfaceClass() == QSurface::Offscreen)
        return; // Nothing to do

-    // When using threaded rendering, the render-thread may not have picked up
-    // yet on the fact that a window is no longer exposed, and will try to swap
-    // a non-exposed window. This may in some cases result in crashes, e.g. when
-    // iOS is suspending an application, so we have an extra guard here.
-    if (!static_cast<QIOSWindow *>(surface)->isExposed()) {
-        qCDebug(lcQpaGLContext, "Detected swapBuffers on a non-exposed window, skipping flush");
-        return;
-    }
-
    FramebufferObject &framebufferObject = backingFramebufferObjectFor(surface);
    Q_ASSERT_X(framebufferObject.isComplete, "QIOSContext", "swapBuffers on incomplete FBO");

@ -287,6 +287,54 @@ bool QIOSContext::needsRenderbufferResize(QPlatformSurface *surface) const
    return false;
 }

+bool QIOSContext::verifyGraphicsHardwareAvailability()
+{
+    // Per the iOS OpenGL ES Programming Guide, background apps may not execute commands on the
+    // graphics hardware. Specifically: "In your app delegate’s applicationDidEnterBackground:
+    // method, your app may want to delete some of its OpenGL ES objects to make memory and
+    // resources available to the foreground app. Call the glFinish function to ensure that
+    // the resources are removed immediately. After your app exits its applicationDidEnterBackground:
+    // method, it must not make any new OpenGL ES calls. If it makes an OpenGL ES call, it is
+    // terminated by iOS.".
+    static bool applicationBackgrounded = QGuiApplication::applicationState() == Qt::ApplicationSuspended;
+
+    static dispatch_once_t onceToken = 0;
+    dispatch_once(&onceToken, ^{
+        QIOSApplicationState *applicationState = &QIOSIntegration::instance()->applicationState;
+        connect(applicationState, &QIOSApplicationState::applicationStateWillChange, [](Qt::ApplicationState state) {
+            if (applicationBackgrounded && state != Qt::ApplicationSuspended) {
+                qCDebug(lcQpaGLContext) << "app no longer backgrounded, rendering enabled";
+                applicationBackgrounded = false;
+            }
+        });
+        connect(applicationState, &QIOSApplicationState::applicationStateDidChange, [](Qt::ApplicationState state) {
+            if (state != Qt::ApplicationSuspended)
+                return;
+
+            qCDebug(lcQpaGLContext) << "app backgrounded, rendering disabled";
+            applicationBackgrounded = true;
+
+            // By the time we receive this signal the application has moved into
+            // Qt::ApplactionStateSuspended, and all windows have been obscured,
+            // which should stop all rendering. If there's still an active GL context,
+            // we follow Apple's advice and call glFinish before making it inactive.
+            if (QOpenGLContext *currentContext = QOpenGLContext::currentContext()) {
+                qCWarning(lcQpaGLContext) << "explicitly glFinishing and deactivating" << currentContext;
+                glFinish();
+                currentContext->doneCurrent();
+            }
+        });
+    });
+
+    if (applicationBackgrounded) {
+        static const char warning[] = "OpenGL ES calls are not allowed while an application is backgrounded";
+        Q_ASSERT_X(!applicationBackgrounded, "QIOSContext", warning);
+        qCWarning(lcQpaGLContext, warning);
+    }
+
+    return !applicationBackgrounded;
+}
+
 void QIOSContext::windowDestroyed(QObject *object)
 {
    QIOSWindow *window = static_cast<QIOSWindow *>(object);
--- a/Show More
+++ b/Show More