1 files changed, 356 insertions, 149 deletions

diff --git a/src/core/web_engine_context.cpp b/src/core/web_engine_context.cpp
index d81e1b86b..94110d51c 100644
--- a/src/core/web_engine_context.cpp
+++ b/src/core/web_engine_context.cpp
@@ -4,16 +4,16 @@
 #include "web_engine_context.h"
 
 #include <math.h>
+#include <QtGui/private/qrhi_p.h>
 
 #include "base/base_switches.h"
-#include "base/bind.h"
+#include "base/functional/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
-#include "base/task/post_task.h"
 #include "base/task/sequence_manager/thread_controller_with_message_pump_impl.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "base/threading/thread_restrictions.h"
@@ -22,6 +22,7 @@
 #include "chrome/browser/media/webrtc/webrtc_log_uploader.h"
 #endif
 #include "chrome/common/chrome_switches.h"
+#include "content/common/process_visibility_tracker.h"
 #include "content/gpu/gpu_child_thread.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/compositor/viz_process_transport_factory.h"
@@ -35,9 +36,13 @@
 #include "components/web_cache/browser/web_cache_manager.h"
 #include "content/app/mojo_ipc_support.h"
 #include "content/browser/devtools/devtools_http_handler.h"
+#include "content/browser/gpu/gpu_main_thread_factory.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/scheduler/browser_task_executor.h"
 #include "content/browser/startup_data_impl.h"
 #include "content/browser/startup_helper.h"
+#include "content/browser/utility_process_host.h"
+#include "content/gpu/in_process_gpu_thread.h"
 #include "content/public/app/content_main.h"
 #include "content/public/app/content_main_runner.h"
 #include "content/public/browser/browser_main_runner.h"
@@ -52,9 +57,10 @@
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/main_function_params.h"
-#include "content/public/common/network_service_util.h"
+#include "content/renderer/in_process_renderer_thread.h"
+#include "content/utility/in_process_utility_thread.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
-#include "gpu/command_buffer/service/sync_point_manager.h"
+#include "gpu/config/gpu_finch_features.h"
 #include "media/audio/audio_manager.h"
 #include "media/base/media_switches.h"
 #include "mojo/core/embedder/embedder.h"
@@ -69,14 +75,15 @@
 #include "ui/base/ui_base_features.h"
 #include "ui/events/event_switches.h"
 #include "ui/native_theme/native_theme_features.h"
+#include "ui/gl/gl_utils.h"
 #include "ui/gl/gl_switches.h"
-#if defined(OS_WIN)
+#if defined(Q_OS_WIN)
 #include "sandbox/win/src/sandbox_types.h"
 #include "content/public/app/sandbox_helper_win.h"
-#endif // OS_WIN
+#endif // Q_OS_WIN
 
 #if defined(Q_OS_MACOS)
-#include "base/mac/foundation_util.h"
+#include "base/apple/foundation_util.h"
 #endif
 
 #if QT_CONFIG(accessibility)
@@ -103,6 +110,7 @@
 #include <qopenglcontext_platform.h>
 #endif
 #include <QQuickWindow>
+#include <QRegularExpression>
 #include <QStringList>
 #include <QSurfaceFormat>
 #include <QNetworkProxy>
@@ -117,13 +125,19 @@ Q_GUI_EXPORT QOpenGLContext *qt_gl_global_share_context();
 QT_END_NAMESPACE
 #endif
 
+#define STRINGIFY_LITERAL(x) #x
+#define STRINGIFY_EXPANDED(x) STRINGIFY_LITERAL(x)
+
 namespace QtWebEngineCore {
 
-#if QT_CONFIG(opengl)
+Q_LOGGING_CATEGORY(webEngineContextLog, "qt.webenginecontext")
 
 static bool usingSupportedSGBackend()
 {
-    if (QQuickWindow::graphicsApi() != QSGRendererInterface::OpenGL)
+    if (QQuickWindow::graphicsApi() != QSGRendererInterface::OpenGL
+        && QQuickWindow::graphicsApi() != QSGRendererInterface::Vulkan
+        && QQuickWindow::graphicsApi() != QSGRendererInterface::Metal
+        && QQuickWindow::graphicsApi() != QSGRendererInterface::Direct3D11)
         return false;
 
     const QStringList args = QGuiApplication::arguments();
@@ -146,16 +160,24 @@ static bool usingSupportedSGBackend()
     return device.isEmpty() || device == QLatin1String("rhi");
 }
 
+#if QT_CONFIG(opengl)
 bool usingSoftwareDynamicGL()
 {
+    const char openGlVar[] = "QT_OPENGL";
     if (QCoreApplication::testAttribute(Qt::AA_UseSoftwareOpenGL))
         return true;
+
+    if (qEnvironmentVariableIsSet(openGlVar)) {
+        const QByteArray requested = qgetenv(openGlVar);
+        if (requested == "software")
+            return true;
+    }
 #if defined(Q_OS_WIN)
     HMODULE handle = QNativeInterface::QWGLContext::openGLModuleHandle();
     wchar_t path[MAX_PATH];
     DWORD size = GetModuleFileName(handle, path, MAX_PATH);
     QFileInfo openGLModule(QString::fromWCharArray(path, size));
-    return !openGLModule.fileName().compare(QLatin1String("opengl32sw.dll"),Qt::CaseInsensitive);
+    return openGLModule.fileName().contains(QLatin1String("opengl32sw"),Qt::CaseInsensitive);
 #else
     return false;
 #endif
@@ -167,19 +189,27 @@ static bool openGLPlatformSupport()
             QPlatformIntegration::OpenGL);
 }
 
-static const char *getGLType(bool enableGLSoftwareRendering, bool disableGpu)
+static std::string getGLType(bool enableGLSoftwareRendering, bool disableGpu)
 {
-    const char *glType = gl::kGLImplementationDisabledName;
     const bool tryGL =
             usingSupportedSGBackend() && !usingSoftwareDynamicGL() && openGLPlatformSupport();
-
     if (disableGpu || (!tryGL && !enableGLSoftwareRendering))
-        return glType;
+        return gl::kGLImplementationDisabledName;
+
+#if defined(Q_OS_MACOS)
+    return gl::kGLImplementationANGLEName;
+#else
+#if defined(Q_OS_WIN)
+    if (QQuickWindow::graphicsApi() == QSGRendererInterface::Direct3D11
+        || QQuickWindow::graphicsApi() == QSGRendererInterface::Vulkan) {
+        return gl::kGLImplementationANGLEName;
+    }
+#endif
 
     if (!qt_gl_global_share_context() || !qt_gl_global_share_context()->isValid()) {
-        qWarning("WebEngineContext used before QtWebEngineCore::initialize() or OpenGL context "
+        qWarning("WebEngineContext is used before QtWebEngineQuick::initialize() or OpenGL context "
                  "creation failed.");
-        return glType;
+        return gl::kGLImplementationDisabledName;
     }
 
     const QSurfaceFormat sharedFormat = qt_gl_global_share_context()->format();
@@ -187,22 +217,13 @@ static const char *getGLType(bool enableGLSoftwareRendering, bool disableGpu)
     switch (sharedFormat.renderableType()) {
     case QSurfaceFormat::OpenGL:
         if (sharedFormat.profile() == QSurfaceFormat::CoreProfile) {
-#if defined(Q_OS_MACOS)
-            // Chromium supports core profile only on mac
-            glType = gl::kGLImplementationCoreProfileName;
-#else
-            glType = gl::kGLImplementationDesktopName;
             qWarning("An OpenGL Core Profile was requested, but it is not supported "
                      "on the current platform. Falling back to a non-Core profile. "
                      "Note that this might cause rendering issues.");
-#endif
-        } else {
-            glType = gl::kGLImplementationDesktopName;
         }
-        break;
+        return gl::kGLImplementationDesktopName;
     case QSurfaceFormat::OpenGLES:
-        glType = gl::kGLImplementationEGLName;
-        break;
+        return gl::kGLImplementationEGLName;
     case QSurfaceFormat::OpenVG:
     case QSurfaceFormat::DefaultRenderableType:
     default:
@@ -210,54 +231,180 @@ static const char *getGLType(bool enableGLSoftwareRendering, bool disableGpu)
         qWarning("Unsupported rendering surface format. Please open bug report at "
                  "https://bugreports.qt.io");
     }
-    return glType;
+
+    return gl::kGLImplementationDisabledName;
+#endif // defined(Q_OS_MACOS)
 }
 #else
-static const char *getGLType(bool enableGLSoftwareRendering, bool disableGpu)
+static std::string getGLType(bool /*enableGLSoftwareRendering*/, bool disableGpu)
 {
+    if (disableGpu)
+        return gl::kGLImplementationDisabledName;
+#if defined(Q_OS_MACOS)
+    return gl::kGLImplementationANGLEName;
+#elif defined(Q_OS_WIN)
+    if (QQuickWindow::graphicsApi() == QSGRendererInterface::Direct3D11
+        || QQuickWindow::graphicsApi() == QSGRendererInterface::Vulkan) {
+        return gl::kGLImplementationANGLEName;
+    }
+#endif
     return gl::kGLImplementationDisabledName;
 }
 #endif // QT_CONFIG(opengl)
 
+static std::string getVulkanType(base::CommandLine *cmd)
+{
+#if QT_CONFIG(webengine_vulkan)
+    if (cmd->HasSwitch(switches::kUseVulkan))
+        return cmd->GetSwitchValueASCII(switches::kUseVulkan);
+#endif
+
+    return "disabled";
+}
+
+static std::string getAngleType(const std::string &glType, base::CommandLine *cmd)
+{
+    if (glType == gl::kGLImplementationANGLEName) {
+        if (cmd->HasSwitch(switches::kUseANGLE))
+            return cmd->GetSwitchValueASCII(switches::kUseANGLE);
+
+#if defined(Q_OS_WIN)
+        return gl::kANGLEImplementationD3D11Name;
+#elif defined(Q_OS_MACOS)
+        return gl::kANGLEImplementationMetalName;
+#else
+        return gl::kANGLEImplementationDefaultName;
+#endif
+    }
+
+    return "disabled";
+}
+
+static quint64 getGPUVendorId()
+{
+#if QT_CONFIG(webengine_vulkan)
+    QVulkanInstance vulkanInstance;
+    vulkanInstance.setApiVersion(QVersionNumber(1, 1));
+    if (vulkanInstance.create()) {
+        QRhiVulkanInitParams params;
+        params.inst = &vulkanInstance;
+        QScopedPointer<QRhi> rhi(QRhi::create(QRhi::Vulkan, &params, QRhi::Flags(), nullptr));
+        return rhi->driverInfo().vendorId;
+    }
+#endif
+
+    return 0;
+}
+
+#if defined(Q_OS_WIN)
+static QString getAdapterLuid() {
+    static const bool preferSoftwareDevice = qEnvironmentVariableIntValue("QSG_RHI_PREFER_SOFTWARE_RENDERER");
+    QRhiD3D11InitParams rhiParams;
+    QRhi::Flags flags;
+    if (preferSoftwareDevice) {
+        flags |= QRhi::PreferSoftwareRenderer;
+    }
+    QScopedPointer<QRhi> rhi(QRhi::create(QRhi::D3D11,&rhiParams,flags,nullptr));
+    // mimic what QSGRhiSupport and QBackingStoreRhi does
+    if (!rhi && !preferSoftwareDevice) {
+        flags |= QRhi::PreferSoftwareRenderer;
+        rhi.reset(QRhi::create(QRhi::D3D11, &rhiParams, flags));
+    }
+    if (rhi) {
+        const QRhiD3D11NativeHandles *handles =
+                static_cast<const QRhiD3D11NativeHandles *>(rhi->nativeHandles());
+        Q_ASSERT(handles);
+        return QString("%1,%2").arg(handles->adapterLuidHigh).arg(handles->adapterLuidLow);
+    } else {
+        return QString();
+    }
+}
+#endif
+
 #if QT_CONFIG(webengine_pepper_plugins)
 void dummyGetPluginCallback(const std::vector<content::WebPluginInfo>&)
 {
 }
 #endif
 
-static void logContext(const char *glType, base::CommandLine *cmd)
+static void logContext(const std::string &glType, base::CommandLine *cmd)
 {
-    QLoggingCategory webEngineContextLog("qt.webenginecontext");
-    if (webEngineContextLog.isInfoEnabled()) {
+    if (Q_UNLIKELY(webEngineContextLog().isDebugEnabled())) {
+        QStringList log;
+        log << "\n";
+
+        log << "Chromium GL Backend:" << glType.c_str() << "\n";
+        log << "Chromium ANGLE Backend:" << getAngleType(glType, cmd).c_str() << "\n";
+        log << "Chromium Vulkan Backend:" << getVulkanType(cmd).c_str() << "\n";
+        log << "\n";
+
+        log << "QSG RHI Backend:" << QSGRhiSupport::instance()->rhiBackendName() << "\n";
+        log << "QSG RHI Backend Supported:" << (usingSupportedSGBackend() ? "yes" : "no") << "\n";
+        log << "GPU Vendor:";
+        if (quint64 vendorId = getGPUVendorId()) {
+            switch (vendorId) {
+            case 0x1002:
+                log << "AMD";
+                break;
+            case 0x10DE:
+                log << "NVIDIA";
+                break;
+            case 0x8086:
+                log << "Intel";
+                break;
+            case 0x1010:
+                log << "ImgTec";
+                break;
+            case 0x13B5:
+                log << "ARM";
+                break;
+            case 0x5143:
+                log << "Qualcomm";
+                break;
+            default:
+                break;
+            }
+            log << QString("(0x%1)\n").arg(vendorId, 0, 16);
+        } else {
+            log << "Unable to detect\n";
+        }
+        log << "\n";
+
 #if QT_CONFIG(opengl)
-        const QSurfaceFormat sharedFormat = qt_gl_global_share_context()->format();
-        const auto profile = QMetaEnum::fromType<QSurfaceFormat::OpenGLContextProfile>().valueToKey(
-                sharedFormat.profile());
-        const auto type = QMetaEnum::fromType<QSurfaceFormat::RenderableType>().valueToKey(
-                sharedFormat.renderableType());
-        const base::CommandLine::SwitchMap switch_map = cmd->GetSwitches();
-        QStringList params;
-        for (const auto &pair : switch_map)
-            params << " * " << toQt(pair.first)
-                   << toQt(pair.second) << "\n";
-        qCInfo(webEngineContextLog,
-               "\n\nGL Type: %s\n"
-               "Surface Type: %s\n"
-               "Surface Profile: %s\n"
-               "Surface Version: %d.%d\n"
-               "QSG RHI Backend: %s\n"
-               "Using Supported QSG Backend: %s\n"
-               "Using Software Dynamic GL: %s\n"
-               "Using Multithreaded OpenGL: %s\n\n"
-               "Init Parameters:\n %s",
-               glType, type, profile, sharedFormat.majorVersion(), sharedFormat.minorVersion(),
-               qUtf8Printable(QSGRhiSupport::instance()->rhiBackendName()),
-               usingSupportedSGBackend() ? "yes" : "no", usingSoftwareDynamicGL() ? "yes" : "no",
-               !WebEngineContext::isGpuServiceOnUIThread() ? "yes" : "no",
-               qPrintable(params.join(" ")));
-#else
-        qCInfo(webEngineContextLog) << "WebEngine compiled with no opengl enabled.";
-#endif //QT_CONFIG(opengl)
+#if defined(USE_OZONE)
+        log << "Using GLX:" << (GLContextHelper::getGlxPlatformInterface() ? "yes" : "no") << "\n";
+        log << "Using EGL:" << (GLContextHelper::getEglPlatformInterface() ? "yes" : "no") << "\n";
+#endif
+        log << "Using Shared GL:" << (qt_gl_global_share_context() ? "yes" : "no") << "\n";
+        if (qt_gl_global_share_context()) {
+            log << "Using Software Dynamic GL:" << (usingSoftwareDynamicGL() ? "yes" : "no")
+                << "\n";
+
+            const QSurfaceFormat sharedFormat = qt_gl_global_share_context()
+                    ? qt_gl_global_share_context()->format()
+                    : QSurfaceFormat::defaultFormat();
+            const auto profile =
+                    QMetaEnum::fromType<QSurfaceFormat::OpenGLContextProfile>().valueToKey(
+                            sharedFormat.profile());
+            const auto type = QMetaEnum::fromType<QSurfaceFormat::RenderableType>().valueToKey(
+                    sharedFormat.renderableType());
+            log << "Surface Type:" << type << "\n";
+            log << "Surface Profile:" << profile << "\n";
+            log << "Surface Version:"
+                << QString("%1.%2")
+                            .arg(sharedFormat.majorVersion())
+                            .arg(sharedFormat.minorVersion())
+                << "\n";
+        }
+        log << "\n";
+#endif // QT_CONFIG(opengl)
+
+        log << "Init Parameters:\n";
+        const base::CommandLine::SwitchMap switchMap = cmd->GetSwitches();
+        for (const auto &pair : switchMap)
+            log << " * " << toQt(pair.first) << toQt(pair.second) << "\n";
+
+        qCDebug(webEngineContextLog) << qPrintable(log.join(" "));
     }
 }
 
@@ -404,7 +551,6 @@ void WebEngineContext::destroy()
     // on IO thread (triggered by ~BrowserMainRunner). But by that time the UI
     // task runner is not working anymore so we need to do this earlier.
     cleanupVizProcess();
-    destroyGpuProcess();
     // Flush the UI message loop before quitting.
     flushMessages();
 
@@ -461,7 +607,6 @@ WebEngineContext::~WebEngineContext()
     Q_ASSERT(!m_devtoolsServer);
     Q_ASSERT(!m_browserRunner);
     Q_ASSERT(m_profileAdapters.isEmpty());
-    delete s_syncPointManager.fetchAndStoreRelaxed(nullptr);
 }
 
 WebEngineContext *WebEngineContext::current()
@@ -535,18 +680,6 @@ ProxyAuthentication WebEngineContext::qProxyNetworkAuthentication(QString host,
 
 const static char kChromiumFlagsEnv[] = "QTWEBENGINE_CHROMIUM_FLAGS";
 const static char kDisableSandboxEnv[] = "QTWEBENGINE_DISABLE_SANDBOX";
-const static char kDisableInProcGpuThread[] = "QTWEBENGINE_DISABLE_GPU_THREAD";
-
-// static
-bool WebEngineContext::isGpuServiceOnUIThread()
-{
-    static bool threadedGpu =
-#if QT_CONFIG(opengl) && !defined(Q_OS_MACOS)
-            QOpenGLContext::supportsThreadedOpenGL() &&
-#endif
-            !qEnvironmentVariableIsSet(kDisableInProcGpuThread);
-    return !threadedGpu;
-}
 
 static void initializeFeatureList(base::CommandLine *commandLine, std::vector<std::string> enableFeatures, std::vector<std::string> disableFeatures)
 {
@@ -598,7 +731,7 @@ WebEngineContext::WebEngineContext()
 #if defined(Q_OS_MACOS)
     // The bundled handling is currently both completely broken in Chromium,
     // and unnecessary for us.
-    base::mac::SetOverrideAmIBundled(false);
+    base::apple::SetOverrideAmIBundled(false);
 #endif
 
     base::ThreadPoolInstance::Create("Browser");
@@ -624,16 +757,11 @@ WebEngineContext::WebEngineContext()
     // Allow us to inject javascript like any webview toolkit.
     content::RenderFrameHost::AllowInjectingJavaScript();
 
-    QStringList appArgs = QCoreApplication::arguments();
-
     bool useEmbeddedSwitches = false;
-#if defined(QTWEBENGINE_EMBEDDED_SWITCHES)
-    useEmbeddedSwitches = !appArgs.contains(QStringLiteral("--disable-embedded-switches"));
-#else
-    useEmbeddedSwitches  = appArgs.contains(QStringLiteral("--enable-embedded-switches"));
-#endif
+    bool enableGLSoftwareRendering = false;
+    base::CommandLine *parsedCommandLine =
+            initCommandLine(useEmbeddedSwitches, enableGLSoftwareRendering);
 
-    base::CommandLine* parsedCommandLine = commandLine();
     setupProxyPac(parsedCommandLine);
     parsedCommandLine->AppendSwitchPath(switches::kBrowserSubprocessPath, WebEngineLibraryInfo::getPath(content::CHILD_PROCESS_EXE));
 
@@ -649,10 +777,6 @@ WebEngineContext::WebEngineContext()
         parsedCommandLine->AppendSwitch(sandbox::policy::switches::kNoSandbox);
         qInfo() << "Sandboxing disabled by user.";
     }
-    // Do not try to be clever with device-scale-factor, it messes up scaling in accessibility for us
-    parsedCommandLine->AppendSwitchASCII(switches::kEnableUseZoomForDSF, "false");
-
-    parsedCommandLine->AppendSwitch(switches::kEnableThreadedCompositing);
 
     // Do not advertise a feature we have removed at compile time
     parsedCommandLine->AppendSwitch(switches::kDisableSpeechAPI);
@@ -669,21 +793,62 @@ WebEngineContext::WebEngineContext()
     // Avoid crashing when websites tries using this feature (since 83)
     disableFeatures.push_back(features::kInstalledApp.name);
 
+    // Not implemented but it overrides the devtools eyedropper
+    // Should be sync with kEyeDropper base::Feature
+    parsedCommandLine->AppendSwitchASCII(switches::kDisableBlinkFeatures, "EyeDropperAPI");
+    disableFeatures.push_back(features::kEyeDropper.name);
+
     // Explicitly tell Chromium about default-on features we do not support
     disableFeatures.push_back(features::kBackgroundFetch.name);
     disableFeatures.push_back(features::kWebOTP.name);
     disableFeatures.push_back(features::kWebPayments.name);
     disableFeatures.push_back(features::kWebUsb.name);
-    disableFeatures.push_back(media::kPictureInPicture.name);
 
     if (useEmbeddedSwitches) {
         // embedded switches are based on the switches for Android, see content/browser/android/content_startup_flags.cc
         enableFeatures.push_back(features::kOverlayScrollbar.name);
         parsedCommandLine->AppendSwitch(switches::kEnableViewport);
-        parsedCommandLine->AppendSwitch(switches::kMainFrameResizesAreOrientationChanges);
         parsedCommandLine->AppendSwitch(cc::switches::kDisableCompositedAntialiasing);
     }
 
+#if QT_CONFIG(webengine_vulkan) && defined(USE_OZONE)
+    if (QQuickWindow::graphicsApi() == QSGRendererInterface::Vulkan) {
+        enableFeatures.push_back(features::kVulkan.name);
+        parsedCommandLine->AppendSwitchASCII(switches::kUseVulkan,
+                                             switches::kVulkanImplementationNameNative);
+        const char deviceExtensionsVar[] = "QT_VULKAN_DEVICE_EXTENSIONS";
+        QByteArrayList requiredDeviceExtensions = { "VK_KHR_external_memory_fd",
+                                                    "VK_EXT_external_memory_dma_buf",
+                                                    "VK_EXT_image_drm_format_modifier" };
+        if (qEnvironmentVariableIsSet(deviceExtensionsVar)) {
+            QByteArrayList envExtList = qgetenv(deviceExtensionsVar).split(';');
+            int found = 0;
+            for (const QByteArray &ext : requiredDeviceExtensions) {
+                if (envExtList.contains(ext))
+                    found++;
+            }
+            if (found != requiredDeviceExtensions.size()) {
+                qWarning().nospace()
+                        << "Vulkan rendering may fail because " << deviceExtensionsVar
+                        << " environment variable is already set but it doesn't contain"
+                        << " some of the required Vulkan device extensions:\n"
+                        << qPrintable(requiredDeviceExtensions.join('\n'));
+            }
+        } else {
+            qputenv(deviceExtensionsVar, requiredDeviceExtensions.join(';'));
+        }
+    }
+#endif // QT_CONFIG(webengine_vulkan) && defined(USE_OZONE)
+
+#if defined(Q_OS_WIN)
+    if (QQuickWindow::graphicsApi() == QSGRendererInterface::Direct3D11
+        || QQuickWindow::graphicsApi() == QSGRendererInterface::Vulkan) {
+        const QString luid = getAdapterLuid();
+        if (!luid.isEmpty())
+            parsedCommandLine->AppendSwitchASCII(switches::kUseAdapterLuid, luid.toStdString());
+    }
+#endif
+
     initializeFeatureList(parsedCommandLine, enableFeatures, disableFeatures);
 
     GLContextHelper::initialize();
@@ -692,11 +857,15 @@ WebEngineContext::WebEngineContext()
     // bitmaps, use software rendering via software OpenGL. This might be less
     // performant, but at least provides WebGL support.
     // TODO(miklocek), check if this still works with latest chromium
-    const bool enableGLSoftwareRendering = appArgs.contains(QStringLiteral("--enable-webgl-software-rendering"));
     const bool disableGpu = parsedCommandLine->HasSwitch(switches::kDisableGpu);
-    const char *glType = getGLType(enableGLSoftwareRendering, disableGpu);
+    std::string glType;
+    if (parsedCommandLine->HasSwitch(switches::kUseGL))
+        glType = parsedCommandLine->GetSwitchValueASCII(switches::kUseGL);
+    else {
+        glType = getGLType(enableGLSoftwareRendering, disableGpu);
+        parsedCommandLine->AppendSwitchASCII(switches::kUseGL, glType);
+    }
 
-    parsedCommandLine->AppendSwitchASCII(switches::kUseGL, glType);
     parsedCommandLine->AppendSwitch(switches::kInProcessGPU);
 
     if (glType != gl::kGLImplementationDisabledName) {
@@ -705,19 +874,26 @@ WebEngineContext::WebEngineContext()
             parsedCommandLine->AppendSwitch(switches::kIgnoreGpuBlocklist);
         }
 #if QT_CONFIG(opengl)
-        const QSurfaceFormat sharedFormat = QOpenGLContext::globalShareContext()->format();
-        if (sharedFormat.profile() == QSurfaceFormat::CompatibilityProfile)
-            parsedCommandLine->AppendSwitch(switches::kCreateDefaultGLContext);
+        if (glType != gl::kGLImplementationANGLEName) {
+            QOpenGLContext *shareContext = QOpenGLContext::globalShareContext();
+            Q_ASSERT(shareContext);
+            const QSurfaceFormat sharedFormat = shareContext->format();
+            if (sharedFormat.profile() == QSurfaceFormat::CompatibilityProfile)
+                parsedCommandLine->AppendSwitch(switches::kCreateDefaultGLContext);
 #if defined(Q_OS_WIN)
-        // This switch is used in Chromium's gl_context_wgl.cc file to determine whether to create
-        // an OpenGL Core Profile context. If the switch is not set, it would always try to create a
-        // Core Profile context, even if Qt uses a legacy profile, which causes
-        // "Could not share GL contexts" warnings, because it's not possible to share between Core and
-        // legacy profiles. See GLContextWGL::Initialize().
-        if (sharedFormat.renderableType() == QSurfaceFormat::OpenGL
-            && sharedFormat.profile() != QSurfaceFormat::CoreProfile)
-            parsedCommandLine->AppendSwitch(switches::kDisableES3GLContext);
+            // This switch is used in Chromium's gl_context_wgl.cc file to determine whether to create
+            // an OpenGL Core Profile context. If the switch is not set, it would always try to create a
+            // Core Profile context, even if Qt uses a legacy profile, which causes
+            // "Could not share GL contexts" warnings, because it's not possible to share between Core and
+            // legacy profiles. See GLContextWGL::Initialize().
+            if (sharedFormat.renderableType() == QSurfaceFormat::OpenGL
+                && sharedFormat.profile() != QSurfaceFormat::CoreProfile) {
+                gl::GlWorkarounds workarounds = gl::GetGlWorkarounds();
+                workarounds.disable_es3gl_context = true;
+                gl::SetGlWorkarounds(workarounds);
+            }
 #endif
+        }
 #endif //QT_CONFIG(opengl)
     } else if (!disableGpu) {
         parsedCommandLine->AppendSwitch(switches::kDisableGpu);
@@ -729,7 +905,7 @@ WebEngineContext::WebEngineContext()
 
     content::ContentMainParams contentMainParams(m_mainDelegate.get());
     contentMainParams.setup_signal_handlers = false;
-#if defined(OS_WIN)
+#if defined(Q_OS_WIN)
     contentMainParams.sandbox_info = QtWebEngineSandbox::staticSandboxInterfaceInfo();
     sandbox::SandboxInterfaceInfo sandbox_info = {nullptr};
     if (!contentMainParams.sandbox_info) {
@@ -747,12 +923,13 @@ WebEngineContext::WebEngineContext()
     m_mainDelegate->PreBrowserMain();
     base::MessagePump::OverrideMessagePumpForUIFactory(messagePumpFactory);
     content::BrowserTaskExecutor::Create();
-    m_mainDelegate->PostEarlyInitialization(false);
+    m_mainDelegate->PostEarlyInitialization({});
     content::StartBrowserThreadPool();
     content::BrowserTaskExecutor::PostFeatureListSetup();
     tracing::InitTracingPostThreadPoolStartAndFeatureList(false);
-    m_discardableSharedMemoryManager = std::make_unique<discardable_memory::DiscardableSharedMemoryManager>();
     base::PowerMonitor::Initialize(std::make_unique<base::PowerMonitorDeviceSource>());
+    content::ProcessVisibilityTracker::GetInstance();
+    m_discardableSharedMemoryManager = std::make_unique<discardable_memory::DiscardableSharedMemoryManager>();
 
     m_mojoIpcSupport = std::make_unique<content::MojoIpcSupport>(content::BrowserTaskExecutor::CreateIOThread());
     download::SetIOTaskRunner(m_mojoIpcSupport->io_thread()->task_runner());
@@ -776,7 +953,7 @@ WebEngineContext::WebEngineContext()
     // Initialize WebCacheManager here to ensure its subscription to render process creation events.
     web_cache::WebCacheManager::GetInstance();
 
-#if defined(OS_LINUX)
+#if defined(Q_OS_LINUX)
     media::AudioManager::SetGlobalAppName(QCoreApplication::applicationName().toStdString());
 #endif
 
@@ -818,54 +995,71 @@ WebRtcLogUploader *WebEngineContext::webRtcLogUploader()
 #endif
 
 
-static QMutex s_spmMutex;
-QAtomicPointer<gpu::SyncPointManager> WebEngineContext::s_syncPointManager;
-
-gpu::SyncPointManager *WebEngineContext::syncPointManager()
+base::CommandLine *WebEngineContext::initCommandLine(bool &useEmbeddedSwitches,
+                                                     bool &enableGLSoftwareRendering)
 {
-    if (gpu::SyncPointManager *spm = s_syncPointManager.loadAcquire())
-        return spm;
-    QMutexLocker lock(&s_spmMutex);
-    if (!s_syncPointManager)
-        s_syncPointManager.storeRelaxed(new gpu::SyncPointManager());
-    return s_syncPointManager.loadRelaxed();
-}
+    if (!base::CommandLine::CreateEmpty())
+        qFatal("base::CommandLine has been initialized unexpectedly.");
+
+    QStringList appArgs = QCoreApplication::arguments();
+    if (appArgs.empty()) {
+        qFatal("Argument list is empty, the program name is not passed to QCoreApplication. "
+               "base::CommandLine cannot be properly initialized.");
+    }
 
-base::CommandLine* WebEngineContext::commandLine() {
-    if (base::CommandLine::CreateEmpty()) {
-        base::CommandLine* parsedCommandLine = base::CommandLine::ForCurrentProcess();
-        QStringList appArgs = QCoreApplication::arguments();
-        if (qEnvironmentVariableIsSet(kChromiumFlagsEnv)) {
-            appArgs = appArgs.mid(0, 1); // Take application name and drop the rest
-            appArgs.append(parseEnvCommandLine(qEnvironmentVariable(kChromiumFlagsEnv)));
+    base::CommandLine *parsedCommandLine = base::CommandLine::ForCurrentProcess();
+    int index = appArgs.indexOf(QRegularExpression(QLatin1String("--webEngineArgs"),
+                                                   QRegularExpression::CaseInsensitiveOption));
+    if (qEnvironmentVariableIsSet(kChromiumFlagsEnv)) {
+        appArgs = appArgs.mid(0, 1); // Take application name and drop the rest
+        appArgs.append(parseEnvCommandLine(qEnvironmentVariable(kChromiumFlagsEnv)));
+        if (index > -1)
+            qWarning("Note 'webEngineArgs' are overridden by QTWEBENGINE_CHROMIUM_FLAGS");
+    } else {
+        if (index > -1) {
+            appArgs.erase(appArgs.begin() + 1, appArgs.begin() + index + 1);
         } else {
-            int index = appArgs.indexOf(QLatin1String("--webEngineArgs"));
-            if (index > -1) {
-                appArgs.erase(appArgs.begin() + 1, appArgs.begin() + index + 1);
-            } else {
-                appArgs = appArgs.mid(0, 1);
-            }
+            appArgs = appArgs.mid(0, 1);
         }
-#ifdef Q_OS_WIN
-        appArgs.removeAll(QStringLiteral("--enable-webgl-software-rendering"));
+    }
+#if defined(QTWEBENGINE_EMBEDDED_SWITCHES)
+    useEmbeddedSwitches = !appArgs.contains(QStringLiteral("--disable-embedded-switches"));
+#else
+    useEmbeddedSwitches = appArgs.contains(QStringLiteral("--enable-embedded-switches"));
 #endif
-        appArgs.removeAll(QStringLiteral("--disable-embedded-switches"));
-        appArgs.removeAll(QStringLiteral("--enable-embedded-switches"));
+    enableGLSoftwareRendering =
+            appArgs.removeAll(QStringLiteral("--enable-webgl-software-rendering"));
+    appArgs.removeAll(QStringLiteral("--disable-embedded-switches"));
+    appArgs.removeAll(QStringLiteral("--enable-embedded-switches"));
+
+    bool isRemoteDebugPort =
+            (-1
+             != appArgs.indexOf(QRegularExpression(QStringLiteral("--remote-debugging-port=.*"),
+                                                   QRegularExpression::CaseInsensitiveOption)))
+            || !qEnvironmentVariable("QTWEBENGINE_REMOTE_DEBUGGING").isEmpty();
+    bool isRemoteAllowOrigins =
+            (-1
+             != appArgs.indexOf(QRegularExpression(QStringLiteral("--remote-allow-origins=.*"),
+                                                   QRegularExpression::CaseInsensitiveOption)));
+
+    if (isRemoteDebugPort && !isRemoteAllowOrigins) {
+        appArgs.append(QStringLiteral("--remote-allow-origins=*"));
+        qWarning("Added {--remote-allow-origins=*} to command-line arguments "
+                 "to avoid web socket connection errors during remote debugging.");
+    }
 
-        base::CommandLine::StringVector argv;
-        argv.resize(appArgs.size());
+    base::CommandLine::StringVector argv;
+    argv.resize(appArgs.size());
 #if defined(Q_OS_WIN)
-        for (int i = 0; i < appArgs.size(); ++i)
-            argv[i] = appArgs[i].toStdWString();
+    for (int i = 0; i < appArgs.size(); ++i)
+        argv[i] = appArgs[i].toStdWString();
 #else
-        for (int i = 0; i < appArgs.size(); ++i)
-            argv[i] = appArgs[i].toStdString();
+    for (int i = 0; i < appArgs.size(); ++i)
+        argv[i] = appArgs[i].toStdString();
 #endif
-        parsedCommandLine->InitFromArgv(argv);
-        return parsedCommandLine;
-    } else {
-        return base::CommandLine::ForCurrentProcess();
-    }
+    parsedCommandLine->InitFromArgv(argv);
+
+    return parsedCommandLine;
 }
 
 bool WebEngineContext::closingDown()
@@ -873,21 +1067,34 @@ bool WebEngineContext::closingDown()
     return m_closingDown;
 }
 
+void WebEngineContext::registerMainThreadFactories()
+{
+    content::UtilityProcessHost::RegisterUtilityMainThreadFactory(content::CreateInProcessUtilityThread);
+    content::RenderProcessHostImpl::RegisterRendererMainThreadFactory(content::CreateInProcessRendererThread);
+    content::RegisterGpuMainThreadFactory(content::CreateInProcessGpuThread);
+}
+
 } // namespace
 
 QT_BEGIN_NAMESPACE
 const char *qWebEngineVersion() noexcept
 {
-    return QTWEBENGINECORE_VERSION_STR;
+    return STRINGIFY_EXPANDED(QTWEBENGINECORE_VERSION_STR);
+}
+
+const char *qWebEngineProcessName() noexcept
+{
+    return STRINGIFY_EXPANDED(QTWEBENGINEPROCESS_NAME);
 }
 
 const char *qWebEngineChromiumVersion() noexcept
 {
-    return CHROMIUM_VERSION;
+    return STRINGIFY_EXPANDED(CHROMIUM_VERSION);
 }
+
 const char *qWebEngineChromiumSecurityPatchVersion() noexcept
 {
-    return "99.0.4844.84"; // FIXME: Remember to update
+    return "122.0.6261.128"; // FIXME: Remember to update
 }
 
 QT_END_NAMESPACE