Attachment 464630 Details for Bug 222366 – WIP patch

[patch] WIP patch

wk-network-session.diff (text/plain), 214.52 KB, created by Carlos Garcia Campos on 2023-01-24 06:57:07 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Carlos Garcia Campos

Created: 2023-01-24 06:57:07 PST

Size: 214.52 KB

patch

obsolete

>diff --git a/Source/WebKit/PlatformGTK.cmake b/Source/WebKit/PlatformGTK.cmake
>index 3a8566afedc4..f8dfd430e2e6 100644
>--- a/Source/WebKit/PlatformGTK.cmake
>+++ b/Source/WebKit/PlatformGTK.cmake
>@@ -183,6 +183,12 @@ set(WebKitGTK_HEADER_TEMPLATES
>     ${WEBKIT_DIR}/UIProcess/API/gtk/WebKitWebViewBase.h.in
> )
> 
>+if (ENABLE_2022_GLIB_API)
>+    list(APPEND WebKitGTK_HEADER_TEMPLATES
>+        ${WEBKIT_DIR}/UIProcess/API/glib/WebKitNetworkSession.h.in
>+    )
>+endif ()
>+
> set(WebKitGTK_INSTALLED_HEADERS
>     ${WebKitGTK_DERIVED_SOURCES_DIR}/webkit/WebKitEnumTypes.h
>     ${WebKitGTK_DERIVED_SOURCES_DIR}/webkit/WebKitVersion.h
>diff --git a/Source/WebKit/PlatformWPE.cmake b/Source/WebKit/PlatformWPE.cmake
>index 0e63cf33c439..d1d196cff280 100644
>--- a/Source/WebKit/PlatformWPE.cmake
>+++ b/Source/WebKit/PlatformWPE.cmake
>@@ -194,6 +194,12 @@ set(WPE_API_HEADER_TEMPLATES
>     ${WEBKIT_DIR}/UIProcess/API/glib/webkit.h.in
> )
> 
>+if (ENABLE_2022_GLIB_API)
>+    list(APPEND WPE_API_HEADER_TEMPLATES
>+        ${WEBKIT_DIR}/UIProcess/API/glib/WebKitNetworkSession.h.in
>+    )
>+endif ()
>+
> set(WPE_API_INSTALLED_HEADERS
>     ${DERIVED_SOURCES_WPE_API_DIR}/WebKitEnumTypes.h
>     ${DERIVED_SOURCES_WPE_API_DIR}/WebKitVersion.h
>diff --git a/Source/WebKit/SourcesGTK.txt b/Source/WebKit/SourcesGTK.txt
>index 447f9908059e..e8a16a51f199 100644
>--- a/Source/WebKit/SourcesGTK.txt
>+++ b/Source/WebKit/SourcesGTK.txt
>@@ -157,6 +157,7 @@ UIProcess/API/glib/WebKitNavigationAction.cpp @no-unify
> UIProcess/API/glib/WebKitNavigationClient.cpp @no-unify
> UIProcess/API/glib/WebKitNavigationPolicyDecision.cpp @no-unify
> UIProcess/API/glib/WebKitNetworkProxySettings.cpp @no-unify
>+UIProcess/API/glib/WebKitNetworkSession.cpp @no-unify
> UIProcess/API/glib/WebKitNotification.cpp @no-unify
> UIProcess/API/glib/WebKitNotificationPermissionRequest.cpp @no-unify
> UIProcess/API/glib/WebKitNotificationProvider.cpp @no-unify
>diff --git a/Source/WebKit/SourcesWPE.txt b/Source/WebKit/SourcesWPE.txt
>index 8533ccf5cc76..498a44eacbbe 100644
>--- a/Source/WebKit/SourcesWPE.txt
>+++ b/Source/WebKit/SourcesWPE.txt
>@@ -149,6 +149,7 @@ UIProcess/API/glib/WebKitNavigationAction.cpp @no-unify
> UIProcess/API/glib/WebKitNavigationClient.cpp @no-unify
> UIProcess/API/glib/WebKitNavigationPolicyDecision.cpp @no-unify
> UIProcess/API/glib/WebKitNetworkProxySettings.cpp @no-unify
>+UIProcess/API/glib/WebKitNetworkSession.cpp @no-unify
> UIProcess/API/glib/WebKitNotification.cpp @no-unify
> UIProcess/API/glib/WebKitNotificationPermissionRequest.cpp @no-unify
> UIProcess/API/glib/WebKitNotificationProvider.cpp @no-unify
>diff --git a/Source/WebKit/UIProcess/API/glib/IconDatabase.cpp b/Source/WebKit/UIProcess/API/glib/IconDatabase.cpp
>index 4ca7ab200846..91e9a2c5b71c 100644
>--- a/Source/WebKit/UIProcess/API/glib/IconDatabase.cpp
>+++ b/Source/WebKit/UIProcess/API/glib/IconDatabase.cpp
>@@ -56,7 +56,7 @@ IconDatabase::IconDatabase(const String& path, AllowDatabaseWrite allowDatabaseW
>     // We initialize the database synchronously, it's hopefully fast enough because it makes
>     // the implementation a lot simpler.
>     m_workQueue->dispatchSync([&] {
>-        if (allowDatabaseWrite == AllowDatabaseWrite::No && !FileSystem::fileExists(path))
>+        if (allowDatabaseWrite == AllowDatabaseWrite::No && (!path.isNull() || !FileSystem::fileExists(path)))
>             return;
> 
>         auto databaseDirectory = FileSystem::parentPath(path);
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitAutocleanups.h.in b/Source/WebKit/UIProcess/API/glib/WebKitAutocleanups.h.in
>index 490b9de705ef..c885b0df81fe 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitAutocleanups.h.in
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitAutocleanups.h.in
>@@ -45,6 +45,9 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitInputMethodContext, g_object_unref)
> G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitInstallMissingMediaPluginsPermissionRequest, g_object_unref)
> #endif
> G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNavigationPolicyDecision, g_object_unref)
>+#if ENABLE(2022_GLIB_API)
>+G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNetworkSession, g_object_unref)
>+#endif
> G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNotification, g_object_unref)
> G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitNotificationPermissionRequest, g_object_unref)
> G_DEFINE_AUTOPTR_CLEANUP_FUNC (WebKitPermissionRequest, g_object_unref)
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitAutomationSession.cpp b/Source/WebKit/UIProcess/API/glib/WebKitAutomationSession.cpp
>index 6a75b9dd31c5..1c054f45b495 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitAutomationSession.cpp
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitAutomationSession.cpp
>@@ -31,6 +31,10 @@
> #include <wtf/glib/WTFGType.h>
> #include <wtf/text/CString.h>
> 
>+#if ENABLE(2022_GLIB_API)
>+#include "WebKitNetworkSession.h"
>+#endif
>+
> using namespace WebKit;
> 
> /**
>@@ -350,13 +354,27 @@ WebKitAutomationSession* webkitAutomationSessionCreate(WebKitWebContext* webCont
> {
>     auto* session = WEBKIT_AUTOMATION_SESSION(g_object_new(WEBKIT_TYPE_AUTOMATION_SESSION, "id", sessionID, nullptr));
>     session->priv->webContext = webContext;
>-    if (capabilities.acceptInsecureCertificates)
>+#if ENABLE(2022_GLIB_API)
>+    WebKitNetworkSession* networkSession = webkitWebContextGetNetworkSessionForAutomation(webContext);
>+#endif
>+
>+    if (capabilities.acceptInsecureCertificates) {
>+#if ENABLE(2022_GLIB_API)
>+        webkit_network_session_set_tls_errors_policy(networkSession, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#else
>         webkit_website_data_manager_set_tls_errors_policy(webkit_web_context_get_website_data_manager(webContext), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#endif
>+    }
> 
>     for (auto& certificate : capabilities.certificates) {
>         GRefPtr<GTlsCertificate> tlsCertificate = adoptGRef(g_tls_certificate_new_from_file(certificate.second.utf8().data(), nullptr));
>-        if (tlsCertificate)
>+        if (tlsCertificate) {
>+#if ENABLE(2022_GLIB_API)
>+            webkit_network_session_allow_tls_certificate_for_host(networkSession, tlsCertificate.get(), certificate.first.utf8().data());
>+#else
>             webkit_web_context_allow_tls_certificate_for_host(webContext, tlsCertificate.get(), certificate.first.utf8().data());
>+#endif
>+        }
>     }
>     if (capabilities.proxy) {
>         if (capabilities.proxy->type == "pac"_s) {
>@@ -365,13 +383,21 @@ WebKitAutomationSession* webkitAutomationSessionCreate(WebKitWebContext* webCont
>             if (capabilities.proxy->autoconfigURL)
>                 settings.defaultProxyURL = capabilities.proxy->autoconfigURL->utf8();
>             if (!settings.isEmpty()) {
>+#if ENABLE(2022_GLIB_API)
>+                auto& dataStore = webkitWebsiteDataManagerGetDataStore(webkit_network_session_get_website_data_manager(networkSession));
>+#else
>                 auto& dataStore = webkitWebsiteDataManagerGetDataStore(webkit_web_context_get_website_data_manager(webContext));
>+#endif
>                 dataStore.setNetworkProxySettings(WTFMove(settings));
>             }
>         } else {
>             WebKitNetworkProxySettings* proxySettings = nullptr;
>             auto proxyMode = parseProxyCapabilities(*capabilities.proxy, &proxySettings);
>+#if ENABLE(2022_GLIB_API)
>+            webkit_network_session_set_proxy_settings(networkSession, proxyMode, proxySettings);
>+#else
>             webkit_website_data_manager_set_network_proxy_settings(webkit_web_context_get_website_data_manager(webContext), proxyMode, proxySettings);
>+#endif
>             if (proxySettings)
>                 webkit_network_proxy_settings_free(proxySettings);
>         }
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitNavigationClient.cpp b/Source/WebKit/UIProcess/API/glib/WebKitNavigationClient.cpp
>index 45d4f4654c61..1c46b9b982f5 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitNavigationClient.cpp
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitNavigationClient.cpp
>@@ -34,6 +34,10 @@
> #include <wtf/glib/GUniquePtr.h>
> #include <wtf/text/CString.h>
> 
>+#if ENABLE(2022_GLIB_API)
>+#include "WebKitNetworkSessionPrivate.h"
>+#endif
>+
> using namespace WebKit;
> using namespace WebCore;
> 
>@@ -158,19 +162,31 @@ private:
>     void navigationActionDidBecomeDownload(WebPageProxy&, API::NavigationAction&, DownloadProxy& downloadProxy) override
>     {
>         auto download = webkitDownloadCreate(downloadProxy, m_webView);
>+#if ENABLE(2022_GLIB_API)
>+        webkitNetworkSessionDownloadStarted(webkit_web_view_get_network_session(m_webView), download.get());
>+#else
>         webkitWebContextDownloadStarted(webkit_web_view_get_context(m_webView), download.get());
>+#endif
>     }
> 
>     void navigationResponseDidBecomeDownload(WebPageProxy&, API::NavigationResponse&, DownloadProxy& downloadProxy) override
>     {
>         auto download = webkitDownloadCreate(downloadProxy, m_webView);
>+#if ENABLE(2022_GLIB_API)
>+        webkitNetworkSessionDownloadStarted(webkit_web_view_get_network_session(m_webView), download.get());
>+#else
>         webkitWebContextDownloadStarted(webkit_web_view_get_context(m_webView), download.get());
>+#endif
>     }
> 
>     void contextMenuDidCreateDownload(WebPageProxy&, DownloadProxy& downloadProxy) override
>     {
>         auto download = webkitDownloadCreate(downloadProxy, m_webView);
>+#if ENABLE(2022_GLIB_API)
>+        webkitNetworkSessionDownloadStarted(webkit_web_view_get_network_session(m_webView), download.get());
>+#else
>         webkitWebContextDownloadStarted(webkit_web_view_get_context(m_webView), download.get());
>+#endif
>     }
> 
>     WebKitWebView* m_webView;
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitNetworkSession.cpp b/Source/WebKit/UIProcess/API/glib/WebKitNetworkSession.cpp
>new file mode 100644
>index 000000000000..5d75967a34c8
>--- /dev/null
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitNetworkSession.cpp
>@@ -0,0 +1,654 @@
>+/*
>+ * Copyright (C) 2023 Igalia S.L.
>+ *
>+ * This library is free software; you can redistribute it and/or
>+ * modify it under the terms of the GNU Lesser General Public
>+ * License as published by the Free Software Foundation; either
>+ * version 2,1 of the License, or (at your option) any later version.
>+ *
>+ * This library is distributed in the hope that it will be useful,
>+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
>+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+ * Library General Public License for more details.
>+ *
>+ * You should have received a copy of the GNU Library General Public License
>+ * along with this library; see the file COPYING.LIB.  If not, write to
>+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
>+ * Boston, MA 02110-1301, USA.
>+ */
>+
>+#if ENABLE(2022_GLIB_API)
>+
>+#include "config.h"
>+#include "WebKitNetworkSession.h"
>+
>+#include "APIDownloadClient.h"
>+#include "FrameInfoData.h"
>+#include "NetworkProcessMessages.h"
>+#include "WebKitCookieManagerPrivate.h"
>+#include "WebKitDownloadPrivate.h"
>+#include "WebKitInitialize.h"
>+#include "WebKitMemoryPressureSettings.h"
>+#include "WebKitMemoryPressureSettingsPrivate.h"
>+#include "WebKitNetworkProxySettingsPrivate.h"
>+#include "WebKitPrivate.h"
>+#include "WebKitWebsiteDataManagerPrivate.h"
>+#include "WebProcessPool.h"
>+#include <glib/gi18n-lib.h>
>+#include <pal/HysteresisActivity.h>
>+#include <wtf/HashSet.h>
>+#include <wtf/glib/GRefPtr.h>
>+#include <wtf/glib/GUniquePtr.h>
>+#include <wtf/glib/WTFGType.h>
>+
>+using namespace WebKit;
>+
>+/**
>+ * WebKitNetworkSession:
>+ * @see_also: #WebKitWebContext, #WebKitWebsiteData
>+ *
>+ * Manages network configuration.
>+ *
>+ *
>+ * Since: 2.40
>+ */
>+
>+using namespace WebKit;
>+
>+enum {
>+    PROP_0,
>+
>+    PROP_DATA_DIRECTORY,
>+    PROP_CACHE_DIRECTORY,
>+    PROP_IS_EPHEMERAL,
>+
>+    N_PROPERTIES
>+};
>+
>+static GParamSpec* sObjProperties[N_PROPERTIES] = { nullptr, };
>+
>+enum {
>+    DOWNLOAD_STARTED,
>+
>+    LAST_SIGNAL
>+};
>+
>+static guint signals[LAST_SIGNAL] = { 0, };
>+
>+struct _WebKitNetworkSessionPrivate {
>+    _WebKitNetworkSessionPrivate()
>+        : dnsPrefetchHystereris([this](PAL::HysteresisState state) { if (state == PAL::HysteresisState::Stopped) dnsPrefetchedHosts.clear(); })
>+    {
>+    }
>+
>+    GRefPtr<WebKitWebsiteDataManager> websiteDataManager;
>+    GRefPtr<WebKitCookieManager> cookieManager;
>+    WebKitTLSErrorsPolicy tlsErrorsPolicy;
>+
>+    GUniquePtr<char> dataDirectory;
>+    GUniquePtr<char> cacheDirectory;
>+
>+    HashSet<String> dnsPrefetchedHosts;
>+    PAL::HysteresisActivity dnsPrefetchHystereris;
>+};
>+
>+WEBKIT_DEFINE_TYPE(WebKitNetworkSession, webkit_network_session, G_TYPE_OBJECT)
>+
>+static void webkitNetworkSessionGetProperty(GObject* object, guint propID, GValue* value, GParamSpec* paramSpec)
>+{
>+    WebKitNetworkSession* session = WEBKIT_NETWORK_SESSION(object);
>+
>+    switch (propID) {
>+    case PROP_IS_EPHEMERAL:
>+        g_value_set_boolean(value, webkit_network_session_is_ephemeral(session));
>+        break;
>+    default:
>+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, paramSpec);
>+    }
>+}
>+
>+static void webkitNetworkSessionSetProperty(GObject* object, guint propID, const GValue* value, GParamSpec* paramSpec)
>+{
>+    WebKitNetworkSession* session = WEBKIT_NETWORK_SESSION(object);
>+
>+    switch (propID) {
>+    case PROP_DATA_DIRECTORY:
>+        session->priv->dataDirectory.reset(g_value_dup_string(value));
>+        break;
>+    case PROP_CACHE_DIRECTORY:
>+        session->priv->cacheDirectory.reset(g_value_dup_string(value));
>+        break;
>+    case PROP_IS_EPHEMERAL:
>+        if (g_value_get_boolean(value))
>+            session->priv->websiteDataManager = adoptGRef(WEBKIT_WEBSITE_DATA_MANAGER(g_object_new(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, "is-ephemeral", TRUE, nullptr)));
>+        break;
>+    default:
>+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, paramSpec);
>+    }
>+}
>+
>+static void webkitNetworkSessionConstructed(GObject* object)
>+{
>+    G_OBJECT_CLASS(webkit_network_session_parent_class)->constructed(object);
>+
>+    WebKitNetworkSessionPrivate* priv = WEBKIT_NETWORK_SESSION(object)->priv;
>+    if (!priv->websiteDataManager)
>+        priv->websiteDataManager = adoptGRef(webkitWebsiteDataManagerCreate(WTFMove(priv->dataDirectory), WTFMove(priv->cacheDirectory)));
>+
>+    priv->tlsErrorsPolicy = WEBKIT_TLS_ERRORS_POLICY_FAIL;
>+    webkitWebsiteDataManagerGetDataStore(priv->websiteDataManager.get()).setIgnoreTLSErrors(false);
>+
>+    // Enable favicons by default.
>+    webkit_website_data_manager_set_favicons_enabled(priv->websiteDataManager.get(), TRUE);
>+}
>+
>+static void webkit_network_session_class_init(WebKitNetworkSessionClass* sessionClass)
>+{
>+    webkitInitialize();
>+
>+    GObjectClass* gObjectClass = G_OBJECT_CLASS(sessionClass);
>+    gObjectClass->get_property = webkitNetworkSessionGetProperty;
>+    gObjectClass->set_property = webkitNetworkSessionSetProperty;
>+    gObjectClass->constructed = webkitNetworkSessionConstructed;
>+
>+    /**
>+     * WebKitNetworkSession:data-directory:
>+     *
>+     * The base data directory used to create the #WebKitWebsiteDataManager. If %NULL, a default location will be used.
>+     *
>+     * Since: 2.40
>+     */
>+    sObjProperties[PROP_DATA_DIRECTORY] =
>+        g_param_spec_string(
>+            "data-directory",
>+            nullptr, nullptr,
>+            nullptr,
>+            static_cast<GParamFlags>(WEBKIT_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
>+
>+    /**
>+     * WebKitNetworkSession:cache-directory:
>+     *
>+     * The base caches directory used to create the #WebKitWebsiteDataManager. If %NULL, a default location will be used.
>+     *
>+     * Since: 2.40
>+     */
>+    sObjProperties[PROP_CACHE_DIRECTORY] =
>+        g_param_spec_string(
>+            "cache-directory",
>+            nullptr, nullptr,
>+            nullptr,
>+            static_cast<GParamFlags>(WEBKIT_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
>+
>+    /**
>+     * WebKitNetworkSession:is-ephemeral:
>+     *
>+     * Whether to create an ephermeral #WebKitWebsiteDataManager for the session.
>+     *
>+     * Since: 2.40
>+     */
>+    sObjProperties[PROP_IS_EPHEMERAL] =
>+        g_param_spec_boolean(
>+            "is-ephemeral",
>+            nullptr, nullptr,
>+            FALSE,
>+            static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
>+
>+    g_object_class_install_properties(gObjectClass, N_PROPERTIES, sObjProperties);
>+
>+    /**
>+     * WebKitNetworkSession::download-started:
>+     * @session: the #WebKitNetworkSession
>+     * @download: the #WebKitDownload associated with this event
>+     *
>+     * This signal is emitted when a new download request is made.
>+     *
>+     * Since: 2.40
>+     */
>+    signals[DOWNLOAD_STARTED] =
>+        g_signal_new("download-started",
>+            G_TYPE_FROM_CLASS(gObjectClass),
>+            G_SIGNAL_RUN_LAST,
>+            0, nullptr, nullptr,
>+            nullptr,
>+            G_TYPE_NONE, 1,
>+            WEBKIT_TYPE_DOWNLOAD);
>+}
>+
>+void webkitNetworkSessionDownloadStarted(WebKitNetworkSession* session, WebKitDownload* download)
>+{
>+    g_signal_emit(session, signals[DOWNLOAD_STARTED], 0, download);
>+}
>+
>+static gpointer createDefaultNetworkSession(gpointer)
>+{
>+    static GRefPtr<WebKitNetworkSession> session = adoptGRef(webkit_network_session_new(nullptr, nullptr));
>+    return session.get();
>+}
>+
>+/**
>+ * webkit_network_session_get_default:
>+ *
>+ * Get the default network session.
>+ * The default network session is created using webkit_network_session_new() and passing
>+ * %NULL as data and cache directories.
>+ *
>+ * Returns: (transfer none): a #WebKitNetworkSession
>+ *
>+ * Since: 2.40
>+ */
>+WebKitNetworkSession* webkit_network_session_get_default()
>+{
>+    static GOnce onceInit = G_ONCE_INIT;
>+    return WEBKIT_NETWORK_SESSION(g_once(&onceInit, createDefaultNetworkSession, nullptr));
>+}
>+
>+/**
>+ * webkit_network_session_new:
>+ * @data_directory: (nullable): a base directory for data, or %NULL
>+ * @cache_directrory: (nullable): a base direfctory for caches, or %NULL
>+ *
>+ * Creates a new #WebKitNetworkSession with a persistent #WebKitWebsiteDataManager.
>+ *
>+ * It must be passed as construction parameter of a #WebKitWebView.
>+ *
>+ * Returns: (transfer full): the newly created #WebKitNetworkSession
>+ *
>+ * Since: 2.40
>+ */
>+WebKitNetworkSession* webkit_network_session_new(const char* dataDirectory, const char* cacheDirectory)
>+{
>+    return WEBKIT_NETWORK_SESSION(g_object_new(WEBKIT_TYPE_NETWORK_SESSION, "data-directory", dataDirectory, "cache-directory", cacheDirectory, nullptr));
>+}
>+
>+/**
>+ * webkit_network_session_new_ephemeral:
>+ *
>+ * Creates a new #WebKitNetworkSession with an ephemeral #WebKitWebsiteDataManager.
>+ *
>+ *
>+ * Returns: (transfer full): a new ephemeral #WebKitNetworkSession.
>+ *
>+ * Since: 2.40
>+ */
>+WebKitNetworkSession* webkit_network_session_new_ephemeral()
>+{
>+    return WEBKIT_NETWORK_SESSION(g_object_new(WEBKIT_TYPE_NETWORK_SESSION, "is-ephemeral", TRUE, nullptr));
>+}
>+
>+/**
>+ * webkit_network_session_is_ephemeral:
>+ * @session: a #WebKitNetworkSession
>+ *
>+ * Get whether @session is ephemeral.
>+ * A #WebKitNetworkSession is ephemeral when its #WebKitWebsiteDataManager is ephemeral.
>+ * See #WebKitWebsiteDataManager:is-ephemeral for more details.
>+ *
>+ * Returns: %TRUE if @session is pehmeral, or %FALSE otherwise
>+ *
>+ * Since: 2.40
>+ */
>+gboolean webkit_network_session_is_ephemeral(WebKitNetworkSession* session)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_NETWORK_SESSION(session), FALSE);
>+
>+    return webkit_website_data_manager_is_ephemeral(session->priv->websiteDataManager.get());
>+}
>+
>+/**
>+ * webkit_network_session_get_website_data_manager:
>+ * @session: a #WebKitNetworkSession
>+ *
>+ * Get the #WebKitWebsiteDataManager of @session.
>+ *
>+ * Returns: (transfer none): a #WebKitWebsiteDataManager
>+ *
>+ * Since: 2.40
>+ */
>+WebKitWebsiteDataManager* webkit_network_session_get_website_data_manager(WebKitNetworkSession* session)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_NETWORK_SESSION(session), nullptr);
>+
>+    return session->priv->websiteDataManager.get();
>+}
>+
>+/**
>+ * webkit_network_session_get_cookie_manager:
>+ * @session: a #WebKitNetworkSession
>+ *
>+ * Get the #WebKitCookieManager of @session.
>+ *
>+ * Returns: (transfer none): a #WebKitCookieManager
>+ *
>+ * Since: 2.40
>+ */
>+WebKitCookieManager* webkit_network_session_get_cookie_manager(WebKitNetworkSession* session)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_NETWORK_SESSION(session), nullptr);
>+
>+    if (!session->priv->cookieManager)
>+        session->priv->cookieManager = adoptGRef(webkitCookieManagerCreate(session->priv->websiteDataManager.get()));
>+
>+    return session->priv->cookieManager.get();
>+}
>+
>+/**
>+ * webkit_network_session_set_itp_enabled:
>+ * @session: a #WebKitNetworkSession
>+ * @enabled: value to set
>+ *
>+ * Enable or disable Intelligent Tracking Prevention (ITP).
>+ *
>+ * When ITP is enabled resource load statistics
>+ * are collected and used to decide whether to allow or block third-party cookies and prevent user tracking.
>+ * Note that while ITP is enabled the accept policy %WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY is ignored and
>+ * %WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS is used instead. See also webkit_cookie_session_set_accept_policy().
>+ *
>+ * Since: 2.40
>+ */
>+void webkit_network_session_set_itp_enabled(WebKitNetworkSession* session, gboolean enabled)
>+{
>+    g_return_if_fail(WEBKIT_IS_NETWORK_SESSION(session));
>+
>+    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+    websiteDataStore.setTrackingPreventionEnabled(enabled);
>+}
>+
>+/**
>+ * webkit_network_session_get_itp_enabled:
>+ * @session: a #WebKitNetworkSession
>+ *
>+ * Get whether Intelligent Tracking Prevention (ITP) is enabled or not.
>+ *
>+ * Returns: %TRUE if ITP is enabled, or %FALSE otherwise.
>+ *
>+ * Since: 2.40
>+ */
>+gboolean webkit_network_session_get_itp_enabled(WebKitNetworkSession* session)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_NETWORK_SESSION(session), FALSE);
>+
>+    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+    return websiteDataStore.trackingPreventionEnabled();
>+}
>+
>+/**
>+ * webkit_network_session_set_persistent_credential_storage_enabled:
>+ * @session: a #WebKitNetworkSession
>+ * @enabled: value to set
>+ *
>+ * Enable or disable persistent credential storage.
>+ *
>+ * When enabled, which is the default for
>+ * non-ephemeral sessions, the network process will try to read and write HTTP authentiacation
>+ * credentials from persistent storage.
>+ *
>+ * Since: 2.40
>+ */
>+void webkit_network_session_set_persistent_credential_storage_enabled(WebKitNetworkSession* session, gboolean enabled)
>+{
>+    g_return_if_fail(WEBKIT_IS_NETWORK_SESSION(session));
>+
>+    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+    websiteDataStore.setPersistentCredentialStorageEnabled(enabled);
>+}
>+
>+/**
>+ * webkit_network_session_get_persistent_credential_storage_enabled:
>+ * @session: a #WebKitNetworkSession
>+ *
>+ * Get whether persistent credential storage is enabled or not.
>+ *
>+ * See also webkit_network_session_set_persistent_credential_storage_enabled().
>+ *
>+ * Returns: %TRUE if persistent credential storage is enabled, or %FALSE otherwise.
>+ *
>+ * Since: 2.40
>+ */
>+gboolean webkit_network_session_get_persistent_credential_storage_enabled(WebKitNetworkSession* session)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_NETWORK_SESSION(session), FALSE);
>+
>+    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+    return websiteDataStore.persistentCredentialStorageEnabled();
>+}
>+
>+/**
>+ * webkit_network_session_set_tls_errors_policy:
>+ * @session: a #WebKitNetworkSession
>+ * @policy: a #WebKitTLSErrorsPolicy
>+ *
>+ * Set the TLS errors policy of @session as @policy.
>+ *
>+ * Since: 2.40
>+ */
>+void webkit_network_session_set_tls_errors_policy(WebKitNetworkSession* session, WebKitTLSErrorsPolicy policy)
>+{
>+    g_return_if_fail(WEBKIT_IS_NETWORK_SESSION(session));
>+
>+    if (session->priv->tlsErrorsPolicy == policy)
>+        return;
>+
>+    session->priv->tlsErrorsPolicy = policy;
>+    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+    websiteDataStore.setIgnoreTLSErrors(policy == WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+}
>+
>+/**
>+ * webkit_network_session_get_tls_errors_policy:
>+ * @session: a #WebKitNetworkSession
>+ *
>+ * Get the TLS errors policy of @session.
>+ *
>+ * Returns: a #WebKitTLSErrorsPolicy
>+ *
>+ * Since: 2.40
>+ */
>+WebKitTLSErrorsPolicy webkit_network_session_get_tls_errors_policy(WebKitNetworkSession* session)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_NETWORK_SESSION(session), WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+
>+    return session->priv->tlsErrorsPolicy;
>+}
>+
>+/**
>+ * webkit_network_session_allow_tls_certificate_for_host:
>+ * @session: a #WebKitNetworkSession
>+ * @certificate: a #GTlsCertificate
>+ * @host: the host for which a certificate is to be allowed
>+ *
>+ * Ignore further TLS errors on the @host for the certificate present in @info.
>+ *
>+ * Since: 2.40
>+ */
>+void webkit_network_session_allow_tls_certificate_for_host(WebKitNetworkSession* session, GTlsCertificate* certificate, const char* host)
>+{
>+    g_return_if_fail(WEBKIT_IS_NETWORK_SESSION(session));
>+    g_return_if_fail(G_IS_TLS_CERTIFICATE(certificate));
>+    g_return_if_fail(host);
>+
>+    auto certificateInfo = WebCore::CertificateInfo(certificate, static_cast<GTlsCertificateFlags>(0));
>+    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+    websiteDataStore.allowSpecificHTTPSCertificateForHost(certificateInfo, String::fromUTF8(host));
>+}
>+
>+/**
>+ * webkit_network_session_set_proxy_settings:
>+ * @session: a #WebKitNetworkSession
>+ * @proxy_mode: a #WebKitNetworkProxyMode
>+ * @proxy_settings: (allow-none): a #WebKitNetworkProxySettings, or %NULL
>+ *
>+ * Set the network proxy settings to be used by connections started in @session session.
>+ *
>+ * By default %WEBKIT_NETWORK_PROXY_MODE_DEFAULT is used, which means that the
>+ * system settings will be used (g_proxy_resolver_get_default()).
>+ * If you want to override the system default settings, you can either use
>+ * %WEBKIT_NETWORK_PROXY_MODE_NO_PROXY to make sure no proxies are used at all,
>+ * or %WEBKIT_NETWORK_PROXY_MODE_CUSTOM to provide your own proxy settings.
>+ * When @proxy_mode is %WEBKIT_NETWORK_PROXY_MODE_CUSTOM @proxy_settings must be
>+ * a valid #WebKitNetworkProxySettings; otherwise, @proxy_settings must be %NULL.
>+ *
>+ * Since: 2.40
>+ */
>+void webkit_network_session_set_proxy_settings(WebKitNetworkSession* session, WebKitNetworkProxyMode proxyMode, WebKitNetworkProxySettings* proxySettings)
>+{
>+    g_return_if_fail(WEBKIT_IS_NETWORK_SESSION(session));
>+    g_return_if_fail((proxyMode != WEBKIT_NETWORK_PROXY_MODE_CUSTOM && !proxySettings) || (proxyMode == WEBKIT_NETWORK_PROXY_MODE_CUSTOM && proxySettings));
>+
>+    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+    switch (proxyMode) {
>+    case WEBKIT_NETWORK_PROXY_MODE_DEFAULT:
>+        websiteDataStore.setNetworkProxySettings({ });
>+        break;
>+    case WEBKIT_NETWORK_PROXY_MODE_NO_PROXY:
>+        websiteDataStore.setNetworkProxySettings(WebCore::SoupNetworkProxySettings(WebCore::SoupNetworkProxySettings::Mode::NoProxy));
>+        break;
>+    case WEBKIT_NETWORK_PROXY_MODE_CUSTOM:
>+        auto settings = webkitNetworkProxySettingsGetNetworkProxySettings(proxySettings);
>+        if (settings.isEmpty()) {
>+            g_warning("Invalid attempt to set custom network proxy settings with an empty WebKitNetworkProxySettings. Use "
>+                "WEBKIT_NETWORK_PROXY_MODE_NO_PROXY to not use any proxy or WEBKIT_NETWORK_PROXY_MODE_DEFAULT to use the default system settings");
>+        } else
>+            websiteDataStore.setNetworkProxySettings(WTFMove(settings));
>+        break;
>+    }
>+}
>+
>+/**
>+ * webkit_network_session_set_memory_pressure_settings:
>+ * @settings: a WebKitMemoryPressureSettings.
>+ *
>+ * Sets @settings as the #WebKitMemoryPressureSettings.
>+ *
>+ * Sets @settings as the #WebKitMemoryPressureSettings to be used by the network
>+ * process created by any instance of #WebKitNetworkSession after this function
>+ * is called.
>+ *
>+ * Be sure to call this function before creating any #WebKitNetworkSession.
>+ *
>+ * The periodic check for used memory is disabled by default on network processes. This will
>+ * be enabled only if custom settings have been set using this function. After that, in order
>+ * to remove the custom settings and disable the periodic check, this function must be called
>+ * passing %NULL as the value of @settings.
>+ *
>+ * Since: 2.40
>+ */
>+void webkit_network_session_set_memory_pressure_settings(WebKitMemoryPressureSettings* settings)
>+{
>+    std::optional<MemoryPressureHandler::Configuration> config = settings ? std::make_optional(webkitMemoryPressureSettingsGetMemoryPressureHandlerConfiguration(settings)) : std::nullopt;
>+    WebProcessPool::setNetworkProcessMemoryPressureHandlerConfiguration(config);
>+}
>+
>+/**
>+ * webkit_network_session_get_itp_summary:
>+ * @session: a #WebKitNetworkSession
>+ * @cancellable: (allow-none): a #GCancellable or %NULL to ignore
>+ * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
>+ * @user_data: (closure): the data to pass to callback function
>+ *
>+ * Asynchronously get the list of #WebKitITPThirdParty seen for @session.
>+ *
>+ * Every #WebKitITPThirdParty
>+ * contains the list of #WebKitITPFirstParty under which it has been seen.
>+ *
>+ * When the operation is finished, @callback will be called. You can then call
>+ * webkit_network_session_get_itp_summary_finish() to get the result of the operation.
>+ *
>+ * Since: 2.40
>+ */
>+void webkit_network_session_get_itp_summary(WebKitNetworkSession* session, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
>+{
>+    g_return_if_fail(WEBKIT_IS_NETWORK_SESSION(session));
>+
>+    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+    GRefPtr<GTask> task = adoptGRef(g_task_new(session, cancellable, callback, userData));
>+    websiteDataStore.getResourceLoadStatisticsDataSummary([task = WTFMove(task)](Vector<WebResourceLoadStatisticsStore::ThirdPartyData>&& thirdPartyList) {
>+        GList* result = nullptr;
>+        while (!thirdPartyList.isEmpty())
>+            result = g_list_prepend(result, webkitITPThirdPartyCreate(thirdPartyList.takeLast()));
>+        g_task_return_pointer(task.get(), result, [](gpointer data) {
>+            g_list_free_full(static_cast<GList*>(data), reinterpret_cast<GDestroyNotify>(webkit_itp_third_party_unref));
>+        });
>+    });
>+}
>+
>+/**
>+ * webkit_network_session_get_itp_summary_finish:
>+ * @session: a #WebKitNetworkSession
>+ * @result: a #GAsyncResult
>+ * @error: return location for error or %NULL to ignore
>+ *
>+ * Finish an asynchronous operation started with webkit_network_session_get_itp_summary().
>+ *
>+ * Returns: (transfer full) (element-type WebKitITPThirdParty): a #GList of #WebKitITPThirdParty.
>+ *    You must free the #GList with g_list_free() and unref the #WebKitITPThirdPartys with
>+ *    webkit_itp_third_party_unref() when you're done with them.
>+ *
>+ * Since: 2.40
>+ */
>+GList* webkit_network_session_get_itp_summary_finish(WebKitNetworkSession* session, GAsyncResult* result, GError** error)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_NETWORK_SESSION(session), nullptr);
>+    g_return_val_if_fail(g_task_is_valid(result, session), nullptr);
>+
>+    return static_cast<GList*>(g_task_propagate_pointer(G_TASK(result), error));
>+}
>+
>+/**
>+ * webkit_network_session_prefetch_dns:
>+ * @session: a #WebKitNetworkSession
>+ * @hostname: a hostname to be resolved
>+ *
>+ * Resolve the domain name of the given @hostname in advance, so that if a URI
>+ * of @hostname is requested the load will be performed more quickly.
>+ *
>+ * Since: 2.40
>+ */
>+void webkit_network_session_prefetch_dns(WebKitNetworkSession* session, const char* hostname)
>+{
>+    g_return_if_fail(WEBKIT_IS_NETWORK_SESSION(session));
>+    g_return_if_fail(hostname);
>+
>+    if (session->priv->dnsPrefetchedHosts.add(String::fromUTF8(hostname)).isNewEntry) {
>+        auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+        websiteDataStore.networkProcess().send(Messages::NetworkProcess::PrefetchDNS(String::fromUTF8(hostname)), 0);
>+    }
>+    session->priv->dnsPrefetchHystereris.impulse();
>+}
>+
>+/**
>+ * webkit_network_session_download_uri:
>+ * @session: a #WebKitNetworkSession
>+ * @uri: the URI to download
>+ *
>+ * Requests downloading of the specified URI string.
>+ *
>+ * The download operation will not be associated to any #WebKitWebView,
>+ * if you are interested in starting a download from a particular #WebKitWebView use
>+ * webkit_web_view_download_uri() instead.
>+ *
>+ * Returns: (transfer full): a new #WebKitDownload representing
>+ *    the download operation.
>+ *
>+ * Since: 2.40
>+ */
>+WebKitDownload* webkit_network_session_download_uri(WebKitNetworkSession* session, const char* uri)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_NETWORK_SESSION(session), nullptr);
>+    g_return_val_if_fail(uri, nullptr);
>+
>+    WebCore::ResourceRequest request(String::fromUTF8(uri));
>+    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(session->priv->websiteDataManager.get());
>+    auto& downloadProxy = websiteDataStore.createDownloadProxy(adoptRef(*new API::DownloadClient), request, nullptr, { });
>+    auto download = webkitDownloadCreate(downloadProxy);
>+    downloadProxy.setDidStartCallback([session = GRefPtr<WebKitNetworkSession> { session }, download = download.get()](auto* downloadProxy) {
>+        if (!downloadProxy)
>+            return;
>+
>+	webkitDownloadStarted(download);
>+        webkitNetworkSessionDownloadStarted(session.get(), download);
>+    });
>+    websiteDataStore.download(downloadProxy, { });
>+    return download.leakRef();
>+}
>+
>+#endif // ENABLE(2022_GLIB_API)
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitNetworkSession.h.in b/Source/WebKit/UIProcess/API/glib/WebKitNetworkSession.h.in
>new file mode 100644
>index 000000000000..822c394cbdb4
>--- /dev/null
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitNetworkSession.h.in
>@@ -0,0 +1,133 @@
>+/*
>+ * Copyright (C) 2023 Igalia S.L.
>+ *
>+ * This library is free software; you can redistribute it and/or
>+ * modify it under the terms of the GNU Lesser General Public
>+ * License as published by the Free Software Foundation; either
>+ * version 2,1 of the License, or (at your option) any later version.
>+ *
>+ * This library is distributed in the hope that it will be useful,
>+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
>+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+ * Library General Public License for more details.
>+ *
>+ * You should have received a copy of the GNU Library General Public License
>+ * along with this library; see the file COPYING.LIB.  If not, write to
>+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
>+ * Boston, MA 02110-1301, USA.
>+ */
>+
>+@API_SINGLE_HEADER_CHECK@
>+
>+#ifndef WebKitNetworkSession_h
>+#define WebKitNetworkSession_h
>+
>+#include <gio/gio.h>
>+#include <@API_INCLUDE_PREFIX@/WebKitCookieManager.h>
>+#include <@API_INCLUDE_PREFIX@/WebKitDefines.h>
>+#include <@API_INCLUDE_PREFIX@/WebKitDownload.h>
>+#include <@API_INCLUDE_PREFIX@/WebKitMemoryPressureSettings.h>
>+#include <@API_INCLUDE_PREFIX@/WebKitNetworkProxySettings.h>
>+#include <@API_INCLUDE_PREFIX@/WebKitWebsiteDataManager.h>
>+
>+G_BEGIN_DECLS
>+
>+#define WEBKIT_TYPE_NETWORK_SESSION            (webkit_network_session_get_type())
>+#define WEBKIT_NETWORK_SESSION(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), WEBKIT_TYPE_NETWORK_SESSION, WebKitNetworkSession))
>+#define WEBKIT_IS_NETWORK_SESSION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), WEBKIT_TYPE_NETWORK_SESSION))
>+#define WEBKIT_NETWORK_SESSION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass),  WEBKIT_TYPE_NETWORK_SESSION, WebKitNetworkSessionClass))
>+#define WEBKIT_IS_NETWORK_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),  WEBKIT_TYPE_NETWORK_SESSION))
>+#define WEBKIT_NETWORK_SESSION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj),  WEBKIT_TYPE_NETWORK_SESSION, WebKitNetworkSessionClass))
>+
>+typedef struct _WebKitNetworkSession        WebKitNetworkSession;
>+typedef struct _WebKitNetworkSessionClass   WebKitNetworkSessionClass;
>+typedef struct _WebKitNetworkSessionPrivate WebKitNetworkSessionPrivate;
>+
>+struct _WebKitNetworkSession {
>+    GObject parent;
>+
>+    /*< private >*/
>+    WebKitNetworkSessionPrivate *priv;
>+};
>+
>+struct _WebKitNetworkSessionClass {
>+    GObjectClass parent_class;
>+
>+    /*< private >*/
>+    void (*_webkit_reserved0) (void);
>+    void (*_webkit_reserved1) (void);
>+    void (*_webkit_reserved2) (void);
>+    void (*_webkit_reserved3) (void);
>+};
>+
>+WEBKIT_API GType
>+webkit_network_session_get_type                                  (void);
>+
>+WEBKIT_API WebKitNetworkSession *
>+webkit_network_session_get_default                               (void);
>+
>+WEBKIT_API WebKitNetworkSession *
>+webkit_network_session_new                                       (const char                   *data_directory,
>+                                                                  const char                   *cache_directrory);
>+WEBKIT_API WebKitNetworkSession *
>+webkit_network_session_new_ephemeral                             (void);
>+
>+WEBKIT_API gboolean
>+webkit_network_session_is_ephemeral                              (WebKitNetworkSession         *session);
>+
>+WEBKIT_API WebKitWebsiteDataManager *
>+webkit_network_session_get_website_data_manager                  (WebKitNetworkSession         *session);
>+
>+WEBKIT_API WebKitCookieManager *
>+webkit_network_session_get_cookie_manager                        (WebKitNetworkSession         *session);
>+
>+WEBKIT_API void
>+webkit_network_session_set_itp_enabled                           (WebKitNetworkSession         *session,
>+                                                                  gboolean                      enabled);
>+
>+WEBKIT_API gboolean
>+webkit_network_session_get_itp_enabled                           (WebKitNetworkSession         *session);
>+
>+WEBKIT_API void
>+webkit_network_session_set_persistent_credential_storage_enabled (WebKitNetworkSession         *session,
>+                                                                  gboolean                      enabled);
>+
>+WEBKIT_API gboolean
>+webkit_network_session_get_persistent_credential_storage_enabled (WebKitNetworkSession         *session);
>+
>+WEBKIT_API void
>+webkit_network_session_set_tls_errors_policy                     (WebKitNetworkSession         *session,
>+                                                                  WebKitTLSErrorsPolicy         policy);
>+
>+WEBKIT_API WebKitTLSErrorsPolicy
>+webkit_network_session_get_tls_errors_policy                     (WebKitNetworkSession         *session);
>+
>+WEBKIT_API void
>+webkit_network_session_allow_tls_certificate_for_host            (WebKitNetworkSession         *session,
>+                                                                  GTlsCertificate              *certificate,
>+                                                                  const char                   *host);
>+
>+WEBKIT_API void
>+webkit_network_session_set_proxy_settings                        (WebKitNetworkSession         *session,
>+                                                                  WebKitNetworkProxyMode        proxy_mode,
>+                                                                  WebKitNetworkProxySettings   *proxy_settings);
>+
>+WEBKIT_API void
>+webkit_network_session_set_memory_pressure_settings              (WebKitMemoryPressureSettings *settings);
>+
>+WEBKIT_API void
>+webkit_network_session_get_itp_summary                           (WebKitNetworkSession         *session,
>+                                                                  GCancellable                 *cancellable,
>+                                                                  GAsyncReadyCallback           callback,
>+                                                                  gpointer                      user_data);
>+WEBKIT_API GList *
>+webkit_network_session_get_itp_summary_finish                    (WebKitNetworkSession         *session,
>+                                                                  GAsyncResult                 *result,
>+                                                                  GError                      **error);
>+WEBKIT_API WebKitDownload *
>+webkit_network_session_download_uri                              (WebKitNetworkSession         *session,
>+                                                                  const char                   *uri);
>+
>+G_END_DECLS
>+
>+#endif
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitNetworkSessionPrivate.h b/Source/WebKit/UIProcess/API/glib/WebKitNetworkSessionPrivate.h
>new file mode 100644
>index 000000000000..cb01ee8f8052
>--- /dev/null
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitNetworkSessionPrivate.h
>@@ -0,0 +1,25 @@
>+/*
>+ * Copyright (C) 2015 Igalia S.L.
>+ *
>+ * This library is free software; you can redistribute it and/or
>+ * modify it under the terms of the GNU Library General Public
>+ * License as published by the Free Software Foundation; either
>+ * version 2 of the License, or (at your option) any later version.
>+ *
>+ * This library is distributed in the hope that it will be useful,
>+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
>+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+ * Library General Public License for more details.
>+ *
>+ * You should have received a copy of the GNU Library General Public License
>+ * along with this library; see the file COPYING.LIB.  If not, write to
>+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
>+ * Boston, MA 02110-1301, USA.
>+ */
>+
>+#pragma once
>+
>+#include "WebKitDownload.h"
>+#include "WebKitNetworkSession.h"
>+
>+void webkitNetworkSessionDownloadStarted(WebKitNetworkSession*, WebKitDownload*);
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp b/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp
>index 1511de724111..1ad985f1ca1b 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp
>@@ -80,6 +80,10 @@
> #include "WebKitRemoteInspectorProtocolHandler.h"
> #endif
> 
>+#if ENABLE(2022_GLIB_API)
>+#include "WebKitNetworkSession.h"
>+#endif
>+
> using namespace WebKit;
> 
> /**
>@@ -117,7 +121,9 @@ enum {
> #if PLATFORM(GTK) && !USE(GTK4)
>     PROP_LOCAL_STORAGE_DIRECTORY,
> #endif
>+#if !ENABLE(2022_GLIB_API)
>     PROP_WEBSITE_DATA_MANAGER,
>+#endif
> #if PLATFORM(GTK) && !USE(GTK4)
>     PROP_PSON_ENABLED,
>     PROP_USE_SYSTEM_APPEARANCE_FOR_SCROLLBARS,
>@@ -130,7 +136,9 @@ enum {
> static GParamSpec* sObjProperties[N_PROPERTIES] = { nullptr, };
> 
> enum {
>+#if !ENABLE(2022_GLIB_API)
>     DOWNLOAD_STARTED,
>+#endif
>     INITIALIZE_WEB_EXTENSIONS,
>     INITIALIZE_NOTIFICATION_PERMISSIONS,
>     AUTOMATION_STARTED,
>@@ -199,10 +207,12 @@ typedef HashMap<String, RefPtr<WebKitURISchemeHandler> > URISchemeHandlerMap;
> class WebKitAutomationClient;
> 
> struct _WebKitWebContextPrivate {
>+#if !ENABLE(2022_GLIB_API)
>     _WebKitWebContextPrivate()
>         : dnsPrefetchHystereris([this](PAL::HysteresisState state) { if (state == PAL::HysteresisState::Stopped) dnsPrefetchedHosts.clear(); })
>     {
>     }
>+#endif
> 
>     RefPtr<WebProcessPool> processPool;
>     bool clientsDetached;
>@@ -211,14 +221,17 @@ struct _WebKitWebContextPrivate {
>     bool useSystemAppearanceForScrollbars;
> #endif
> 
>+#if !ENABLE(2022_GLIB_API)
>     GRefPtr<WebKitFaviconDatabase> faviconDatabase;
>+    CString faviconDatabaseDirectory;
>+#endif
>     GRefPtr<WebKitSecurityManager> securityManager;
>     URISchemeHandlerMap uriSchemeHandlers;
>     GRefPtr<WebKitGeolocationManager> geolocationManager;
>     std::unique_ptr<WebKitNotificationProvider> notificationProvider;
>+#if !ENABLE(2022_GLIB_API)
>     GRefPtr<WebKitWebsiteDataManager> websiteDataManager;
>-
>-    CString faviconDatabaseDirectory;
>+#endif
> 
>     HashMap<WebPageProxyIdentifier, WebKitWebView*> webViews;
> 
>@@ -232,11 +245,16 @@ struct _WebKitWebContextPrivate {
> #endif
>     std::unique_ptr<WebKitAutomationClient> automationClient;
>     GRefPtr<WebKitAutomationSession> automationSession;
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitNetworkSession> automationNetworkSession;
>+#endif
> #endif
>     std::unique_ptr<WebKitProtocolHandler> webkitProtocolHandler;
> 
>+#if !ENABLE(2022_GLIB_API)
>     HashSet<String> dnsPrefetchedHosts;
>     PAL::HysteresisActivity dnsPrefetchHystereris;
>+#endif
> 
>     WebKitMemoryPressureSettings* memoryPressureSettings;
> 
>@@ -296,7 +314,17 @@ void webkitWebContextWillCloseAutomationSession(WebKitWebContext* webContext)
> {
>     webContext->priv->processPool->setAutomationSession(nullptr);
>     webContext->priv->automationSession = nullptr;
>+    webContext->priv->automationNetworkSession = nullptr;
> }
>+
>+#if ENABLE(2022_GLIB_API)
>+WebKitNetworkSession* webkitWebContextGetNetworkSessionForAutomation(WebKitWebContext* webContext)
>+{
>+    if (!webContext->priv->automationNetworkSession && webContext->priv->automationClient)
>+        webContext->priv->automationNetworkSession = adoptGRef(webkit_network_session_new_ephemeral());
>+    return webContext->priv->automationNetworkSession.get();
>+}
>+#endif
> #endif // ENABLE(REMOTE_INSPECTOR)
> 
> WEBKIT_DEFINE_TYPE(WebKitWebContext, webkit_web_context, G_TYPE_OBJECT)
>@@ -335,9 +363,11 @@ static void webkitWebContextGetProperty(GObject* object, guint propID, GValue* v
>         g_value_set_string(value, context->priv->localStorageDirectory.data());
>         break;
> #endif
>+#if !ENABLE(2022_GLIB_API)
>     case PROP_WEBSITE_DATA_MANAGER:
>         g_value_set_object(value, webkit_web_context_get_website_data_manager(context));
>         break;
>+#endif
> #if PLATFORM(GTK) && !USE(GTK4)
>     case PROP_PSON_ENABLED:
>         g_value_set_boolean(value, context->priv->psonEnabled);
>@@ -364,11 +394,13 @@ static void webkitWebContextSetProperty(GObject* object, guint propID, const GVa
>         context->priv->localStorageDirectory = g_value_get_string(value);
>         break;
> #endif
>+#if !ENABLE(2022_GLIB_API)
>     case PROP_WEBSITE_DATA_MANAGER: {
>         gpointer manager = g_value_get_object(value);
>         context->priv->websiteDataManager = manager ? WEBKIT_WEBSITE_DATA_MANAGER(manager) : nullptr;
>         break;
>     }
>+#endif
> #if PLATFORM(GTK) && !USE(GTK4)
>     case PROP_PSON_ENABLED:
>         context->priv->psonEnabled = g_value_get_boolean(value);
>@@ -418,13 +450,10 @@ static void webkitWebContextConstructed(GObject* object)
>     }
>     configuration.setTimeZoneOverride(String::fromUTF8(priv->timeZoneOverride.data(), priv->timeZoneOverride.length()));
> 
>-    if (!priv->websiteDataManager) {
>-        priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new(
> #if !ENABLE(2022_GLIB_API)
>-                    "local-storage-directory", priv->localStorageDirectory.data(),
>+    if (!priv->websiteDataManager)
>+        priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new("local-storage-directory", priv->localStorageDirectory.data(), nullptr));
> #endif
>-        nullptr));
>-    }
> 
>     priv->processPool = WebProcessPool::create(configuration);
>     priv->processPool->setUserMessageHandler([webContext](UserMessage&& message, CompletionHandler<void(UserMessage&&)>&& completionHandler) {
>@@ -461,10 +490,12 @@ static void webkitWebContextDispose(GObject* object)
>         priv->processPool->setInjectedBundleClient(nullptr);
>     }
> 
>+#if !ENABLE(2022_GLIB_API)
>     if (priv->faviconDatabase) {
>         webkitFaviconDatabaseClose(priv->faviconDatabase.get());
>         priv->faviconDatabase = nullptr;
>     }
>+#endif
> 
>     if (priv->processPool) {
>         priv->processPool->setUserMessageHandler(nullptr);
>@@ -508,6 +539,7 @@ static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass
>             static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
> #endif
> 
>+#if !ENABLE(2022_GLIB_API)
>     /**
>      * WebKitWebContext:website-data-manager:
>      *
>@@ -521,6 +553,7 @@ static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass
>             nullptr, nullptr,
>             WEBKIT_TYPE_WEBSITE_DATA_MANAGER,
>             static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
>+#endif
> 
> #if PLATFORM(GTK) && !USE(GTK4)
>     /**
>@@ -599,6 +632,7 @@ static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass
> 
>     g_object_class_install_properties(gObjectClass, N_PROPERTIES, sObjProperties);
> 
>+#if !ENABLE(2022_GLIB_API)
>     /**
>      * WebKitWebContext::download-started:
>      * @context: the #WebKitWebContext
>@@ -615,6 +649,7 @@ static void webkit_web_context_class_init(WebKitWebContextClass* webContextClass
>             g_cclosure_marshal_VOID__OBJECT,
>             G_TYPE_NONE, 1,
>             WEBKIT_TYPE_DOWNLOAD);
>+#endif
> 
>     /**
>      * WebKitWebContext::initialize-web-extensions:
>@@ -741,6 +776,7 @@ WebKitWebContext* webkit_web_context_new(void)
>     return WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT, nullptr));
> }
> 
>+#if !ENABLE(2022_GLIB_API)
> /**
>  * webkit_web_context_new_ephemeral:
>  *
>@@ -813,6 +849,7 @@ gboolean webkit_web_context_is_ephemeral(WebKitWebContext* context)
> 
>     return webkit_website_data_manager_is_ephemeral(context->priv->websiteDataManager.get());
> }
>+#endif
> 
> /**
>  * webkit_web_context_is_automation_allowed:
>@@ -951,6 +988,7 @@ WebKitCacheModel webkit_web_context_get_cache_model(WebKitWebContext* context)
>     return WEBKIT_CACHE_MODEL_WEB_BROWSER;
> }
> 
>+#if !ENABLE(2022_GLIB_API)
> /**
>  * webkit_web_context_clear_cache:
>  * @context: a #WebKitWebContext
>@@ -970,7 +1008,6 @@ void webkit_web_context_clear_cache(WebKitWebContext* context)
>     websiteDataStore.removeData(websiteDataTypes, -WallTime::infinity(), [] { });
> }
> 
>-#if !ENABLE(2022_GLIB_API)
> /**
>  * webkit_web_context_set_network_proxy_settings:
>  * @context: a #WebKitWebContext
>@@ -997,7 +1034,6 @@ void webkit_web_context_set_network_proxy_settings(WebKitWebContext* context, We
> 
>     webkit_website_data_manager_set_network_proxy_settings(context->priv->websiteDataManager.get(), proxyMode, proxySettings);
> }
>-#endif
> 
> /**
>  * webkit_web_context_download_uri:
>@@ -1046,6 +1082,7 @@ WebKitCookieManager* webkit_web_context_get_cookie_manager(WebKitWebContext* con
> 
>     return webkit_website_data_manager_get_cookie_manager(context->priv->websiteDataManager.get());
> }
>+#endif
> 
> /**
>  * webkit_web_context_get_geolocation_manager:
>@@ -1064,6 +1101,7 @@ WebKitGeolocationManager* webkit_web_context_get_geolocation_manager(WebKitWebCo
>     return context->priv->geolocationManager.get();
> }
> 
>+#if !ENABLE(2022_GLIB_API)
> static void ensureFaviconDatabase(WebKitWebContext* context)
> {
>     WebKitWebContextPrivate* priv = context->priv;
>@@ -1165,6 +1203,7 @@ WebKitFaviconDatabase* webkit_web_context_get_favicon_database(WebKitWebContext*
>     ensureFaviconDatabase(context);
>     return context->priv->faviconDatabase.get();
> }
>+#endif
> 
> /**
>  * webkit_web_context_get_security_manager:
>@@ -1652,6 +1691,7 @@ void webkit_web_context_set_disk_cache_directory(WebKitWebContext*, const char*)
> }
> #endif
> 
>+#if !ENABLE(2022_GLIB_API)
> /**
>  * webkit_web_context_prefetch_dns:
>  * @context: a #WebKitWebContext
>@@ -1667,8 +1707,10 @@ void webkit_web_context_prefetch_dns(WebKitWebContext* context, const char* host
>     g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));
>     g_return_if_fail(hostname);
> 
>-    auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(context->priv->websiteDataManager.get());
>-    websiteDataStore.networkProcess().send(Messages::NetworkProcess::PrefetchDNS(String::fromUTF8(hostname)), 0);
>+    if (context->priv->dnsPrefetchedHosts.add(hostname).isNewEntry) {
>+        auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(context->priv->websiteDataManager.get());
>+        websiteDataStore.networkProcess().send(Messages::NetworkProcess::PrefetchDNS(String::fromUTF8(hostname)), 0);
>+    }
>     context->priv->dnsPrefetchHystereris.impulse();
> }
> 
>@@ -1692,6 +1734,7 @@ void webkit_web_context_allow_tls_certificate_for_host(WebKitWebContext* context
>     auto& websiteDataStore = webkitWebsiteDataManagerGetDataStore(context->priv->websiteDataManager.get());
>     websiteDataStore.allowSpecificHTTPSCertificateForHost(certificateInfo, String::fromUTF8(host));
> }
>+#endif
> 
> #if !ENABLE(2022_GLIB_API)
> /**
>@@ -1914,10 +1957,12 @@ void webkitWebContextInitializeNotificationPermissions(WebKitWebContext* context
>     g_signal_emit(context, signals[INITIALIZE_NOTIFICATION_PERMISSIONS], 0);
> }
> 
>+#if !ENABLE(2022_GLIB_API)
> void webkitWebContextDownloadStarted(WebKitWebContext* context, WebKitDownload* download)
> {
>     g_signal_emit(context, signals[DOWNLOAD_STARTED], 0, download);
> }
>+#endif
> 
> GVariant* webkitWebContextInitializeWebExtensions(WebKitWebContext* context)
> {
>@@ -1955,8 +2000,10 @@ void webkitWebContextCreatePageForWebView(WebKitWebContext* context, WebKitWebVi
>         pageConfiguration->setOverrideContentSecurityPolicy(String::fromUTF8(defaultContentSecurityPolicy));
> 
>     WebKitWebsiteDataManager* manager = webkitWebViewGetWebsiteDataManager(webView);
>+#if !ENABLE(2022_GLIB_API)
>     if (!manager)
>         manager = context->priv->websiteDataManager.get();
>+#endif
>     pageConfiguration->setWebsiteDataStore(&webkitWebsiteDataManagerGetDataStore(manager));
>     pageConfiguration->setDefaultWebsitePolicies(webkitWebsitePoliciesGetWebsitePolicies(defaultWebsitePolicies));
>     webkitWebViewCreatePage(webView, WTFMove(pageConfiguration));
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.h.in b/Source/WebKit/UIProcess/API/glib/WebKitWebContext.h.in
>index e4b38b2b4a12..f390e37c9eb5 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitWebContext.h.in
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitWebContext.h.in
>@@ -27,7 +27,9 @@
> #include <@API_INCLUDE_PREFIX@/WebKitCookieManager.h>
> #include <@API_INCLUDE_PREFIX@/WebKitDefines.h>
> #include <@API_INCLUDE_PREFIX@/WebKitDownload.h>
>+#if !ENABLE(2022_GLIB_API)
> #include <@API_INCLUDE_PREFIX@/WebKitFaviconDatabase.h>
>+#endif
> #include <@API_INCLUDE_PREFIX@/WebKitGeolocationManager.h>
> #include <@API_INCLUDE_PREFIX@/WebKitNetworkProxySettings.h>
> #include <@API_INCLUDE_PREFIX@/WebKitSecurityManager.h>
>@@ -140,6 +142,7 @@ webkit_web_context_get_default                      (void);
> WEBKIT_API WebKitWebContext *
> webkit_web_context_new                              (void);
> 
>+#if !ENABLE(2022_GLIB_API)
> WEBKIT_API WebKitWebContext *
> webkit_web_context_new_ephemeral                    (void);
> 
>@@ -151,6 +154,7 @@ webkit_web_context_get_website_data_manager         (WebKitWebContext
> 
> WEBKIT_API gboolean
> webkit_web_context_is_ephemeral                     (WebKitWebContext              *context);
>+#endif
> 
> WEBKIT_API gboolean
> webkit_web_context_is_automation_allowed            (WebKitWebContext              *context);
>@@ -173,15 +177,14 @@ WEBKIT_DEPRECATED guint
> webkit_web_context_get_web_process_count_limit      (WebKitWebContext              *context);
> #endif
> 
>+#if !ENABLE(2022_GLIB_API)
> WEBKIT_API void
> webkit_web_context_clear_cache                      (WebKitWebContext              *context);
> 
>-#if !ENABLE(2022_GLIB_API)
> WEBKIT_DEPRECATED_FOR(webkit_website_data_manager_set_network_proxy_settings) void
> webkit_web_context_set_network_proxy_settings       (WebKitWebContext              *context,
>                                                      WebKitNetworkProxyMode         proxy_mode,
>                                                      WebKitNetworkProxySettings    *proxy_settings);
>-#endif
> 
> WEBKIT_API WebKitDownload *
> webkit_web_context_download_uri                     (WebKitWebContext              *context,
>@@ -189,10 +192,12 @@ webkit_web_context_download_uri                     (WebKitWebContext
> 
> WEBKIT_API WebKitCookieManager *
> webkit_web_context_get_cookie_manager               (WebKitWebContext              *context);
>+#endif
> 
> WEBKIT_API WebKitGeolocationManager *
> webkit_web_context_get_geolocation_manager          (WebKitWebContext              *context);
> 
>+#if !ENABLE(2022_GLIB_API)
> WEBKIT_API WebKitFaviconDatabase *
> webkit_web_context_get_favicon_database             (WebKitWebContext              *context);
> 
>@@ -201,6 +206,7 @@ webkit_web_context_set_favicon_database_directory   (WebKitWebContext
>                                                      const gchar                   *path);
> WEBKIT_API const gchar *
> webkit_web_context_get_favicon_database_directory   (WebKitWebContext              *context);
>+#endif
> 
> WEBKIT_API WebKitSecurityManager *
> webkit_web_context_get_security_manager             (WebKitWebContext              *context);
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitWebContextPrivate.h b/Source/WebKit/UIProcess/API/glib/WebKitWebContextPrivate.h
>index 53ce35471211..aa7e660ae619 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitWebContextPrivate.h
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitWebContextPrivate.h
>@@ -31,8 +31,14 @@
> #include "WebProcessPool.h"
> #include <WebCore/ResourceRequest.h>
> 
>+#if ENABLE(2022_GLIB_API)
>+#include "WebKitNetworkSession.h"
>+#endif
>+
> WebKit::WebProcessPool& webkitWebContextGetProcessPool(WebKitWebContext*);
>+#if !ENABLE(2022_GLIB_API)
> void webkitWebContextDownloadStarted(WebKitWebContext*, WebKitDownload*);
>+#endif
> void webkitWebContextCreatePageForWebView(WebKitWebContext*, WebKitWebView*, WebKitUserContentManager*, WebKitWebView*, WebKitWebsitePolicies*);
> void webkitWebContextWebViewDestroyed(WebKitWebContext*, WebKitWebView*);
> WebKitWebView* webkitWebContextGetWebViewForPage(WebKitWebContext*, WebKit::WebPageProxy*);
>@@ -40,4 +46,7 @@ GVariant* webkitWebContextInitializeWebExtensions(WebKitWebContext*);
> void webkitWebContextInitializeNotificationPermissions(WebKitWebContext*);
> #if ENABLE(REMOTE_INSPECTOR)
> void webkitWebContextWillCloseAutomationSession(WebKitWebContext*);
>+#if ENABLE(2022_GLIB_API)
>+WebKitNetworkSession* webkitWebContextGetNetworkSessionForAutomation(WebKitWebContext*);
>+#endif
> #endif
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp b/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp
>index 231e20fe6bf8..2fd9c0a35f82 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitWebView.cpp
>@@ -102,6 +102,10 @@
> #include "WebKitWebViewClient.h"
> #endif
> 
>+#if ENABLE(2022_GLIB_API)
>+#include "WebKitNetworkSessionPrivate.h"
>+#endif
>+
> using namespace WebKit;
> using namespace WebCore;
> 
>@@ -187,6 +191,9 @@ enum {
>     PROP_RELATED_VIEW,
>     PROP_SETTINGS,
>     PROP_USER_CONTENT_MANAGER,
>+#if ENABLE(2022_GLIB_API)
>+    PROP_NETWORK_SESSION,
>+#endif
>     PROP_TITLE,
>     PROP_ESTIMATED_LOAD_PROGRESS,
> 
>@@ -198,7 +205,9 @@ enum {
>     PROP_ZOOM_LEVEL,
>     PROP_IS_LOADING,
>     PROP_IS_PLAYING_AUDIO,
>+#if !ENABLE(2022_GLIB_API)
>     PROP_IS_EPHEMERAL,
>+#endif
>     PROP_IS_CONTROLLED_BY_AUTOMATION,
>     PROP_AUTOMATION_PRESENTATION_TYPE,
>     PROP_EDITABLE,
>@@ -273,7 +282,9 @@ struct _WebKitWebViewPrivate {
>     CString activeURI;
>     bool isActiveURIChangeBlocked;
>     bool isLoading;
>+#if !ENABLE(2022_GLIB_API)
>     bool isEphemeral;
>+#endif
>     bool isControlledByAutomation;
>     WebKitAutomationBrowsingContextPresentation automationPresentationType;
> 
>@@ -312,7 +323,11 @@ struct _WebKitWebViewPrivate {
> 
>     GRefPtr<WebKitAuthenticationRequest> authenticationRequest;
> 
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitNetworkSession> networkSession;
>+#else
>     GRefPtr<WebKitWebsiteDataManager> websiteDataManager;
>+#endif
>     GRefPtr<WebKitWebsitePolicies> websitePolicies;
> 
>     CString defaultContentSecurityPolicy;
>@@ -581,6 +596,15 @@ static void userAgentChanged(WebKitSettings* settings, GParamSpec*, WebKitWebVie
>     getPage(webView).setCustomUserAgent(String::fromUTF8(webkit_settings_get_user_agent(settings)));
> }
> 
>+static gboolean webkitWebViewIsEphemeral(WebKitWebView* webView)
>+{
>+#if ENABLE(2022_GLIB_API)
>+    return webkit_network_session_is_ephemeral(webView->priv->networkSession.get());
>+#else
>+    return webView->priv->isEphemeral;
>+#endif
>+}
>+
> #if PLATFORM(GTK)
> static void enableBackForwardNavigationGesturesChanged(WebKitSettings* settings, GParamSpec*, WebKitWebView* webView)
> {
>@@ -619,14 +643,26 @@ static void gotFaviconCallback(GObject* object, GAsyncResult* result, gpointer u
>     webView->priv->faviconCancellable = 0;
> }
> 
>+static WebKitFaviconDatabase* webkitWebViewGetFaviconDatabase(WebKitWebView* webView)
>+{
>+#if ENABLE(2022_GLIB_API)
>+    return webkit_website_data_manager_get_favicon_database(webkitWebViewGetWebsiteDataManager(webView));
>+#else
>+    return webkit_web_context_get_favicon_database(priv->context.get());
>+#endif
>+}
>+
> static void webkitWebViewRequestFavicon(WebKitWebView* webView)
> {
>     webkitWebViewCancelFaviconRequest(webView);
> 
>     WebKitWebViewPrivate* priv = webView->priv;
>+    auto* database = webkitWebViewGetFaviconDatabase(webView);
>+    if (!database)
>+        return;
>+
>     priv->faviconCancellable = adoptGRef(g_cancellable_new());
>-    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context.get());
>-    webkitFaviconDatabaseGetFaviconInternal(database, priv->activeURI.data(), priv->isEphemeral, priv->faviconCancellable.get(), gotFaviconCallback, webView);
>+    webkitFaviconDatabaseGetFaviconInternal(database, priv->activeURI.data(), webkitWebViewIsEphemeral(webView), priv->faviconCancellable.get(), gotFaviconCallback, webView);
> }
> 
> static void webkitWebViewUpdateFaviconURI(WebKitWebView* webView, const char* faviconURI)
>@@ -701,16 +737,11 @@ static void webkitWebViewWatchForChangesInFavicon(WebKitWebView* webView)
>     if (priv->faviconChangedHandlerID)
>         return;
> 
>-    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context.get());
>-    priv->faviconChangedHandlerID = g_signal_connect(database, "favicon-changed", G_CALLBACK(faviconChangedCallback), webView);
>-}
>+    auto* database = webkitWebViewGetFaviconDatabase(webView);
>+    if (!database)
>+        return;
> 
>-static void webkitWebViewDisconnectFaviconDatabaseSignalHandlers(WebKitWebView* webView)
>-{
>-    WebKitWebViewPrivate* priv = webView->priv;
>-    if (priv->faviconChangedHandlerID)
>-        g_signal_handler_disconnect(webkit_web_context_get_favicon_database(priv->context.get()), priv->faviconChangedHandlerID);
>-    priv->faviconChangedHandlerID = 0;
>+    priv->faviconChangedHandlerID = g_signal_connect_object(database, "favicon-changed", G_CALLBACK(faviconChangedCallback), webView, G_CONNECT_DEFAULT);
> }
> #endif
> 
>@@ -722,12 +753,17 @@ static void webkitWebViewConstructed(GObject* object)
>     WebKitWebViewPrivate* priv = webView->priv;
>     if (priv->relatedView) {
>         priv->context = webkit_web_view_get_context(priv->relatedView);
>+        priv->networkSession = webkit_web_view_get_network_session(priv->relatedView);
>+#if !ENABLE(2022_GLIB_API)
>         priv->isEphemeral = webkit_web_view_is_ephemeral(priv->relatedView);
>+#endif
>         priv->isControlledByAutomation = webkit_web_view_is_controlled_by_automation(priv->relatedView);
>     } else if (!priv->context)
>         priv->context = webkit_web_context_get_default();
>+#if !ENABLE(2022_GLIB_API)
>     else if (!priv->isEphemeral)
>         priv->isEphemeral = webkit_web_context_is_ephemeral(priv->context.get());
>+#endif
> 
>     if (!priv->settings)
>         priv->settings = adoptGRef(webkit_settings_new());
>@@ -735,6 +771,14 @@ static void webkitWebViewConstructed(GObject* object)
>     if (!priv->userContentManager)
>         priv->userContentManager = adoptGRef(webkit_user_content_manager_new());
> 
>+#if ENABLE(2022_GLIB_API)
>+#if ENABLE(REMOTE_INSPECTOR)
>+    if (priv->isControlledByAutomation)
>+        priv->networkSession = webkitWebContextGetNetworkSessionForAutomation(priv->context.get());
>+#endif
>+    if (!priv->networkSession)
>+        priv->networkSession = webkit_network_session_get_default();
>+#else
>     if (priv->isEphemeral && !webkit_web_context_is_ephemeral(priv->context.get())) {
>         priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new_ephemeral());
>         auto* contextDataManager = webkit_web_context_get_website_data_manager(priv->context.get());
>@@ -742,6 +786,7 @@ static void webkitWebViewConstructed(GObject* object)
>         auto proxySettings = webkitWebsiteDataManagerGetDataStore(contextDataManager).networkProxySettings();
>         webkitWebsiteDataManagerGetDataStore(priv->websiteDataManager.get()).setNetworkProxySettings(WTFMove(proxySettings));
>     }
>+#endif
> 
>     if (!priv->websitePolicies)
>         priv->websitePolicies = adoptGRef(webkit_website_policies_new());
>@@ -824,12 +869,21 @@ static void webkitWebViewSetProperty(GObject* object, guint propId, const GValue
>         webView->priv->userContentManager = userContentManager ? WEBKIT_USER_CONTENT_MANAGER(userContentManager) : nullptr;
>         break;
>     }
>+#if ENABLE(2022_GLIB_API)
>+    case PROP_NETWORK_SESSION: {
>+        gpointer networkSession = g_value_get_object(value);
>+        webView->priv->networkSession = networkSession ? WEBKIT_NETWORK_SESSION(networkSession) : nullptr;
>+        break;
>+    }
>+#endif
>     case PROP_ZOOM_LEVEL:
>         webkit_web_view_set_zoom_level(webView, g_value_get_double(value));
>         break;
>+#if !ENABLE(2022_GLIB_API)
>     case PROP_IS_EPHEMERAL:
>         webView->priv->isEphemeral = g_value_get_boolean(value);
>         break;
>+#endif
>     case PROP_IS_CONTROLLED_BY_AUTOMATION:
>         webView->priv->isControlledByAutomation = g_value_get_boolean(value);
>         break;
>@@ -884,6 +938,11 @@ static void webkitWebViewGetProperty(GObject* object, guint propId, GValue* valu
>     case PROP_USER_CONTENT_MANAGER:
>         g_value_set_object(value, webkit_web_view_get_user_content_manager(webView));
>         break;
>+#if ENABLE(2022_GLIB_API)
>+    case PROP_NETWORK_SESSION:
>+        g_value_set_object(value, webkit_web_view_get_network_session(webView));
>+        break;
>+#endif
>     case PROP_TITLE:
>         g_value_set_string(value, webView->priv->title.data());
>         break;
>@@ -907,9 +966,11 @@ static void webkitWebViewGetProperty(GObject* object, guint propId, GValue* valu
>     case PROP_IS_PLAYING_AUDIO:
>         g_value_set_boolean(value, webkit_web_view_is_playing_audio(webView));
>         break;
>+#if !ENABLE(2022_GLIB_API)
>     case PROP_IS_EPHEMERAL:
>         g_value_set_boolean(value, webkit_web_view_is_ephemeral(webView));
>         break;
>+#endif
>     case PROP_IS_CONTROLLED_BY_AUTOMATION:
>         g_value_set_boolean(value, webkit_web_view_is_controlled_by_automation(webView));
>         break;
>@@ -957,7 +1018,7 @@ static void webkitWebViewDispose(GObject* object)
> 
> #if PLATFORM(GTK)
>     webkitWebViewCancelFaviconRequest(webView);
>-    webkitWebViewDisconnectFaviconDatabaseSignalHandlers(webView);
>+    webView->priv->faviconChangedHandlerID = 0;
> #endif
> 
>     webkitWebViewDisconnectSettingsSignalHandlers(webView);
>@@ -1083,6 +1144,23 @@ static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass)
>             WEBKIT_TYPE_USER_CONTENT_MANAGER,
>             static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
> 
>+#if ENABLE(2022_GLIB_API)
>+    /**
>+     * WebKitWebView:network-session:
>+     *
>+     * The #WebKitNetworkSession of the view
>+     *
>+     * Since: 2.40
>+     */
>+    sObjProperties[PROP_NETWORK_SESSION]=
>+        g_param_spec_object(
>+            "network-session",
>+            _("WebView network session"),
>+            _("The WebKitNetworkSession of the view"),
>+            WEBKIT_TYPE_NETWORK_SESSION,
>+            static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
>+#endif
>+
>     /**
>      * WebKitWebView:title:
>      *
>@@ -1188,6 +1266,7 @@ static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass)
>             FALSE,
>             WEBKIT_PARAM_READABLE);
> 
>+#if !ENABLE(2022_GLIB_API)
>     /**
>      * WebKitWebView:is-ephemeral:
>      *
>@@ -1212,6 +1291,7 @@ static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass)
>             nullptr, nullptr,
>             FALSE,
>             static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
>+#endif
> 
>     /**
>      * WebKitWebView:is-controlled-by-automation:
>@@ -2334,9 +2414,10 @@ void webkitWebViewLoadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent)
>             g_object_notify_by_pspec(G_OBJECT(webView), sObjProperties[PROP_URI]);
>         }
> #if PLATFORM(GTK)
>-        WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(priv->context.get());
>-        GUniquePtr<char> faviconURI(webkit_favicon_database_get_favicon_uri(database, priv->activeURI.data()));
>-        webkitWebViewUpdateFaviconURI(webView, faviconURI.get());
>+        if (auto* database = webkitWebViewGetFaviconDatabase(webView)) {
>+            GUniquePtr<char> faviconURI(webkit_favicon_database_get_favicon_uri(database, priv->activeURI.data()));
>+            webkitWebViewUpdateFaviconURI(webView, faviconURI.get());
>+        }
> #endif
>         break;
>     }
>@@ -2363,8 +2444,12 @@ void webkitWebViewLoadFailedWithTLSErrors(WebKitWebView* webView, const char* fa
> {
>     webkitWebViewCompleteAuthenticationRequest(webView);
> 
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy tlsErrorsPolicy = webkit_network_session_get_tls_errors_policy(webView->priv->networkSession.get());
>+#else
>     auto* websiteDataManager = webkit_web_view_get_website_data_manager(webView);
>     WebKitTLSErrorsPolicy tlsErrorsPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>+#endif
>     if (tlsErrorsPolicy == WEBKIT_TLS_ERRORS_POLICY_FAIL) {
>         gboolean returnValue;
>         g_signal_emit(webView, signals[LOAD_FAILED_WITH_TLS_ERRORS], 0, failingURI, certificate, tlsErrors, &returnValue);
>@@ -2383,14 +2468,21 @@ void webkitWebViewGetLoadDecisionForIcon(WebKitWebView* webView, const LinkIcon&
>         completionHandler(false);
>         return;
>     }
>-    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(webView->priv->context.get());
>-    webkitFaviconDatabaseGetLoadDecisionForIcon(database, icon, getPage(webView).pageLoadState().activeURL(), webView->priv->isEphemeral, WTFMove(completionHandler));
>+
>+    auto* database = webkitWebViewGetFaviconDatabase(webView);
>+    if (!database)
>+        return;
>+
>+    webkitFaviconDatabaseGetLoadDecisionForIcon(database, icon, getPage(webView).pageLoadState().activeURL(), webkitWebViewIsEphemeral(webView), WTFMove(completionHandler));
> }
> 
> void webkitWebViewSetIcon(WebKitWebView* webView, const LinkIcon& icon, API::Data& iconData)
> {
>-    WebKitFaviconDatabase* database = webkit_web_context_get_favicon_database(webView->priv->context.get());
>-    webkitFaviconDatabaseSetIconForPageURL(database, icon, iconData, getPage(webView).pageLoadState().activeURL(), webView->priv->isEphemeral);
>+    auto* database = webkitWebViewGetFaviconDatabase(webView);
>+    if (!database)
>+        return;
>+
>+    webkitFaviconDatabaseSetIconForPageURL(database, icon, iconData, getPage(webView).pageLoadState().activeURL(), webkitWebViewIsEphemeral(webView));
> }
> #endif
> 
>@@ -2702,9 +2794,13 @@ void webkitWebViewSubmitFormRequest(WebKitWebView* webView, WebKitFormSubmission
> 
> void webkitWebViewHandleAuthenticationChallenge(WebKitWebView* webView, AuthenticationChallengeProxy* authenticationChallenge)
> {
>+#if ENABLE(2022_GLIB_API)
>+    bool credenialStorageEnabled = webkit_network_session_get_persistent_credential_storage_enabled(webView->priv->networkSession.get());
>+#else
>     auto* websiteDataManager = webkit_web_view_get_website_data_manager(webView);
>-    webView->priv->authenticationRequest = adoptGRef(webkitAuthenticationRequestCreate(authenticationChallenge,
>-        webView->priv->isEphemeral, webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager)));
>+    bool credenialStorageEnabled = webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager);
>+#endif
>+    webView->priv->authenticationRequest = adoptGRef(webkitAuthenticationRequestCreate(authenticationChallenge, webkitWebViewIsEphemeral(webView), credenialStorageEnabled));
>     gboolean returnValue;
>     g_signal_emit(webView, signals[AUTHENTICATE], 0, webView->priv->authenticationRequest.get(), &returnValue);
> }
>@@ -2740,7 +2836,11 @@ void webkitWebViewSelectionDidChange(WebKitWebView* webView)
> 
> WebKitWebsiteDataManager* webkitWebViewGetWebsiteDataManager(WebKitWebView* webView)
> {
>+#if ENABLE(2022_GLIB_API)
>+    return webkit_network_session_get_website_data_manager(webView->priv->networkSession.get());
>+#else
>     return webView->priv->websiteDataManager.get();
>+#endif
> }
> 
> #if PLATFORM(GTK)
>@@ -2888,6 +2988,7 @@ WebKitUserContentManager* webkit_web_view_get_user_content_manager(WebKitWebView
>     return webView->priv->userContentManager.get();
> }
> 
>+#if !ENABLE(2022_GLIB_API)
> /**
>  * webkit_web_view_is_ephemeral:
>  * @web_view: a #WebKitWebView
>@@ -2910,6 +3011,7 @@ gboolean webkit_web_view_is_ephemeral(WebKitWebView* webView)
> 
>     return webView->priv->isEphemeral;
> }
>+#endif
> 
> /**
>  * webkit_web_view_is_controlled_by_automation:
>@@ -2949,6 +3051,24 @@ WebKitAutomationBrowsingContextPresentation webkit_web_view_get_automation_prese
>     return webView->priv->automationPresentationType;
> }
> 
>+#if ENABLE(2022_GLIB_API)
>+/**
>+ * webkit_web_view_get_network_session:
>+ * @web_view: a #WebKitWebView
>+ *
>+ * Get the #WebKitNetworkSession associated to @web_view.
>+ *
>+ * Returns: (transfer none): a #WebKitNetworkSession
>+ *
>+ * Since: 2.40
>+ */
>+WebKitNetworkSession* webkit_web_view_get_network_session(WebKitWebView* webView)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), nullptr);
>+
>+    return webView->priv->networkSession.get();
>+}
>+#else
> /**
>  * webkit_web_view_get_website_data_manager:
>  * @web_view: a #WebKitWebView
>@@ -2972,6 +3092,7 @@ WebKitWebsiteDataManager* webkit_web_view_get_website_data_manager(WebKitWebView
> 
>     return webkit_web_context_get_website_data_manager(webView->priv->context.get());
> }
>+#endif
> 
> /**
>  * webkit_web_view_try_close:
>@@ -4414,12 +4535,20 @@ WebKitDownload* webkit_web_view_download_uri(WebKitWebView* webView, const char*
>     auto& page = getPage(webView);
>     auto& downloadProxy = page.process().processPool().download(page.websiteDataStore(), &page, ResourceRequest { String::fromUTF8(uri) });
>     auto download = webkitDownloadCreate(downloadProxy, webView);
>+#if ENABLE(2022_GLIB_API)
>+    downloadProxy.setDidStartCallback([session = GRefPtr<WebKitNetworkSession> { webView->priv->networkSession }, download = download.get()](auto* downloadProxy) {
>+#else
>     downloadProxy.setDidStartCallback([context = GRefPtr<WebKitWebContext> { webView->priv->context }, download = download.get()](auto* downloadProxy) {
>+#endif
>         if (!downloadProxy)
>             return;
> 
>         webkitDownloadStarted(download);
>+#if ENABLE(2022_GLIB_API)
>+        webkitNetworkSessionDownloadStarted(session.get(), download);
>+#else
>         webkitWebContextDownloadStarted(context.get(), download);
>+#endif
>     });
> 
>     return download.leakRef();
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitWebView.h.in b/Source/WebKit/UIProcess/API/glib/WebKitWebView.h.in
>index 6757af34b541..76f597e554e3 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitWebView.h.in
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitWebView.h.in
>@@ -54,6 +54,10 @@
> #include <@API_INCLUDE_PREFIX@/WebKitWebsitePolicies.h>
> #include <@API_INCLUDE_PREFIX@/WebKitWindowProperties.h>
> 
>+#if ENABLE(2022_GLIB_API)
>+#include <@API_INCLUDE_PREFIX@/WebKitNetworkSession.h>
>+#endif
>+
> #if PLATFORM(GTK)
> #include <JavaScriptCore/JSBase.h>
> #include <webkit/WebKitColorChooserRequest.h>
>@@ -432,8 +436,10 @@ WEBKIT_API WebKitWebViewBackend *
> webkit_web_view_get_backend                          (WebKitWebView             *web_view);
> #endif
> 
>+#if !ENABLE(2022_GLIB_API)
> WEBKIT_API gboolean
> webkit_web_view_is_ephemeral                         (WebKitWebView             *web_view);
>+#endif
> 
> WEBKIT_API gboolean
> webkit_web_view_is_controlled_by_automation          (WebKitWebView             *web_view);
>@@ -441,8 +447,13 @@ webkit_web_view_is_controlled_by_automation          (WebKitWebView
> WEBKIT_API WebKitAutomationBrowsingContextPresentation
> webkit_web_view_get_automation_presentation_type     (WebKitWebView             *web_view);
> 
>+#if ENABLE(2022_GLIB_API)
>+WEBKIT_API WebKitNetworkSession *
>+webkit_web_view_get_network_session                  (WebKitWebView             *web_view);
>+#else
> WEBKIT_API WebKitWebsiteDataManager *
> webkit_web_view_get_website_data_manager             (WebKitWebView             *web_view);
>+#endif
> 
> WEBKIT_API WebKitWebContext *
> webkit_web_view_get_context                          (WebKitWebView             *web_view);
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp b/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp
>index 33959349690d..2febc22f2f9b 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.cpp
>@@ -21,6 +21,7 @@
> #include "WebKitWebsiteDataManager.h"
> 
> #include "WebKitCookieManagerPrivate.h"
>+#include "WebKitFaviconDatabasePrivate.h"
> #include "WebKitInitialize.h"
> #include "WebKitMemoryPressureSettings.h"
> #include "WebKitMemoryPressureSettingsPrivate.h"
>@@ -94,11 +95,15 @@ struct _WebKitWebsiteDataManagerPrivate {
>     GUniquePtr<char> baseDataDirectory;
>     GUniquePtr<char> baseCacheDirectory;
> 
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitFaviconDatabase> faviconDatabase;
>+#endif
>+
>+#if !ENABLE(2022_GLIB_API)
>     WebKitTLSErrorsPolicy tlsErrorsPolicy;
> 
>     GRefPtr<WebKitCookieManager> cookieManager;
> 
>-#if !ENABLE(2022_GLIB_API)
>     // These manual directory overrides are deprecated. Please don't add more.
>     GUniquePtr<char> localStorageDirectory;
>     GUniquePtr<char> diskCacheDirectory;
>@@ -217,12 +222,12 @@ static void webkitWebsiteDataManagerSetProperty(GObject* object, guint propID, c
>     }
> }
> 
>+#if !ENABLE(2022_GLIB_API)
> static void webkitWebsiteDataManagerConstructed(GObject* object)
> {
>     G_OBJECT_CLASS(webkit_website_data_manager_parent_class)->constructed(object);
> 
>     WebKitWebsiteDataManagerPrivate* priv = WEBKIT_WEBSITE_DATA_MANAGER(object)->priv;
>-#if !ENABLE(2022_GLIB_API)
>     if (priv->baseDataDirectory) {
>         if (!priv->localStorageDirectory)
>             priv->localStorageDirectory.reset(g_build_filename(priv->baseDataDirectory.get(), "localstorage", nullptr));
>@@ -246,22 +251,23 @@ static void webkitWebsiteDataManagerConstructed(GObject* object)
>         if (!priv->domCacheDirectory)
>             priv->domCacheDirectory.reset(g_build_filename(priv->baseCacheDirectory.get(), "CacheStorage", nullptr));
>     }
>-#endif
> 
>     priv->tlsErrorsPolicy = WEBKIT_TLS_ERRORS_POLICY_FAIL;
>     if (priv->websiteDataStore)
>         priv->websiteDataStore->setIgnoreTLSErrors(false);
> }
>+#endif
> 
> static void webkit_website_data_manager_class_init(WebKitWebsiteDataManagerClass* findClass)
> {
>     webkitInitialize();
> 
>     GObjectClass* gObjectClass = G_OBJECT_CLASS(findClass);
>-
>     gObjectClass->get_property = webkitWebsiteDataManagerGetProperty;
>     gObjectClass->set_property = webkitWebsiteDataManagerSetProperty;
>+#if !ENABLE(2022_GLIB_API)
>     gObjectClass->constructed = webkitWebsiteDataManagerConstructed;
>+#endif
> 
>     /**
>      * WebKitWebsiteDataManager:base-data-directory:
>@@ -505,12 +511,23 @@ WebKit::WebsiteDataStore& webkitWebsiteDataManagerGetDataStore(WebKitWebsiteData
>             configuration->setCacheStorageDirectory(FileSystem::stringFromFileSystemRepresentation(priv->domCacheDirectory.get()));
> #endif
>         priv->websiteDataStore = WebKit::WebsiteDataStore::create(WTFMove(configuration), PAL::SessionID::generatePersistentSessionID());
>+#if !ENABLE(2022_GLIB_API)
>         priv->websiteDataStore->setIgnoreTLSErrors(priv->tlsErrorsPolicy == WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#endif
>     }
> 
>     return *priv->websiteDataStore;
> }
> 
>+#if ENABLE(2022_GLIB_API)
>+WebKitWebsiteDataManager* webkitWebsiteDataManagerCreate(GUniquePtr<char>&& baseDataDirectory, GUniquePtr<char>&& baseCacheDirectory)
>+{
>+    auto* manager = WEBKIT_WEBSITE_DATA_MANAGER(g_object_new(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, nullptr));
>+    manager->priv->baseDataDirectory = WTFMove(baseDataDirectory);
>+    manager->priv->baseCacheDirectory = WTFMove(baseCacheDirectory);
>+    return manager;
>+}
>+#else
> /**
>  * webkit_website_data_manager_new:
>  * @first_option_name: name of the first option to set
>@@ -549,6 +566,7 @@ WebKitWebsiteDataManager* webkit_website_data_manager_new_ephemeral()
> {
>     return WEBKIT_WEBSITE_DATA_MANAGER(g_object_new(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, "is-ephemeral", TRUE, nullptr));
> }
>+#endif
> 
> /**
>  * webkit_website_data_manager_is_ephemeral:
>@@ -838,7 +856,6 @@ const gchar* webkit_website_data_manager_get_dom_cache_directory(WebKitWebsiteDa
>         priv->domCacheDirectory.reset(g_strdup(WebKit::WebsiteDataStore::defaultCacheStorageDirectory().utf8().data()));
>     return priv->domCacheDirectory.get();
> }
>-#endif
> 
> /**
>  * webkit_website_data_manager_get_cookie_manager:
>@@ -1015,6 +1032,92 @@ void webkit_website_data_manager_set_network_proxy_settings(WebKitWebsiteDataMan
>         break;
>     }
> }
>+#endif
>+
>+#if ENABLE(2022_GLIB_API)
>+static String webkitWebsiteDataManagerGetFaviconDatabasePath(WebKitWebsiteDataManager* manager)
>+{
>+    if (webkit_website_data_manager_is_ephemeral(manager))
>+        return { };
>+
>+    if (manager->priv->baseCacheDirectory)
>+        return FileSystem::pathByAppendingComponents(FileSystem::stringFromFileSystemRepresentation(manager->priv->baseCacheDirectory.get()), { "icondatabase"_s, "WebpageIcons.db"_s });
>+
>+    auto programName = []() -> String {
>+        if (auto* prgname = g_get_prgname())
>+            return String::fromUTF8(prgname);
>+#if PLATFORM(GTK)
>+        return "webkitgtk"_s;
>+#elif PLATFORM(WPE)
>+        return "wpe"_s;
>+#endif
>+        RELEASE_ASSERT_NOT_REACHED();
>+    };
>+    return FileSystem::pathByAppendingComponents(FileSystem::userCacheDirectory(), { programName(), "icondatabase"_s, "WebpageIcons.db"_s });
>+}
>+
>+/**
>+ * webkit_website_data_manager_set_favicons_enabled:
>+ * @manager: a #WebKitWebsiteDataManager
>+ * @enabled: value to set
>+ *
>+ * Set whether website icons are enabled. Website icons are enabled by default.
>+ * When website icons are disabled, the #WebKitFaviconDatabase of @manager is closed
>+ * its reference removed, so webkit_website_data_manager_get_favicon_database() will
>+ * return %NULL. If website icons are enabled again, a new #WebKitFaviconDatabase will
>+ * be created.
>+ *
>+ * Since: 2.40
>+ */
>+void webkit_website_data_manager_set_favicons_enabled(WebKitWebsiteDataManager* manager, gboolean enabled)
>+{
>+    g_return_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
>+
>+    if (enabled) {
>+        if (!manager->priv->faviconDatabase)
>+            manager->priv->faviconDatabase = adoptGRef(webkitFaviconDatabaseCreate());
>+        auto path = webkitWebsiteDataManagerGetFaviconDatabasePath(manager);
>+        webkitFaviconDatabaseOpen(manager->priv->faviconDatabase.get(), path, path.isNull());
>+    } else if (manager->priv->faviconDatabase) {
>+        webkitFaviconDatabaseClose(manager->priv->faviconDatabase.get());
>+        manager->priv->faviconDatabase = nullptr;
>+    }
>+}
>+
>+/**
>+ * webkit_website_data_manager_get_favicons_enabled:
>+ * @manager: a #WebKitWebsiteDataManager
>+ *
>+ * Get whether website icons are enabled.
>+ *
>+ * Returns: %TRUE if website icons are enabled, or %FALSE otherwise.
>+ *
>+ * Since: 2.40
>+ */
>+gboolean webkit_website_data_manager_get_favicons_enabled(WebKitWebsiteDataManager* manager)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), FALSE);
>+
>+    return !!manager->priv->faviconDatabase;
>+}
>+
>+/**
>+ * webkit_website_data_manager_get_favicon_database:
>+ * @manager: a #WebKitWebsiteDataManager
>+ *
>+ * Get the #WebKitFaviconDatabase of @manager.
>+ *
>+ * Returns: (transfer none) (nullable): a #WebKitFaviconDatabase, or %NULL if website icons are disabled
>+ *
>+ * Since: 2.40
>+ */
>+WebKitFaviconDatabase* webkit_website_data_manager_get_favicon_database(WebKitWebsiteDataManager* manager)
>+{
>+    g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
>+
>+    return manager->priv->faviconDatabase.get();
>+}
>+#endif
> 
> static OptionSet<WebsiteDataType> toWebsiteDataTypes(WebKitWebsiteDataTypes types)
> {
>@@ -1247,6 +1350,7 @@ struct _WebKitITPFirstParty {
>     int referenceCount { 1 };
> };
> 
>+#if !ENABLE(2022_GLIB_API)
> /**
>  * webkit_website_data_manager_set_memory_pressure_settings:
>  * @settings: a WebKitMemoryPressureSettings.
>@@ -1272,6 +1376,7 @@ void webkit_website_data_manager_set_memory_pressure_settings(WebKitMemoryPressu
>     std::optional<MemoryPressureHandler::Configuration> config = settings ? std::make_optional(webkitMemoryPressureSettingsGetMemoryPressureHandlerConfiguration(settings)) : std::nullopt;
>     WebProcessPool::setNetworkProcessMemoryPressureHandlerConfiguration(config);
> }
>+#endif
> 
> G_DEFINE_BOXED_TYPE(WebKitITPFirstParty, webkit_itp_first_party, webkit_itp_first_party_ref, webkit_itp_first_party_unref)
> 
>@@ -1410,7 +1515,7 @@ struct _WebKitITPThirdParty {
> 
> G_DEFINE_BOXED_TYPE(WebKitITPThirdParty, webkit_itp_third_party, webkit_itp_third_party_ref, webkit_itp_third_party_unref)
> 
>-static WebKitITPThirdParty* webkitITPThirdPartyCreate(WebResourceLoadStatisticsStore::ThirdPartyData&& data)
>+WebKitITPThirdParty* webkitITPThirdPartyCreate(WebResourceLoadStatisticsStore::ThirdPartyData&& data)
> {
>     auto* thirdParty = static_cast<WebKitITPThirdParty*>(fastMalloc(sizeof(WebKitITPThirdParty)));
>     new (thirdParty) WebKitITPThirdParty(WTFMove(data));
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in b/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in
>index 4148722a769b..a4de5d560ea3 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManager.h.in
>@@ -25,6 +25,9 @@
> #include <gio/gio.h>
> #include <@API_INCLUDE_PREFIX@/WebKitCookieManager.h>
> #include <@API_INCLUDE_PREFIX@/WebKitDefines.h>
>+#if ENABLE(2022_GLIB_API)
>+#include <@API_INCLUDE_PREFIX@/WebKitFaviconDatabase.h>
>+#endif
> #include <@API_INCLUDE_PREFIX@/WebKitMemoryPressureSettings.h>
> #include <@API_INCLUDE_PREFIX@/WebKitNetworkProxySettings.h>
> #include <@API_INCLUDE_PREFIX@/WebKitWebsiteData.h>
>@@ -77,11 +80,13 @@ struct _WebKitWebsiteDataManagerClass {
> WEBKIT_API GType
> webkit_website_data_manager_get_type                                  (void);
> 
>+#if !ENABLE(2022_GLIB_API)
> WEBKIT_API WebKitWebsiteDataManager *
> webkit_website_data_manager_new                                       (const gchar              *first_option_name,
>                                                                        ...);
> WEBKIT_API WebKitWebsiteDataManager *
> webkit_website_data_manager_new_ephemeral                             (void);
>+#endif
> 
> WEBKIT_API gboolean
> webkit_website_data_manager_is_ephemeral                              (WebKitWebsiteDataManager* manager);
>@@ -92,6 +97,18 @@ webkit_website_data_manager_get_base_data_directory                   (WebKitWeb
> WEBKIT_API const gchar *
> webkit_website_data_manager_get_base_cache_directory                  (WebKitWebsiteDataManager *manager);
> 
>+#if ENABLE(2022_GLIB_API)
>+WEBKIT_API void
>+webkit_website_data_manager_set_favicons_enabled                      (WebKitWebsiteDataManager *manager,
>+                                                                       gboolean                  enabled);
>+
>+WEBKIT_API gboolean
>+webkit_website_data_manager_get_favicons_enabled                      (WebKitWebsiteDataManager *manager);
>+
>+WEBKIT_API WebKitFaviconDatabase *
>+webkit_website_data_manager_get_favicon_database                      (WebKitWebsiteDataManager *manager);
>+#endif
>+
> #if !ENABLE(2022_GLIB_API)
> WEBKIT_DEPRECATED const gchar *
> webkit_website_data_manager_get_local_storage_directory               (WebKitWebsiteDataManager *manager);
>@@ -119,7 +136,6 @@ webkit_website_data_manager_get_service_worker_registrations_directory(WebKitWeb
> 
> WEBKIT_DEPRECATED const gchar *
> webkit_website_data_manager_get_dom_cache_directory                   (WebKitWebsiteDataManager *manager);
>-#endif
> 
> WEBKIT_API WebKitCookieManager *
> webkit_website_data_manager_get_cookie_manager                        (WebKitWebsiteDataManager *manager);
>@@ -149,6 +165,7 @@ WEBKIT_API void
> webkit_website_data_manager_set_network_proxy_settings                (WebKitWebsiteDataManager *manager,
>                                                                        WebKitNetworkProxyMode    proxy_mode,
>                                                                        WebKitNetworkProxySettings *proxy_settings);
>+#endif
> 
> WEBKIT_API void
> webkit_website_data_manager_fetch                                     (WebKitWebsiteDataManager *manager,
>@@ -186,8 +203,10 @@ webkit_website_data_manager_clear_finish                               (WebKitWe
>                                                                         GAsyncResult             *result,
>                                                                         GError                  **error);
> 
>+#if !ENABLE(2022_GLIB_API)
> WEBKIT_API void
> webkit_website_data_manager_set_memory_pressure_settings               (WebKitMemoryPressureSettings *settings);
>+#endif
> 
> 
> #define WEBKIT_TYPE_ITP_FIRST_PARTY   (webkit_itp_first_party_get_type())
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManagerPrivate.h b/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManagerPrivate.h
>index fc9e8226fbb8..866acaa77006 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManagerPrivate.h
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitWebsiteDataManagerPrivate.h
>@@ -19,6 +19,12 @@
> 
> #pragma once
> 
>+#include "WebResourceLoadStatisticsStore.h"
> #include "WebsiteDataStore.h"
>+#include <wtf/glib/GUniquePtr.h>
> 
>+#if ENABLE(2022_GLIB_API)
>+WebKitWebsiteDataManager* webkitWebsiteDataManagerCreate(GUniquePtr<char>&&, GUniquePtr<char>&&);
>+#endif
> WebKit::WebsiteDataStore& webkitWebsiteDataManagerGetDataStore(WebKitWebsiteDataManager*);
>+WebKitITPThirdParty* webkitITPThirdPartyCreate(WebKit::WebResourceLoadStatisticsStore::ThirdPartyData&&);
>diff --git a/Source/WebKit/UIProcess/API/glib/webkit.h.in b/Source/WebKit/UIProcess/API/glib/webkit.h.in
>index 47b65bc7f0d1..358e65c095be 100644
>--- a/Source/WebKit/UIProcess/API/glib/webkit.h.in
>+++ b/Source/WebKit/UIProcess/API/glib/webkit.h.in
>@@ -76,6 +76,9 @@
> #include <@API_INCLUDE_PREFIX@/WebKitNavigationAction.h>
> #include <@API_INCLUDE_PREFIX@/WebKitNavigationPolicyDecision.h>
> #include <@API_INCLUDE_PREFIX@/WebKitNetworkProxySettings.h>
>+#if ENABLE(2022_GLIB_API)
>+#include <@API_INCLUDE_PREFIX@/WebKitNetworkSession.h>
>+#endif
> #include <@API_INCLUDE_PREFIX@/WebKitNotification.h>
> #include <@API_INCLUDE_PREFIX@/WebKitNotificationPermissionRequest.h>
> #include <@API_INCLUDE_PREFIX@/WebKitOptionMenu.h>
>diff --git a/Source/WebKit/UIProcess/API/gtk/WebKitWebViewGtk.cpp b/Source/WebKit/UIProcess/API/gtk/WebKitWebViewGtk.cpp
>index 10372de38d0b..0c04f1dddf92 100644
>--- a/Source/WebKit/UIProcess/API/gtk/WebKitWebViewGtk.cpp
>+++ b/Source/WebKit/UIProcess/API/gtk/WebKitWebViewGtk.cpp
>@@ -351,7 +351,9 @@ GtkWidget* webkit_web_view_new_with_context(WebKitWebContext* context)
>     g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), 0);
> 
>     return GTK_WIDGET(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>+#if !ENABLE(2022_GLIB_API)
>         "is-ephemeral", webkit_web_context_is_ephemeral(context),
>+#endif
>         "web-context", context,
>         nullptr));
> }
>diff --git a/Source/WebKit/UIProcess/API/wpe/WebKitWebViewWPE.cpp b/Source/WebKit/UIProcess/API/wpe/WebKitWebViewWPE.cpp
>index d4a381bde68b..46833f335566 100644
>--- a/Source/WebKit/UIProcess/API/wpe/WebKitWebViewWPE.cpp
>+++ b/Source/WebKit/UIProcess/API/wpe/WebKitWebViewWPE.cpp
>@@ -109,7 +109,9 @@ WebKitWebView* webkit_web_view_new_with_context(WebKitWebViewBackend* backend, W
> 
>     return WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>         "backend", backend,
>+#if !ENABLE(2022_GLIB_API)
>         "is-ephemeral", webkit_web_context_is_ephemeral(context),
>+#endif
>         "web-context", context,
>         nullptr));
> }
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>index 783ef7e47e40..dcbbd5043150 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>@@ -253,7 +253,7 @@ SOAuthorizationCoordinator& WebsiteDataStore::soAuthorizationCoordinator(const W
> 
> static Ref<NetworkProcessProxy> networkProcessForSession(PAL::SessionID sessionID)
> {
>-#if PLATFORM(GTK) || PLATFORM(WPE)
>+#if ((PLATFORM(GTK) || PLATFORM(WPE)) && !ENABLE(2022_GLIB_API))
>     if (sessionID.isEphemeral()) {
>         // Reuse a previous persistent session network process for ephemeral sessions.
>         for (auto* dataStore : allDataStores().values()) {
>diff --git a/Tools/MiniBrowser/gtk/BrowserTab.c b/Tools/MiniBrowser/gtk/BrowserTab.c
>index c02247aeeff6..8a79287f4420 100644
>--- a/Tools/MiniBrowser/gtk/BrowserTab.c
>+++ b/Tools/MiniBrowser/gtk/BrowserTab.c
>@@ -218,7 +218,11 @@ static void tlsErrorsDialogResponse(GtkWidget *dialog, gint response, BrowserTab
>         GTlsCertificate *certificate = (GTlsCertificate *)g_object_get_data(G_OBJECT(dialog), "certificate");
> #if SOUP_CHECK_VERSION(2, 91, 0)
>         GUri *uri = g_uri_parse(failingURI, SOUP_HTTP_URI_FLAGS, NULL);
>+#if GTK_CHECK_VERSION(3, 98, 5)
>+        webkit_network_session_allow_tls_certificate_for_host(webkit_web_view_get_network_session(tab->webView), certificate, g_uri_get_host(uri));
>+#else
>         webkit_web_context_allow_tls_certificate_for_host(webkit_web_view_get_context(tab->webView), certificate, g_uri_get_host(uri));
>+#endif
>         g_uri_unref(uri);
> #else
>         SoupURI *uri = soup_uri_new(failingURI);
>diff --git a/Tools/MiniBrowser/gtk/BrowserWindow.c b/Tools/MiniBrowser/gtk/BrowserWindow.c
>index 881609c9fe8f..37010032ffb9 100644
>--- a/Tools/MiniBrowser/gtk/BrowserWindow.c
>+++ b/Tools/MiniBrowser/gtk/BrowserWindow.c
>@@ -40,6 +40,9 @@ struct _BrowserWindow {
>     GtkApplicationWindow parent;
> 
>     WebKitWebContext *webContext;
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    WebKitNetworkSession *networkSession;
>+#endif
> 
>     GtkWidget *mainBox;
>     GtkWidget *toolbar;
>@@ -159,7 +162,11 @@ static void webViewTitleChanged(WebKitWebView *webView, GParamSpec *pspec, Brows
>     char *privateTitle = NULL;
>     if (webkit_web_view_is_controlled_by_automation(webView))
>         privateTitle = g_strdup_printf("[Automation] %s", title);
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    else if (webkit_network_session_is_ephemeral(webkit_web_view_get_network_session(webView)))
>+#else
>     else if (webkit_web_view_is_ephemeral(webView))
>+#endif
>         privateTitle = g_strdup_printf("[Private] %s", title);
>     gtk_window_set_title(GTK_WINDOW(window), privateTitle ? privateTitle : title);
>     g_free(privateTitle);
>@@ -185,9 +192,9 @@ static void webViewLoadProgressChanged(WebKitWebView *webView, GParamSpec *pspec
>     }
> }
> 
>+#if !GTK_CHECK_VERSION(3, 98, 0)
> static void downloadStarted(WebKitWebContext *webContext, WebKitDownload *download, BrowserWindow *window)
> {
>-#if !GTK_CHECK_VERSION(3, 98, 0)
>     if (!window->downloadsBar) {
>         window->downloadsBar = browser_downloads_bar_new();
>         gtk_box_pack_start(GTK_BOX(window->mainBox), window->downloadsBar, FALSE, FALSE, 0);
>@@ -196,8 +203,8 @@ static void downloadStarted(WebKitWebContext *webContext, WebKitDownload *downlo
>         gtk_widget_show(window->downloadsBar);
>     }
>     browser_downloads_bar_add_download(BROWSER_DOWNLOADS_BAR(window->downloadsBar), download);
>-#endif
> }
>+#endif
> 
> static void browserWindowHistoryItemActivated(BrowserWindow *window, GVariant *parameter, GAction *action)
> {
>@@ -458,7 +465,11 @@ static GtkWidget *webViewCreate(WebKitWebView *webView, WebKitNavigationAction *
>     WebKitWebView *newWebView = WEBKIT_WEB_VIEW(webkit_web_view_new_with_related_view(webView));
>     webkit_web_view_set_settings(newWebView, webkit_web_view_get_settings(webView));
> 
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext, window->networkSession);
>+#else
>     GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext);
>+#endif
>     gtk_window_set_application(GTK_WINDOW(newWindow), gtk_window_get_application(GTK_WINDOW(window)));
>     browser_window_append_view(BROWSER_WINDOW(newWindow), newWebView);
>     gtk_widget_grab_focus(GTK_WIDGET(newWebView));
>@@ -504,6 +515,9 @@ static gboolean webViewDecidePolicy(WebKitWebView *webView, WebKitPolicyDecision
>     /* Opening a new tab if link clicked with the middle button. */
>     WebKitWebView *newWebView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>         "web-context", webkit_web_view_get_context(webView),
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+        "network-session", webkit_web_view_get_network_session(webView),
>+#endif
>         "settings", webkit_web_view_get_settings(webView),
>         "user-content-manager", webkit_web_view_get_user_content_manager(webView),
>         "is-controlled-by-automation", webkit_web_view_is_controlled_by_automation(webView),
>@@ -756,6 +770,9 @@ static void newTabCallback(GSimpleAction *action, GVariant *parameter, gpointer
> 
>     browser_window_append_view(window, WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>         "web-context", webkit_web_view_get_context(webView),
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+        "network-session", window->networkSession,
>+#endif
>         "settings", webkit_web_view_get_settings(webView),
>         "user-content-manager", webkit_web_view_get_user_content_manager(webView),
>         "is-controlled-by-automation", webkit_web_view_is_controlled_by_automation(webView),
>@@ -774,15 +791,33 @@ static void openPrivateWindow(GSimpleAction *action, GVariant *parameter, gpoint
> {
>     BrowserWindow *window = BROWSER_WINDOW(userData);
>     WebKitWebView *webView = browser_tab_get_web_view(window->activeTab);
>+
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    WebKitNetworkSession *networkSession = NULL;
>+    if (!webkit_web_view_is_controlled_by_automation(webView)) {
>+        networkSession = webkit_network_session_new_ephemeral();
>+        webkit_network_session_set_tls_errors_policy(networkSession, webkit_network_session_get_tls_errors_policy(window->networkSession));
>+        // FIXME: we need public api to get proxy settings.
>+    }
>+#endif
>     WebKitWebView *newWebView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>         "web-context", webkit_web_view_get_context(webView),
>         "settings", webkit_web_view_get_settings(webView),
>         "user-content-manager", webkit_web_view_get_user_content_manager(webView),
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+        "network-session", networkSession,
>+#else
>         "is-ephemeral", TRUE,
>+#endif
>         "is-controlled-by-automation", webkit_web_view_is_controlled_by_automation(webView),
>         "website-policies", webkit_web_view_get_website_policies(webView),
>         NULL));
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext, networkSession);
>+    g_clear_object(&networkSession);
>+#else
>     GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext);
>+#endif
>     gtk_window_set_application(GTK_WINDOW(newWindow), gtk_window_get_application(GTK_WINDOW(window)));
>     browser_window_append_view(BROWSER_WINDOW(newWindow), newWebView);
>     gtk_widget_grab_focus(GTK_WIDGET(newWebView));
>@@ -962,6 +997,10 @@ static void browserWindowFinalize(GObject *gObject)
>     g_signal_handlers_disconnect_matched(window->webContext, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, window);
>     g_object_unref(window->webContext);
> 
>+#if GTK_CHECK_VERSION(3, 98, 5)
>+    g_clear_object(&window->networkSession);
>+#endif
>+
>     if (window->favicon) {
>         g_object_unref(window->favicon);
>         window->favicon = NULL;
>@@ -1461,7 +1500,11 @@ static void browser_window_class_init(BrowserWindowClass *klass)
> }
> 
> /* Public API. */
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+GtkWidget *browser_window_new(GtkWindow *parent, WebKitWebContext *webContext, WebKitNetworkSession *networkSession)
>+#else
> GtkWidget *browser_window_new(GtkWindow *parent, WebKitWebContext *webContext)
>+#endif
> {
>     g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(webContext), NULL);
> 
>@@ -1472,7 +1515,12 @@ GtkWidget *browser_window_new(GtkWindow *parent, WebKitWebContext *webContext)
>         NULL));
> 
>     window->webContext = g_object_ref(webContext);
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    window->networkSession = networkSession ? g_object_ref(networkSession) : NULL;
>+#else
>     g_signal_connect(window->webContext, "download-started", G_CALLBACK(downloadStarted), window);
>+#endif
>+
>     if (parent) {
>         window->parentWindow = parent;
>         g_object_add_weak_pointer(G_OBJECT(parent), (gpointer *)&window->parentWindow);
>@@ -1481,6 +1529,15 @@ GtkWidget *browser_window_new(GtkWindow *parent, WebKitWebContext *webContext)
>     return GTK_WIDGET(window);
> }
> 
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+WebKitNetworkSession* browser_window_get_network_session(BrowserWindow *window)
>+{
>+    g_return_val_if_fail(BROWSER_IS_WINDOW(window), NULL);
>+
>+    return window->networkSession;
>+}
>+#endif
>+
> WebKitWebContext *browser_window_get_web_context(BrowserWindow *window)
> {
>     g_return_val_if_fail(BROWSER_IS_WINDOW(window), NULL);
>@@ -1568,6 +1625,9 @@ void browser_window_load_session(BrowserWindow *window, const char *sessionFile)
>         if (!webView) {
>             webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>                 "web-context", webkit_web_view_get_context(previousWebView),
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+                "network-session", webkit_web_view_get_network_session(previousWebView),
>+#endif
>                 "settings", webkit_web_view_get_settings(previousWebView),
>                 "user-content-manager", webkit_web_view_get_user_content_manager(previousWebView),
>                 "website-policies", webkit_web_view_get_website_policies(previousWebView),
>@@ -1637,7 +1697,11 @@ WebKitWebView *browser_window_get_or_create_web_view_for_automation(BrowserWindo
>         "is-controlled-by-automation", TRUE,
>         "website-policies", webkit_web_view_get_website_policies(webView),
>         NULL));
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext, window->networkSession);
>+#else
>     GtkWidget *newWindow = browser_window_new(GTK_WINDOW(window), window->webContext);
>+#endif
>     gtk_window_set_application(GTK_WINDOW(newWindow), gtk_window_get_application(GTK_WINDOW(window)));
> #if !GTK_CHECK_VERSION(3, 98, 0)
>     gtk_window_set_focus_on_map(GTK_WINDOW(newWindow), FALSE);
>diff --git a/Tools/MiniBrowser/gtk/BrowserWindow.h b/Tools/MiniBrowser/gtk/BrowserWindow.h
>index 72831873d5fd..c58ebc2beec7 100644
>--- a/Tools/MiniBrowser/gtk/BrowserWindow.h
>+++ b/Tools/MiniBrowser/gtk/BrowserWindow.h
>@@ -50,7 +50,12 @@ typedef struct _BrowserWindowClass   BrowserWindowClass;
> 
> GType browser_window_get_type(void);
> 
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+GtkWidget* browser_window_new(GtkWindow*, WebKitWebContext*, WebKitNetworkSession*);
>+WebKitNetworkSession* browser_window_get_network_session(BrowserWindow*);
>+#else
> GtkWidget* browser_window_new(GtkWindow*, WebKitWebContext*);
>+#endif
> WebKitWebContext* browser_window_get_web_context(BrowserWindow*);
> void browser_window_append_view(BrowserWindow*, WebKitWebView*);
> void browser_window_load_uri(BrowserWindow*, const char *uri);
>diff --git a/Tools/MiniBrowser/gtk/main.c b/Tools/MiniBrowser/gtk/main.c
>index a436001f3e42..21726f0c39b4 100644
>--- a/Tools/MiniBrowser/gtk/main.c
>+++ b/Tools/MiniBrowser/gtk/main.c
>@@ -96,6 +96,9 @@ static WebKitWebView *createBrowserTab(BrowserWindow *window, WebKitSettings *we
> {
>     WebKitWebView *webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>         "web-context", browser_window_get_web_context(window),
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+        "network-session", browser_window_get_network_session(window),
>+#endif
>         "settings", webkitSettings,
>         "user-content-manager", userContentManager,
>         "is-controlled-by-automation", automationMode,
>@@ -354,7 +357,7 @@ static void websiteDataClearedCallback(WebKitWebsiteDataManager *manager, GAsync
>         webkit_web_view_reload(webkit_uri_scheme_request_get_web_view(dataRequest->request));
> }
> 
>-static void aboutDataScriptMessageReceivedCallback(WebKitUserContentManager *userContentManager, WebKitJavascriptResult *message, WebKitWebContext *webContext)
>+static void aboutDataScriptMessageReceivedCallback(WebKitUserContentManager *userContentManager, WebKitJavascriptResult *message, WebKitWebsiteDataManager *manager)
> {
>     char *messageString = jsc_value_to_string(webkit_javascript_result_get_js_value(message));
>     char **tokens = g_strsplit(messageString, ":", 3);
>@@ -373,7 +376,6 @@ static void aboutDataScriptMessageReceivedCallback(WebKitUserContentManager *use
>         return;
>     }
> 
>-    WebKitWebsiteDataManager *manager = webkit_web_context_get_website_data_manager(webContext);
>     guint64 types = g_ascii_strtoull(tokens[1], NULL, 10);
>     if (tokenCount == 2)
>         webkit_website_data_manager_clear(manager, types, 0, NULL, (GAsyncReadyCallback)websiteDataClearedCallback, dataRequest);
>@@ -475,10 +477,15 @@ static void gotWebsiteDataCallback(WebKitWebsiteDataManager *manager, GAsyncResu
>     g_list_free_full(dataList, (GDestroyNotify)webkit_website_data_unref);
> }
> 
>-static void aboutDataHandleRequest(WebKitURISchemeRequest *request, WebKitWebContext *webContext)
>+static void aboutDataHandleRequest(WebKitURISchemeRequest *request)
> {
>     AboutDataRequest *dataRequest = aboutDataRequestNew(request);
>-    WebKitWebsiteDataManager *manager = webkit_web_context_get_website_data_manager(webContext);
>+    WebKitWebView *webView = webkit_uri_scheme_request_get_web_view(request);
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    WebKitWebsiteDataManager *manager = webkit_network_session_get_website_data_manager(webkit_web_view_get_network_session(webView));
>+#else
>+    WebKitWebsiteDataManager *manager = webkit_web_view_get_website_data_manager(webView);
>+#endif
>     webkit_website_data_manager_fetch(manager, WEBKIT_WEBSITE_DATA_ALL, NULL, (GAsyncReadyCallback)gotWebsiteDataCallback, dataRequest);
> }
> 
>@@ -530,14 +537,19 @@ static void gotITPSummaryCallback(WebKitWebsiteDataManager *manager, GAsyncResul
>     aboutITPRequestFree(itpRequest);
> }
> 
>-static void aboutITPHandleRequest(WebKitURISchemeRequest *request, WebKitWebContext *webContext)
>+static void aboutITPHandleRequest(WebKitURISchemeRequest *request)
> {
>     AboutITPRequest *itpRequest = aboutITPRequestNew(request);
>-    WebKitWebsiteDataManager *manager = webkit_web_context_get_website_data_manager(webContext);
>+    WebKitWebView *webView = webkit_uri_scheme_request_get_web_view(request);
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    WebKitWebsiteDataManager *manager = webkit_network_session_get_website_data_manager(webkit_web_view_get_network_session(webView));
>+#else
>+    WebKitWebsiteDataManager *manager = webkit_web_view_get_website_data_manager(webView);
>+#endif
>     webkit_website_data_manager_get_itp_summary(manager, NULL, (GAsyncReadyCallback)gotITPSummaryCallback, itpRequest);
> }
> 
>-static void aboutURISchemeRequestCallback(WebKitURISchemeRequest *request, WebKitWebContext *webContext)
>+static void aboutURISchemeRequestCallback(WebKitURISchemeRequest *request, gpointer userData)
> {
>     GInputStream *stream;
>     gsize streamLength;
>@@ -557,9 +569,9 @@ static void aboutURISchemeRequestCallback(WebKitURISchemeRequest *request, WebKi
>         webkit_uri_scheme_request_finish(request, stream, streamLength, "text/html");
>         g_object_unref(stream);
>     } else if (!g_strcmp0(path, "data"))
>-        aboutDataHandleRequest(request, webContext);
>+        aboutDataHandleRequest(request);
>     else if (!g_strcmp0(path, "itp"))
>-        aboutITPHandleRequest(request, webContext);
>+        aboutITPHandleRequest(request);
>     else {
>         error = g_error_new(MINI_BROWSER_ERROR, MINI_BROWSER_ERROR_INVALID_ABOUT_PATH, "Invalid about:%s page.", path);
>         webkit_uri_scheme_request_finish_error(request, error);
>@@ -660,6 +672,46 @@ static void startup(GApplication *application)
> 
> static void activate(GApplication *application, WebKitSettings *webkitSettings)
> {
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    WebKitNetworkSession *networkSession = NULL;
>+    if (!automationMode) {
>+        if (privateMode)
>+            networkSession = webkit_network_session_new_ephemeral();
>+        else {
>+            char *dataDirectory = g_build_filename(g_get_user_data_dir(), "webkitgtk-" WEBKITGTK_API_VERSION, "MiniBrowser", NULL);
>+            char *cacheDirectory = g_build_filename(g_get_user_cache_dir(), "webkitgtk-" WEBKITGTK_API_VERSION, "MiniBrowser", NULL);
>+            networkSession = webkit_network_session_new(dataDirectory, cacheDirectory);
>+            g_free(dataDirectory);
>+            g_free(cacheDirectory);
>+        }
>+
>+        webkit_network_session_set_itp_enabled(networkSession, enableITP);
>+
>+        if (proxy) {
>+            WebKitNetworkProxySettings *webkitProxySettings = webkit_network_proxy_settings_new(proxy, ignoreHosts);
>+            webkit_network_session_set_proxy_settings(networkSession, WEBKIT_NETWORK_PROXY_MODE_CUSTOM, webkitProxySettings);
>+            webkit_network_proxy_settings_free(webkitProxySettings);
>+        }
>+
>+        if (ignoreTLSErrors)
>+            webkit_network_session_set_tls_errors_policy(networkSession, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+
>+        if (cookiesPolicy) {
>+            WebKitCookieManager *cookieManager = webkit_network_session_get_cookie_manager(networkSession);
>+            GEnumClass *enumClass = g_type_class_ref(WEBKIT_TYPE_COOKIE_ACCEPT_POLICY);
>+            GEnumValue *enumValue = g_enum_get_value_by_nick(enumClass, cookiesPolicy);
>+            if (enumValue)
>+                webkit_cookie_manager_set_accept_policy(cookieManager, enumValue->value);
>+            g_type_class_unref(enumClass);
>+        }
>+
>+        if (cookiesFile && !webkit_network_session_is_ephemeral(networkSession)) {
>+            WebKitCookieManager *cookieManager = webkit_network_session_get_cookie_manager(networkSession);
>+            WebKitCookiePersistentStorage storageType = g_str_has_suffix(cookiesFile, ".txt") ? WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT : WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE;
>+            webkit_cookie_manager_set_persistent_storage(cookieManager, cookiesFile, storageType);
>+        }
>+    }
>+#else
>     WebKitWebsiteDataManager *manager;
>     if (privateMode || automationMode)
>         manager = webkit_website_data_manager_new_ephemeral();
>@@ -681,21 +733,26 @@ static void activate(GApplication *application, WebKitSettings *webkitSettings)
> 
>     if (ignoreTLSErrors)
>         webkit_website_data_manager_set_tls_errors_policy(manager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#endif
> 
>-    WebKitWebContext *webContext = g_object_new(WEBKIT_TYPE_WEB_CONTEXT, "website-data-manager", manager,
>+    WebKitWebContext *webContext = g_object_new(WEBKIT_TYPE_WEB_CONTEXT,
> #if !GTK_CHECK_VERSION(3, 98, 0)
>+        "website-data-manager", manager,
>         "process-swap-on-cross-site-navigation-enabled", TRUE,
>         "use-system-appearance-for-scrollbars", FALSE,
> #endif
>         "time-zone-override", timeZone,
>         NULL);
>+#if !GTK_CHECK_VERSION(3, 98, 0)
>     g_object_unref(manager);
>+#endif
> 
> #if !GTK_CHECK_VERSION(3, 98, 0)
>     if (enableSandbox)
>         webkit_web_context_set_sandbox_enabled(webContext, TRUE);
> #endif
> 
>+#if !GTK_CHECK_VERSION(3, 98, 0)
>     if (cookiesPolicy) {
>         WebKitCookieManager *cookieManager = webkit_web_context_get_cookie_manager(webContext);
>         GEnumClass *enumClass = g_type_class_ref(WEBKIT_TYPE_COOKIE_ACCEPT_POLICY);
>@@ -710,15 +767,24 @@ static void activate(GApplication *application, WebKitSettings *webkitSettings)
>         WebKitCookiePersistentStorage storageType = g_str_has_suffix(cookiesFile, ".txt") ? WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT : WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE;
>         webkit_cookie_manager_set_persistent_storage(cookieManager, cookiesFile, storageType);
>     }
>+#endif
> 
>-    // Enable the favicon database, by specifying the default directory.
>+    // Enable the favicon database. In GTK4 API they are enabled by default.
>+#if !GTK_CHECK_VERSION(3, 98, 0)
>     webkit_web_context_set_favicon_database_directory(webContext, NULL);
>+#endif
> 
>-    webkit_web_context_register_uri_scheme(webContext, BROWSER_ABOUT_SCHEME, (WebKitURISchemeRequestCallback)aboutURISchemeRequestCallback, webContext, NULL);
>+    webkit_web_context_register_uri_scheme(webContext, BROWSER_ABOUT_SCHEME, (WebKitURISchemeRequestCallback)aboutURISchemeRequestCallback, NULL, NULL);
> 
>     WebKitUserContentManager *userContentManager = webkit_user_content_manager_new();
>     webkit_user_content_manager_register_script_message_handler(userContentManager, "aboutData");
>-    g_signal_connect(userContentManager, "script-message-received::aboutData", G_CALLBACK(aboutDataScriptMessageReceivedCallback), webContext);
>+    WebKitWebsiteDataManager *dataManager;
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    dataManager = networkSession ? webkit_network_session_get_website_data_manager(networkSession) : NULL;
>+#else
>+    dataManager = webkit_web_context_get_website_data_manager(webContext);
>+#endif
>+    g_signal_connect(userContentManager, "script-message-received::aboutData", G_CALLBACK(aboutDataScriptMessageReceivedCallback), dataManager);
> 
>     WebKitWebsitePolicies *defaultWebsitePolicies = webkit_website_policies_new_with_policies(
>         "autoplay", autoplayPolicy,
>@@ -751,7 +817,11 @@ static void activate(GApplication *application, WebKitSettings *webkitSettings)
>     webkit_web_context_set_automation_allowed(webContext, automationMode);
>     g_signal_connect(webContext, "automation-started", G_CALLBACK(automationStartedCallback), application);
> 
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    BrowserWindow *mainWindow = BROWSER_WINDOW(browser_window_new(NULL, webContext, networkSession));
>+#else
>     BrowserWindow *mainWindow = BROWSER_WINDOW(browser_window_new(NULL, webContext));
>+#endif
>     gtk_application_add_window(GTK_APPLICATION(application), GTK_WINDOW(mainWindow));
>     if (darkMode)
>         g_object_set(gtk_widget_get_settings(GTK_WIDGET(mainWindow)), "gtk-application-prefer-dark-theme", TRUE, NULL);
>@@ -795,6 +865,9 @@ static void activate(GApplication *application, WebKitSettings *webkitSettings)
>     g_object_unref(webContext);
>     g_object_unref(userContentManager);
>     g_object_unref(defaultWebsitePolicies);
>+#if GTK_CHECK_VERSION(3, 98, 0)
>+    g_clear_object(&networkSession);
>+#endif
> 
>     gtk_widget_grab_focus(firstTab);
>     gtk_widget_show(GTK_WIDGET(mainWindow));
>diff --git a/Tools/MiniBrowser/wpe/main.cpp b/Tools/MiniBrowser/wpe/main.cpp
>index c3526520eaec..a40280674117 100644
>--- a/Tools/MiniBrowser/wpe/main.cpp
>+++ b/Tools/MiniBrowser/wpe/main.cpp
>@@ -76,8 +76,8 @@ static const GOptionEntry commandLineOptions[] =
> 
> class InputClient final : public WPEToolingBackends::ViewBackend::InputClient {
> public:
>-    InputClient(GMainLoop* loop, WebKitWebView* webView)
>-        : m_loop(loop)
>+    InputClient(GApplication* application, WebKitWebView* webView)
>+        : m_application(application)
>         , m_webView(webView)
>     {
>     }
>@@ -88,7 +88,7 @@ public:
>             return false;
> 
>         if (event->modifiers & wpe_input_keyboard_modifier_control && event->key_code == WPE_KEY_q) {
>-            g_main_loop_quit(m_loop);
>+            g_application_quit(m_application);
>             return true;
>         }
> 
>@@ -108,7 +108,7 @@ public:
>     }
> 
> private:
>-    GMainLoop* m_loop { nullptr };
>+    GApplication* m_application { nullptr };
>     WebKitWebView* m_webView { nullptr };
> };
> 
>@@ -183,50 +183,42 @@ static WebKitWebView* createWebView(WebKitWebView* webView, WebKitNavigationActi
>     return newWebView;
> }
> 
>-int main(int argc, char *argv[])
>+static void activate(GApplication* application, WPEToolingBackends::ViewBackend* backend)
> {
>-#if ENABLE_DEVELOPER_MODE
>-    g_setenv("WEBKIT_INJECTED_BUNDLE_PATH", WEBKIT_INJECTED_BUNDLE_PATH, FALSE);
>-#endif
>-
>-    GOptionContext* context = g_option_context_new(nullptr);
>-    g_option_context_add_main_entries(context, commandLineOptions, nullptr);
>-
>-#if !USE_GSTREAMER_FULL && (ENABLE_WEB_AUDIO || ENABLE_VIDEO)
>-    g_option_context_add_group(context, gst_init_get_option_group());
>-#endif
>-
>-    GError* error = nullptr;
>-    if (!g_option_context_parse(context, &argc, &argv, &error)) {
>-        g_printerr("Cannot parse arguments: %s\n", error->message);
>-        g_error_free(error);
>-        g_option_context_free(context);
>+    g_application_hold(application);
>+#if ENABLE_2022_GLIB_API
>+    WebKitNetworkSession* networkSession = nullptr;
>+    if (!automationMode) {
>+        networkSession = privateMode ? webkit_network_session_new_ephemeral() : webkit_network_session_new(nullptr, nullptr);
>+        webkit_network_session_set_itp_enabled(networkSession, enableITP);
>+
>+        if (proxy) {
>+            auto* webkitProxySettings = webkit_network_proxy_settings_new(proxy, ignoreHosts);
>+            webkit_network_session_set_proxy_settings(networkSession, WEBKIT_NETWORK_PROXY_MODE_CUSTOM, webkitProxySettings);
>+            webkit_network_proxy_settings_free(webkitProxySettings);
>+        }
> 
>-        return 1;
>-    }
>-    g_option_context_free(context);
>+        if (ignoreTLSErrors)
>+            webkit_network_session_set_tls_errors_policy(networkSession, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
> 
>-    if (printVersion) {
>-        g_print("WPE WebKit %u.%u.%u",
>-            webkit_get_major_version(),
>-            webkit_get_minor_version(),
>-            webkit_get_micro_version());
>-        if (g_strcmp0(BUILD_REVISION, "tarball"))
>-            g_print(" (%s)", BUILD_REVISION);
>-        g_print("\n");
>-        return 0;
>-    }
>-
>-    auto* loop = g_main_loop_new(nullptr, FALSE);
>+        if (cookiesPolicy) {
>+            auto* cookieManager = webkit_network_session_get_cookie_manager(networkSession);
>+            auto* enumClass = static_cast<GEnumClass*>(g_type_class_ref(WEBKIT_TYPE_COOKIE_ACCEPT_POLICY));
>+            GEnumValue* enumValue = g_enum_get_value_by_nick(enumClass, cookiesPolicy);
>+            if (enumValue)
>+                webkit_cookie_manager_set_accept_policy(cookieManager, static_cast<WebKitCookieAcceptPolicy>(enumValue->value));
>+            g_type_class_unref(enumClass);
>+        }
> 
>-    auto backend = createViewBackend(1280, 720);
>-    struct wpe_view_backend* wpeBackend = backend->backend();
>-    if (!wpeBackend) {
>-        g_warning("Failed to create WPE view backend");
>-        g_main_loop_unref(loop);
>-        return 1;
>+        if (cookiesFile && !webkit_network_session_is_ephemeral(networkSession)) {
>+            auto* cookieManager = webkit_network_session_get_cookie_manager(networkSession);
>+            auto storageType = g_str_has_suffix(cookiesFile, ".txt") ? WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT : WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE;
>+            webkit_cookie_manager_set_persistent_storage(cookieManager, cookiesFile, storageType);
>+        }
>     }
> 
>+    auto* webContext = WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT, "time-zone-override", timeZone, nullptr));
>+#else
>     auto* manager = (privateMode || automationMode) ? webkit_website_data_manager_new_ephemeral() : webkit_website_data_manager_new(nullptr);
>     webkit_website_data_manager_set_itp_enabled(manager, enableITP);
> 
>@@ -256,6 +248,7 @@ int main(int argc, char *argv[])
>         auto storageType = g_str_has_suffix(cookiesFile, ".txt") ? WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT : WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE;
>         webkit_cookie_manager_set_persistent_storage(cookieManager, cookiesFile, storageType);
>     }
>+#endif
> 
>     WebKitUserContentManager* userContentManager = nullptr;
>     if (contentFilter) {
>@@ -290,25 +283,27 @@ int main(int argc, char *argv[])
>         "enable-encrypted-media", TRUE,
>         nullptr);
> 
>-    auto* backendPtr = backend.get();
>-    auto* viewBackend = webkit_web_view_backend_new(wpeBackend, [](gpointer data) {
>+    auto* viewBackend = webkit_web_view_backend_new(backend->backend(), [](gpointer data) {
>         delete static_cast<WPEToolingBackends::ViewBackend*>(data);
>-    }, backend.release());
>+    }, backend);
> 
>     auto* webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>         "backend", viewBackend,
>         "web-context", webContext,
>+#if ENABLE_2022_GLIB_API
>+        "network-session", networkSession,
>+#endif
>         "settings", settings,
>         "user-content-manager", userContentManager,
>         "is-controlled-by-automation", automationMode,
>         nullptr));
>     g_object_unref(settings);
> 
>-    backendPtr->setInputClient(std::make_unique<InputClient>(loop, webView));
>+    backend->setInputClient(std::make_unique<InputClient>(application, webView));
> #if defined(ENABLE_ACCESSIBILITY) && ENABLE_ACCESSIBILITY
>-    auto* accessible = wpe_view_backend_dispatch_get_accessible(wpeBackend);
>+    auto* accessible = wpe_view_backend_dispatch_get_accessible(backend->backend());
>     if (ATK_IS_OBJECT(accessible))
>-        backendPtr->setAccessibleChild(ATK_OBJECT(accessible));
>+        backend->setAccessibleChild(ATK_OBJECT(accessible));
> #endif
> 
>     openViews = g_hash_table_new_full(nullptr, nullptr, g_object_unref, nullptr);
>@@ -339,14 +334,59 @@ int main(int argc, char *argv[])
>     else
>         webkit_web_view_load_uri(webView, "https://wpewebkit.org");
> 
>-    g_main_loop_run(loop);
>+    g_object_unref(webContext);
>+#if ENABLE_2022_GLIB_API
>+    g_clear_object(&networkSession);
>+#endif
>+}
> 
>-    g_hash_table_destroy(openViews);
>+int main(int argc, char *argv[])
>+{
>+#if ENABLE_DEVELOPER_MODE
>+    g_setenv("WEBKIT_INJECTED_BUNDLE_PATH", WEBKIT_INJECTED_BUNDLE_PATH, FALSE);
>+#endif
>+
>+    GOptionContext* context = g_option_context_new(nullptr);
>+    g_option_context_add_main_entries(context, commandLineOptions, nullptr);
>+
>+#if !USE_GSTREAMER_FULL && (ENABLE_WEB_AUDIO || ENABLE_VIDEO)
>+    g_option_context_add_group(context, gst_init_get_option_group());
>+#endif
>+
>+    GError* error = nullptr;
>+    if (!g_option_context_parse(context, &argc, &argv, &error)) {
>+        g_printerr("Cannot parse arguments: %s\n", error->message);
>+        g_error_free(error);
>+        g_option_context_free(context);
>+
>+        return 1;
>+    }
>+    g_option_context_free(context);
> 
>+    if (printVersion) {
>+        g_print("WPE WebKit %u.%u.%u",
>+            webkit_get_major_version(),
>+            webkit_get_minor_version(),
>+            webkit_get_micro_version());
>+        if (g_strcmp0(BUILD_REVISION, "tarball"))
>+            g_print(" (%s)", BUILD_REVISION);
>+        g_print("\n");
>+        return 0;
>+    }
>+
>+    auto backend = createViewBackend(1280, 720);
>+    struct wpe_view_backend* wpeBackend = backend->backend();
>+    if (!wpeBackend) {
>+        g_warning("Failed to create WPE view backend");
>+        return 1;
>+    }
> 
>-    if (privateMode || automationMode)
>-        g_object_unref(webContext);
>-    g_main_loop_unref(loop);
>+    GApplication *application = g_application_new("org.wpewebkit.MiniBrowser", G_APPLICATION_NON_UNIQUE);
>+    g_signal_connect(application, "activate", G_CALLBACK(activate), backend.release());
>+    g_application_run(application, 0, nullptr);
>+    g_object_unref(application);
>+
>+    g_hash_table_destroy(openViews);
> 
>     return 0;
> }
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp
>index b43139802d92..2eaa01608ec4 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp
>@@ -254,10 +254,17 @@ static void testWebViewAuthenticationStorage(AuthenticationTest* test, gconstpoi
>     g_assert_false(test->m_authenticationSucceededReceived);
> #endif
> 
>+#if ENABLE(2022_GLIB_API)
>+    auto* networkSession = webkit_web_view_get_network_session(test->m_webView);
>+    g_assert_true(webkit_network_session_get_persistent_credential_storage_enabled(networkSession));
>+    webkit_network_session_set_persistent_credential_storage_enabled(networkSession, FALSE);
>+    g_assert_false(webkit_network_session_get_persistent_credential_storage_enabled(networkSession));
>+#else
>     auto* websiteDataManager = webkit_web_view_get_website_data_manager(test->m_webView);
>     g_assert_true(webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager));
>     webkit_website_data_manager_set_persistent_credential_storage_enabled(websiteDataManager, FALSE);
>     g_assert_false(webkit_website_data_manager_get_persistent_credential_storage_enabled(websiteDataManager));
>+#endif
> 
>     test->loadURI(kServer->getURIForPath("/auth-test.html").data());
>     request = test->waitForAuthenticationRequest();
>@@ -280,7 +287,11 @@ static void testWebViewAuthenticationStorage(AuthenticationTest* test, gconstpoi
>     test->waitUntilLoadFinished();
>     g_assert_false(test->m_authenticationCancelledReceived);
>     g_assert_true(test->m_authenticationSucceededReceived);
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_persistent_credential_storage_enabled(networkSession, TRUE);
>+#else
>     webkit_website_data_manager_set_persistent_credential_storage_enabled(websiteDataManager, TRUE);
>+#endif
> }
> 
> static void testWebViewAuthenticationSuccess(AuthenticationTest* test, gconstpointer)
>@@ -467,8 +478,12 @@ public:
>         g_assert_false(m_proxyServer.baseURL().isNull());
>         gProxyServerPort = m_proxyServer.port();
>         WebKitNetworkProxySettings* settings = webkit_network_proxy_settings_new(m_proxyServer.baseURL().string().utf8().data(), nullptr);
>+#if ENABLE(2022_GLIB_API)
>+        webkit_network_session_set_proxy_settings(m_networkSession.get(), WEBKIT_NETWORK_PROXY_MODE_CUSTOM, settings);
>+#else
>         auto* websiteDataManager = webkit_web_context_get_website_data_manager(m_webContext.get());
>         webkit_website_data_manager_set_network_proxy_settings(websiteDataManager, WEBKIT_NETWORK_PROXY_MODE_CUSTOM, settings);
>+#endif
>         webkit_network_proxy_settings_free(settings);
>     }
> 
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp
>index 2f1952c2989b..00b55088f72d 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp
>@@ -340,6 +340,12 @@ static void testAutomationSessionRequestSession(AutomationTest* test, gconstpoin
>         nullptr));
>     g_assert_true(webkit_web_view_is_controlled_by_automation(webView.get()));
>     g_assert_cmpuint(webkit_web_view_get_automation_presentation_type(webView.get()), ==, WEBKIT_AUTOMATION_BROWSING_CONTEXT_PRESENTATION_WINDOW);
>+#if ENABLE(2022_GLIB_API)
>+    // Automation session has its own ephemeral session.
>+    auto* networkSession = webkit_web_view_get_network_session(webView.get());
>+    g_assert_false(networkSession == test->m_networkSession.get());
>+    g_assert_true(webkit_network_session_is_ephemeral(networkSession));
>+#endif
>     g_assert_true(test->createTopLevelBrowsingContext(webView.get()));
> 
>     auto newWebViewInWindow = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>@@ -347,10 +353,17 @@ static void testAutomationSessionRequestSession(AutomationTest* test, gconstpoin
>         "backend", Test::createWebViewBackend(),
> #endif
>         "web-context", test->m_webContext.get(),
>+#if ENABLE(2022_GLIB_API)
>+        // Check also here that network session property is ignored when is-controlled-by-automation is true.
>+        "network-session", test->m_networkSession.get(),
>+#endif
>         "is-controlled-by-automation", TRUE,
>         nullptr));
>     g_assert_true(webkit_web_view_is_controlled_by_automation(newWebViewInWindow.get()));
>     g_assert_cmpuint(webkit_web_view_get_automation_presentation_type(newWebViewInWindow.get()), ==, WEBKIT_AUTOMATION_BROWSING_CONTEXT_PRESENTATION_WINDOW);
>+#if ENABLE(2022_GLIB_API)
>+    g_assert_true(webkit_web_view_get_network_session(newWebViewInWindow.get()) == networkSession);
>+#endif
>     g_assert_true(test->createNewWindow(newWebViewInWindow.get()));
> 
>     auto newWebViewInTab = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp
>index 58f2370b9a20..34559c2ec804 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp
>@@ -57,9 +57,17 @@ public:
> 
>     CookieManagerTest()
>         : WebViewTest()
>+#if ENABLE(2022_GLIB_API)
>+        , m_cookieManager(webkit_network_session_get_cookie_manager(m_networkSession.get()))
>+        , m_websiteDataManager(webkit_network_session_get_website_data_manager(m_networkSession.get()))
>+#else
>         , m_cookieManager(webkit_web_context_get_cookie_manager(m_webContext.get()))
>+        , m_websiteDataManager(webkit_web_context_get_website_data_manager(m_webContext.get()))
>+#endif
>     {
>-        g_assert_true(webkit_website_data_manager_get_cookie_manager(webkit_web_context_get_website_data_manager(m_webContext.get())) == m_cookieManager);
>+#if !ENABLE(2022_GLIB_API)
>+        g_assert_true(webkit_website_data_manager_get_cookie_manager(m_websiteDataManager) == m_cookieManager);
>+#endif
>         g_signal_connect(m_cookieManager, "changed", G_CALLBACK(cookiesChangedCallback), this);
>     }
> 
>@@ -175,28 +183,37 @@ public:
>         webkit_cookie_manager_set_accept_policy(m_cookieManager, policy);
>     }
> 
>-    static void getDomainsReadyCallback(GObject* object, GAsyncResult* result, gpointer userData)
>+    GUniquePtr<GList> fetch()
>     {
>-        GUniqueOutPtr<GError> error;
>-        G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
>-        char** domains = webkit_cookie_manager_get_domains_with_cookies_finish(WEBKIT_COOKIE_MANAGER(object), result, &error.outPtr());
>-        G_GNUC_END_IGNORE_DEPRECATIONS;
>-        g_assert_no_error(error.get());
>-
>-        CookieManagerTest* test = static_cast<CookieManagerTest*>(userData);
>-        test->m_domains = domains;
>-        g_main_loop_quit(test->m_mainLoop);
>+        struct TestData {
>+            GUniquePtr<GList> dataList;
>+            GMainLoop* mainLoop;
>+        } data = { nullptr, m_mainLoop };
>+
>+        webkit_website_data_manager_fetch(m_websiteDataManager, WEBKIT_WEBSITE_DATA_COOKIES, nullptr, [](GObject* object, GAsyncResult* result, gpointer userData) {
>+            auto* data = static_cast<TestData*>(userData);
>+            GUniqueOutPtr<GError> error;
>+            data->dataList.reset(webkit_website_data_manager_fetch_finish(WEBKIT_WEBSITE_DATA_MANAGER(object), result, &error.outPtr()));
>+            g_assert_no_error(error.get());
>+            g_main_loop_quit(data->mainLoop);
>+        }, &data);
>+        g_main_loop_run(m_mainLoop);
>+        return WTFMove(data.dataList);
>     }
> 
>     char** getDomains()
>     {
>-        g_strfreev(m_domains);
>-        m_domains = 0;
>-        G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
>-        webkit_cookie_manager_get_domains_with_cookies(m_cookieManager, 0, getDomainsReadyCallback, this);
>-        G_GNUC_END_IGNORE_DEPRECATIONS;
>-        g_main_loop_run(m_mainLoop);
>+        g_clear_pointer(&m_domains, g_strfreev);
>+        GUniquePtr<GList> dataList = fetch();
>+        GPtrArray* domains = g_ptr_array_sized_new(g_list_length(dataList.get()));
>+        for (GList* item = dataList.get(); item; item = g_list_next(item)) {
>+            auto* data = static_cast<WebKitWebsiteData*>(item->data);
>+            g_ptr_array_add(domains, g_strdup(webkit_website_data_get_name(data)));
>+            webkit_website_data_unref(data);
>+        }
>+        g_ptr_array_add(domains, nullptr);
> 
>+        m_domains = reinterpret_cast<char**>(g_ptr_array_free(domains, FALSE));
>         return m_domains;
>     }
> 
>@@ -214,16 +231,23 @@ public:
> 
>     void deleteCookiesForDomain(const char* domain)
>     {
>-        G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
>-        webkit_cookie_manager_delete_cookies_for_domain(m_cookieManager, domain);
>-        G_GNUC_END_IGNORE_DEPRECATIONS;
>+        GUniquePtr<GList> dataList = fetch();
>+        GUniquePtr<GList> cookies;
>+        for (GList* item = dataList.get(); item; item = g_list_next(item)) {
>+            auto* data = static_cast<WebKitWebsiteData*>(item->data);
>+            if (!g_strcmp0(webkit_website_data_get_name(data), domain))
>+                cookies.reset(g_list_prepend(cookies.get(), webkit_website_data_ref(data)));
>+            webkit_website_data_unref(data);
>+        }
>+        webkit_website_data_manager_remove(m_websiteDataManager, WEBKIT_WEBSITE_DATA_COOKIES, cookies.get(), nullptr, nullptr, nullptr);
>+        g_list_foreach(cookies.get(), [](gpointer data, gpointer) {
>+            webkit_website_data_unref(static_cast<WebKitWebsiteData*>(data));
>+        }, nullptr);
>     }
> 
>     void deleteAllCookies()
>     {
>-        G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
>-        webkit_cookie_manager_delete_all_cookies(m_cookieManager);
>-        G_GNUC_END_IGNORE_DEPRECATIONS;
>+        webkit_website_data_manager_clear(m_websiteDataManager, WEBKIT_WEBSITE_DATA_COOKIES, 0, nullptr, nullptr, nullptr);
>     }
> 
>     void waitUntilCookiesChanged(int cookiesExpectedToChangeCount = 1)
>@@ -235,7 +259,17 @@ public:
>         m_finishLoopWhenCookiesChange = false;
>     }
> 
>+    void setITPEnable(bool enable)
>+    {
>+#if ENABLE(2022_GLIB_API)
>+        webkit_network_session_set_itp_enabled(m_networkSession.get(), enable);
>+#else
>+        webkit_website_data_manager_set_itp_enabled(m_websiteDataManager, enable);
>+#endif
>+    }
>+
>     WebKitCookieManager* m_cookieManager { nullptr };
>+    WebKitWebsiteDataManager* m_websiteDataManager { nullptr };
>     WebKitCookieAcceptPolicy m_acceptPolicy { WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY };
>     char** m_domains { nullptr };
>     GList* m_cookies { nullptr };
>@@ -278,23 +312,22 @@ static void testCookieManagerAcceptPolicy(CookieManagerTest* test, gconstpointer
>     g_assert_cmpint(g_strv_length(domains), ==, 0);
> 
>     // ITP never uses NO_THIRD_PARTY.
>-    auto* manager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>-    webkit_website_data_manager_set_itp_enabled(manager, TRUE);
>+    test->setITPEnable(true);
>     g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
>     test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
>     g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
>-    webkit_website_data_manager_set_itp_enabled(manager, FALSE);
>+    test->setITPEnable(false);
>     g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
>-    webkit_website_data_manager_set_itp_enabled(manager, TRUE);
>+    test->setITPEnable(true);
>     g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
>-    webkit_website_data_manager_set_itp_enabled(manager, FALSE);
>+    test->setITPEnable(false);
>     g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
>     test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
>-    webkit_website_data_manager_set_itp_enabled(manager, TRUE);
>+    test->setITPEnable(true);
>     g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
>     test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
>     g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
>-    webkit_website_data_manager_set_itp_enabled(manager, FALSE);
>+    test->setITPEnable(false);
>     g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
> }
> 
>@@ -667,15 +700,26 @@ static void testCookieManagerEphemeral(CookieManagerTest* test, gconstpointer)
>     g_assert_nonnull(domains);
>     g_assert_cmpint(g_strv_length(domains), ==, 0);
> 
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitNetworkSession> ephemeralSession = adoptGRef(webkit_network_session_new_ephemeral());
>+#endif
>     auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
> #if PLATFORM(WPE)
>         "backend", Test::createWebViewBackend(),
> #endif
>         "web-context", webkit_web_view_get_context(test->m_webView),
>+#if ENABLE(2022_GLIB_API)
>+        "network-session", ephemeralSession.get(),
>+#else
>         "is-ephemeral", TRUE,
>+#endif
>         nullptr));
>+#if ENABLE(2022_GLIB_API)
>+    g_assert_true(webkit_web_view_get_network_session(webView.get()) == ephemeralSession.get());
>+#else
>     g_assert_true(webkit_web_view_is_ephemeral(webView.get()));
>     g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(webView.get())));
>+#endif
> 
>     g_signal_connect(webView.get(), "load-changed", G_CALLBACK(ephemeralViewloadChanged), test);
>     webkit_web_view_load_uri(webView.get(), kServer->getURIForPath("/index.html").data());
>@@ -685,24 +729,32 @@ static void testCookieManagerEphemeral(CookieManagerTest* test, gconstpointer)
>     g_assert_nonnull(domains);
>     g_assert_cmpint(g_strv_length(domains), ==, 0);
> 
>+#if ENABLE(2022_GLIB_API)
>+    auto* viewDataManager = webkit_network_session_get_website_data_manager(ephemeralSession.get());
>+#else
>     auto* viewDataManager = webkit_web_view_get_website_data_manager(webView.get());
>+#endif
>     g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(viewDataManager));
>     test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(viewDataManager));
>+#if ENABLE(2022_GLIB_API)
>+    auto* cookieManager = webkit_network_session_get_cookie_manager(ephemeralSession.get());
>+#else
>     g_assert_true(viewDataManager != webkit_web_context_get_website_data_manager(webkit_web_view_get_context(test->m_webView)));
>     auto* cookieManager = webkit_website_data_manager_get_cookie_manager(viewDataManager);
>+#endif
>     g_assert_true(WEBKIT_IS_COOKIE_MANAGER(cookieManager));
>     test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(cookieManager));
>     g_assert_true(cookieManager != test->m_cookieManager);
>-    G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
>-    webkit_cookie_manager_get_domains_with_cookies(cookieManager, nullptr, [](GObject* object, GAsyncResult* result, gpointer userData) {
>+    webkit_website_data_manager_fetch(viewDataManager, WEBKIT_WEBSITE_DATA_COOKIES, nullptr, [](GObject* object, GAsyncResult* result, gpointer userData) {
>         auto* test = static_cast<CookieManagerTest*>(userData);
>-        GUniquePtr<char*> domains(webkit_cookie_manager_get_domains_with_cookies_finish(WEBKIT_COOKIE_MANAGER(object), result, nullptr));
>+        GUniquePtr<GList> domains(webkit_website_data_manager_fetch_finish(WEBKIT_WEBSITE_DATA_MANAGER(object), result, nullptr));
>         g_assert_nonnull(domains);
>-        g_assert_cmpint(g_strv_length(domains.get()), ==, 1);
>-        g_assert_cmpstr(domains.get()[0], ==, kFirstPartyDomain);
>+        g_assert_cmpint(g_list_length(domains.get()), ==, 1);
>+        auto* data = static_cast<WebKitWebsiteData*>(domains.get()->data);
>+        g_assert_cmpstr(webkit_website_data_get_name(data), ==, kFirstPartyDomain);
>+        webkit_website_data_unref(data);
>         test->quitMainLoop();
>     }, test);
>-    G_GNUC_END_IGNORE_DEPRECATIONS;
>     g_main_loop_run(test->m_mainLoop);
> }
> 
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp
>index c3add4e4e2a8..9c8e5a961317 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp
>@@ -89,7 +89,7 @@ public:
>         return TRUE;
>     }
> 
>-    static void downloadStartedCallback(WebKitWebContext* context, WebKitDownload* download, DownloadTest* test)
>+    static void downloadStartedCallback(DownloadTest* test, WebKitDownload* download)
>     {
>         g_assert_nonnull(webkit_download_get_request(download));
>         test->started(download);
>@@ -106,12 +106,20 @@ public:
>         , m_downloadSize(0)
>         , m_allowOverwrite(false)
>     {
>-        g_signal_connect(m_webContext.get(), "download-started", G_CALLBACK(downloadStartedCallback), this);
>+#if ENABLE(2022_GLIB_API)
>+        g_signal_connect_swapped(m_networkSession.get(), "download-started", G_CALLBACK(downloadStartedCallback), this);
>+#else
>+        g_signal_connect_swapped(m_webContext.get(), "download-started", G_CALLBACK(downloadStartedCallback), this);
>+#endif
>     }
> 
>     ~DownloadTest()
>     {
>-        g_signal_handlers_disconnect_matched(m_webContext.get(), G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
>+#if ENABLE(2022_GLIB_API)
>+        g_signal_handlers_disconnect_matched(m_networkSession.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
>+#else
>+        g_signal_handlers_disconnect_matched(m_webContext.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
>+#endif
>         g_main_loop_unref(m_mainLoop);
>     }
> 
>@@ -160,7 +168,11 @@ public:
> 
>     GRefPtr<WebKitDownload> downloadURIAndWaitUntilFinishes(const CString& requestURI)
>     {
>+#if ENABLE(2022_GLIB_API)
>+        GRefPtr<WebKitDownload> download = adoptGRef(webkit_network_session_download_uri(m_networkSession.get(), requestURI.data()));
>+#else
>         GRefPtr<WebKitDownload> download = adoptGRef(webkit_web_context_download_uri(m_webContext.get(), requestURI.data()));
>+#endif
>         assertObjectIsDeletedWhenTestFinishes(G_OBJECT(download.get()));
> 
>         g_assert_false(webkit_download_get_allow_overwrite(download.get()));
>@@ -539,7 +551,7 @@ class WebViewDownloadTest: public WebViewTest {
> public:
>     MAKE_GLIB_TEST_FIXTURE(WebViewDownloadTest);
> 
>-    static void downloadStartedCallback(WebKitWebContext* context, WebKitDownload* download, WebViewDownloadTest* test)
>+    static void downloadStartedCallback(WebViewDownloadTest* test, WebKitDownload* download)
>     {
>         test->m_download = download;
>         test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(download));
>@@ -550,12 +562,20 @@ public:
> 
>     WebViewDownloadTest()
>     {
>-        g_signal_connect(webkit_web_view_get_context(m_webView), "download-started", G_CALLBACK(downloadStartedCallback), this);
>+#if ENABLE(2022_GLIB_API)
>+        g_signal_connect_swapped(webkit_web_view_get_network_session(m_webView), "download-started", G_CALLBACK(downloadStartedCallback), this);
>+#else
>+        g_signal_connect_swapped(webkit_web_view_get_context(m_webView), "download-started", G_CALLBACK(downloadStartedCallback), this);
>+#endif
>     }
> 
>     ~WebViewDownloadTest()
>     {
>-        g_signal_handlers_disconnect_matched(webkit_web_view_get_context(m_webView), G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
>+#if ENABLE(2022_GLIB_API)
>+        g_signal_handlers_disconnect_matched(webkit_web_view_get_network_session(m_webView), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
>+#else
>+        g_signal_handlers_disconnect_matched(webkit_web_view_get_context(m_webView), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
>+#endif
>     }
> 
>     void waitUntilDownloadStarted()
>@@ -586,7 +606,11 @@ public:
>     }
> 
> #if PLATFORM(GTK)
>+#if ENABLE(2022_GLIB_API)
>+    static gboolean contextMenuCallback(WebKitWebView* webView, WebKitContextMenu* contextMenu, WebKitHitTestResult* hitTestResult, WebViewDownloadTest* test)
>+#else
>     static gboolean contextMenuCallback(WebKitWebView* webView, WebKitContextMenu* contextMenu, GdkEvent*, WebKitHitTestResult* hitTestResult, WebViewDownloadTest* test)
>+#endif
>     {
>         g_assert_true(WEBKIT_IS_HIT_TEST_RESULT(hitTestResult));
>         GList* items = webkit_context_menu_get_items(contextMenu);
>@@ -803,14 +827,23 @@ static void testDownloadUserAgent(DownloadTest* test, gconstpointer)
> 
> static void testDownloadEphemeralContext(Test* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitNetworkSession> networkSession = adoptGRef(webkit_network_session_new_ephemeral());
>+    test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(networkSession.get()));
>+#else
>     GRefPtr<WebKitWebsiteDataManager> manager = adoptGRef(webkit_website_data_manager_new_ephemeral());
>     test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(manager.get()));
>     GRefPtr<WebKitWebContext> context = adoptGRef(webkit_web_context_new_with_website_data_manager(manager.get()));
>     test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(context.get()));
>     g_assert_true(webkit_web_context_is_ephemeral(context.get()));
>+#endif
> 
>     GRefPtr<GMainLoop> mainLoop = adoptGRef(g_main_loop_new(nullptr, TRUE));
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitDownload> download = adoptGRef(webkit_network_session_download_uri(networkSession.get(), kServer->getURIForPath("/test.pdf").data()));
>+#else
>     GRefPtr<WebKitDownload> download = adoptGRef(webkit_web_context_download_uri(context.get(), kServer->getURIForPath("/test.pdf").data()));
>+#endif
>     test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(download.get()));
>     g_signal_connect(download.get(), "decide-destination", G_CALLBACK(+[](WebKitDownload* download, const gchar* suggestedFilename, gpointer) {
>         GUniquePtr<char> destination(g_build_filename(Test::dataDirectory(), suggestedFilename, nullptr));
>@@ -827,7 +860,7 @@ static void testDownloadEphemeralContext(Test* test, gconstpointer)
>     g_file_delete(destFile.get(), nullptr, nullptr);
> }
> 
>-#if PLATFORM(GTK) && !USE(GTK4)
>+#if PLATFORM(GTK)
> static void testContextMenuDownloadActions(WebViewDownloadTest* test, gconstpointer)
> {
>     test->showInWindow();
>@@ -858,7 +891,7 @@ static void testContextMenuDownloadActions(WebViewDownloadTest* test, gconstpoin
>     g_assert_cmpint(g_file_info_get_size(downloadFileInfo.get()), >, 0);
>     g_file_delete(downloadFile.get(), nullptr, nullptr);
> }
>-#endif // PLATFORM(GTK) && !USE(GTK4)
>+#endif // PLATFORM(GTK)
> 
> #if PLATFORM(GTK)
> static void testBlobDownload(WebViewDownloadTest* test, gconstpointer)
>@@ -916,12 +949,9 @@ void beforeAll()
>     DownloadTest::add("Downloads", "text-plain-mime-type", testDownloadTextPlainMIMEType);
>     DownloadTest::add("Downloads", "user-agent", testDownloadUserAgent);
>     Test::add("Downloads", "ephemeral-context", testDownloadEphemeralContext);
>-    // FIXME: Implement keyStroke in WPE.
> #if PLATFORM(GTK)
>-#if !USE(GTK4)
>-    // FIXME: Rework context menu API in GTK4 to not expose GdkEvent.
>+    // FIXME: Implement keyStroke in WPE.
>     WebViewDownloadTest::add("Downloads", "contex-menu-download-actions", testContextMenuDownloadActions);
>-#endif
>     // FIXME: Implement mouse click in WPE.
>     WebViewDownloadTest::add("Downloads", "blob-download", testBlobDownload);
> #endif
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp
>index babadaf059d6..488412221055 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestSSL.cpp
>@@ -67,9 +67,14 @@ public:
> 
> static void testSSL(SSLTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#else
>     auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#endif
> 
>     test->loadURI(kHttpsServer->getURIForPath("/").data());
>     test->waitUntilLoadFinished();
>@@ -86,7 +91,11 @@ static void testSSL(SSLTest* test, gconstpointer)
>     g_assert_null(test->m_certificate);
>     g_assert_cmpuint(test->m_tlsErrors, ==, 0);
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
>+#endif
> }
> 
> class InsecureContentTest: public WebViewTest {
>@@ -117,9 +126,14 @@ public:
> 
> static void testInsecureContent(InsecureContentTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#else
>     auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#endif
> 
>     test->loadURI(kHttpsServer->getURIForPath("/insecure-content/").data());
>     test->waitUntilLoadFinished();
>@@ -129,16 +143,24 @@ static void testInsecureContent(InsecureContentTest* test, gconstpointer)
>     // https://bugs.webkit.org/show_bug.cgi?id=142469
>     g_assert_true(test->m_insecureContentDisplayed);
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
>+#endif
> }
> 
> static bool assertIfSSLRequestProcessed = false;
> 
> static void testTLSErrorsPolicy(SSLTest* test, gconstpointer)
> {
>-    auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     // TLS errors are treated as transport failures by default.
>+#if ENABLE(2022_GLIB_API)
>+    g_assert_cmpint(webkit_network_session_get_tls_errors_policy(test->m_networkSession.get()), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#else
>+    auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#endif
> 
>     assertIfSSLRequestProcessed = true;
>     test->loadURI(kHttpsServer->getURIForPath("/").data());
>@@ -148,37 +170,64 @@ static void testTLSErrorsPolicy(SSLTest* test, gconstpointer)
>     g_assert_false(test->m_loadEvents.contains(LoadTrackingTest::LoadCommitted));
>     assertIfSSLRequestProcessed = false;
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+    g_assert_cmpint(webkit_network_session_get_tls_errors_policy(test->m_networkSession.get()), ==, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>     g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#endif
> 
>     test->m_loadFailed = false;
>     test->loadURI(kHttpsServer->getURIForPath("/").data());
>     test->waitUntilLoadFinished();
>     g_assert_false(test->m_loadFailed);
> 
>-    // An ephemeral web view should keep the same network settings by default.
>+    // An ephemeral web view should keep the same network settings.
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitNetworkSession> ephemeralSession = adoptGRef(webkit_network_session_new_ephemeral());
>+    webkit_network_session_set_tls_errors_policy(ephemeralSession.get(), webkit_network_session_get_tls_errors_policy(test->m_networkSession.get()));
>+#endif
>     auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
> #if PLATFORM(WPE)
>         "backend", Test::createWebViewBackend(),
> #endif
>         "web-context", test->m_webContext.get(),
>+#if ENABLE(2022_GLIB_API)
>+        "network-session", ephemeralSession.get(),
>+#else
>         "is-ephemeral", TRUE,
>+#endif
>         nullptr));
>+#if ENABLE(2022_GLIB_API)
>+    g_assert_true(webkit_web_view_get_network_session(webView.get()) == ephemeralSession.get());
>+#else
>     g_assert_true(webkit_web_view_is_ephemeral(webView.get()));
>     g_assert_false(webkit_web_context_is_ephemeral(test->m_webContext.get()));
>     auto* webViewDataManager = webkit_web_view_get_website_data_manager(webView.get());
>     g_assert_false(websiteDataManager == webViewDataManager);
>     g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, webkit_website_data_manager_get_tls_errors_policy(webViewDataManager));
>+#endif
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+    g_assert_cmpint(webkit_network_session_get_tls_errors_policy(test->m_networkSession.get()), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>     g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#endif
> }
> 
> static void testTLSErrorsRedirect(SSLTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#else
>     auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#endif
> 
>     assertIfSSLRequestProcessed = true;
>     test->loadURI(kHttpsServer->getURIForPath("/redirect").data());
>@@ -188,7 +237,11 @@ static void testTLSErrorsRedirect(SSLTest* test, gconstpointer)
>     g_assert_false(test->m_loadEvents.contains(LoadTrackingTest::LoadCommitted));
>     assertIfSSLRequestProcessed = false;
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
>+#endif
> }
> 
> static gboolean webViewAuthenticationCallback(WebKitWebView*, WebKitAuthenticationRequest* request)
>@@ -200,9 +253,14 @@ static gboolean webViewAuthenticationCallback(WebKitWebView*, WebKitAuthenticati
> 
> static void testTLSErrorsHTTPAuth(SSLTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#else
>     auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#endif
> 
>     assertIfSSLRequestProcessed = true;
>     g_signal_connect(test->m_webView, "authenticate", G_CALLBACK(webViewAuthenticationCallback), NULL);
>@@ -213,7 +271,11 @@ static void testTLSErrorsHTTPAuth(SSLTest* test, gconstpointer)
>     g_assert_false(test->m_loadEvents.contains(LoadTrackingTest::LoadCommitted));
>     assertIfSSLRequestProcessed = false;
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
>+#endif
> }
> 
> class TLSErrorsTest: public SSLTest {
>@@ -248,9 +310,14 @@ private:
> 
> static void testLoadFailedWithTLSErrors(TLSErrorsTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#else
>     auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#endif
> 
>     assertIfSSLRequestProcessed = true;
>     // The load-failed-with-tls-errors signal should be emitted when there is a TLS failure.
>@@ -265,7 +332,11 @@ static void testLoadFailedWithTLSErrors(TLSErrorsTest* test, gconstpointer)
>     assertIfSSLRequestProcessed = false;
> 
>     // Test allowing an exception for this certificate on this host.
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_allow_tls_certificate_for_host(test->m_networkSession.get(), test->certificate(), test->host().data());
>+#else
>     webkit_web_context_allow_tls_certificate_for_host(test->m_webContext.get(), test->certificate(), test->host().data());
>+#endif
>     // The page should now load without errors.
>     test->loadURI(kHttpsServer->getURIForPath("/test-tls/").data());
>     test->waitUntilTitleChanged();
>@@ -275,7 +346,11 @@ static void testLoadFailedWithTLSErrors(TLSErrorsTest* test, gconstpointer)
>     g_assert_cmpint(test->m_loadEvents[2], ==, LoadTrackingTest::LoadFinished);
>     g_assert_cmpstr(webkit_web_view_get_title(test->m_webView), ==, TLSExpectedSuccessTitle);
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
>+#endif
> }
> 
> class TLSSubresourceTest : public WebViewTest {
>@@ -334,8 +409,14 @@ public:
> 
> static void testSubresourceLoadFailedWithTLSErrors(TLSSubresourceTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#else
>     auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#endif
> 
>     assertIfSSLRequestProcessed = true;
>     test->loadURI(kHttpServer->getURIForPath("/").data());
>@@ -343,6 +424,13 @@ static void testSubresourceLoadFailedWithTLSErrors(TLSSubresourceTest* test, gco
>     g_assert_true(G_IS_TLS_CERTIFICATE(test->m_certificate.get()));
>     g_assert_cmpuint(test->m_tlsErrors, ==, G_TLS_CERTIFICATE_UNKNOWN_CA);
>     assertIfSSLRequestProcessed = false;
>+
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
>+#else
>+    webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
>+#endif
>+
> }
> 
> class WebSocketTest : public WebViewTest {
>@@ -420,9 +508,14 @@ public:
> 
> static void testWebSocketTLSErrors(WebSocketTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#else
>     auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#endif
> 
>     // First, check that insecure ws:// web sockets work fine.
>     unsigned events = test->connectToServerAndWaitForEvents(kHttpServer);
>@@ -440,13 +533,21 @@ static void testWebSocketTLSErrors(WebSocketTest* test, gconstpointer)
>     g_assert_true(events & WebSocketTest::EventFlags::DidClose);
> 
>     // Now try wss:// again, this time ignoring TLS errors.
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#endif
>     events = test->connectToServerAndWaitForEvents(kHttpsServer);
>     g_assert_true(events & WebSocketTest::EventFlags::DidServerCompleteHandshake);
>     g_assert_true(events & WebSocketTest::EventFlags::DidOpen);
>     g_assert_false(events & WebSocketTest::EventFlags::DidClose);
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
>+#endif
> }
> 
> class EphemeralSSLTest : public SSLTest {
>@@ -466,9 +567,15 @@ public:
> 
> static void testTLSErrorsEphemeral(EphemeralSSLTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    auto* networkSession = webkit_web_view_get_network_session(test->m_webView);
>+    g_assert_true(webkit_network_session_is_ephemeral(networkSession));
>+    g_assert_cmpint(webkit_network_session_get_tls_errors_policy(networkSession), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#else
>     auto* websiteDataManager = webkit_web_view_get_website_data_manager(test->m_webView);
>     g_assert_true(webkit_website_data_manager_is_ephemeral(websiteDataManager));
>     g_assert_cmpint(webkit_website_data_manager_get_tls_errors_policy(websiteDataManager), ==, WEBKIT_TLS_ERRORS_POLICY_FAIL);
>+#endif
> 
>     test->loadURI(kHttpsServer->getURIForPath("/").data());
>     test->waitUntilLoadFinished();
>@@ -564,9 +671,14 @@ public:
> static void testClientSideCertificate(ClientSideCertificateTest* test, gconstpointer)
> {
>     // Ignore server certificate errors.
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#else
>     auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#endif
> 
>     // Cancel the authentiation request.
>     test->loadURI(kHttpsServer->getURIForPath("/").data());
>@@ -650,7 +762,11 @@ static void testClientSideCertificate(ClientSideCertificateTest* test, gconstpoi
>     g_assert_cmpint(test->m_loadEvents[2], ==, LoadTrackingTest::LoadFinished);
>     test->m_loadEvents.clear();
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
>+#endif
> }
> 
> class WebSocketClientSideCertificateTest final : public WebSocketTest, public ClientSideCertificateTestBase {
>@@ -676,9 +792,14 @@ public:
> static void testWebSocketClientSideCertificate(WebSocketClientSideCertificateTest* test, gconstpointer)
> {
>     // Ignore server certificate errors.
>+#if ENABLE(2022_GLIB_API)
>+    WebKitTLSErrorsPolicy originalPolicy = webkit_network_session_get_tls_errors_policy(test->m_networkSession.get());
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#else
>     auto* websiteDataManager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     WebKitTLSErrorsPolicy originalPolicy = webkit_website_data_manager_get_tls_errors_policy(websiteDataManager);
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, WEBKIT_TLS_ERRORS_POLICY_IGNORE);
>+#endif
> 
>     // Try first without having the certificate in credential storage.
>     auto events = test->connectToServerAndWaitForEvents(kHttpsServer);
>@@ -698,7 +819,11 @@ static void testWebSocketClientSideCertificate(WebSocketClientSideCertificateTes
>     g_assert_true(events & WebSocketTest::EventFlags::DidOpen);
>     g_assert_false(events & WebSocketTest::EventFlags::DidClose);
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_tls_errors_policy(test->m_networkSession.get(), originalPolicy);
>+#else
>     webkit_website_data_manager_set_tls_errors_policy(websiteDataManager, originalPolicy);
>+#endif
> }
> #endif
> 
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFaviconDatabase.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFaviconDatabase.cpp
>index 7bbb4e0ccb0b..9f08856f3b0a 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFaviconDatabase.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFaviconDatabase.cpp
>@@ -1,3 +1,4 @@
>+
> /*
>  * Copyright (C) 2012, 2017 Igalia S.L.
>  *
>@@ -35,11 +36,15 @@ public:
>     MAKE_GLIB_TEST_FIXTURE(FaviconDatabaseTest);
> 
>     FaviconDatabaseTest()
>+#if ENABLE(2022_GLIB_API)
>+        : m_database(webkit_website_data_manager_get_favicon_database(webkit_network_session_get_website_data_manager(m_networkSession.get())))
>+#else
>         : m_database(webkit_web_context_get_favicon_database(m_webContext.get()))
>+#endif
>     {
>-        g_assert_true(WEBKIT_IS_FAVICON_DATABASE(m_database));
>-        assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_database));
>-        g_signal_connect(m_database, "favicon-changed", G_CALLBACK(faviconChangedCallback), this);
>+        g_assert_true(WEBKIT_IS_FAVICON_DATABASE(m_database.get()));
>+        assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_database.get()));
>+        g_signal_connect(m_database.get(), "favicon-changed", G_CALLBACK(faviconChangedCallback), this);
>     }
> 
>     ~FaviconDatabaseTest()
>@@ -47,15 +52,36 @@ public:
>         if (m_favicon)
>             cairo_surface_destroy(m_favicon);
> 
>-        g_signal_handlers_disconnect_matched(m_database, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
>+        g_signal_handlers_disconnect_matched(m_database.get(), G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
>+#if ENABLE(2022_GLIB_API)
>+        GUniquePtr<char> databaseDirectory(g_build_filename(Test::dataDirectory(), "icondatabase", nullptr));
>+        if (GDir* directory = g_dir_open(databaseDirectory.get(), 0, nullptr)) {
>+            const char* fileName;
>+            while ((fileName = g_dir_read_name(directory))) {
>+                GUniquePtr<char> filePath(g_build_filename(databaseDirectory.get(), fileName, nullptr));
>+                g_unlink(filePath.get());
>+            }
>+            g_dir_close(directory);
>+        }
>+        g_rmdir(databaseDirectory.get());
>+#endif
>     }
> 
>+#if !ENABLE(2022_GLIB_API)
>     void open(const char* directory)
>     {
>         GUniquePtr<char> databaseDirectory(g_build_filename(dataDirectory(), directory, nullptr));
>         webkit_web_context_set_favicon_database_directory(m_webContext.get(), databaseDirectory.get());
>         g_assert_cmpstr(databaseDirectory.get(), ==, webkit_web_context_get_favicon_database_directory(m_webContext.get()));
>     }
>+#else
>+    void close()
>+    {
>+        auto* manager = webkit_network_session_get_website_data_manager(m_networkSession.get());
>+        webkit_website_data_manager_set_favicons_enabled(manager, FALSE);
>+        g_assert_null(webkit_website_data_manager_get_favicon_database(manager));
>+    }
>+#endif
> 
>     static void faviconChangedCallback(WebKitFaviconDatabase* database, const char* pageURI, const char* faviconURI, FaviconDatabaseTest* test)
>     {
>@@ -89,7 +115,7 @@ public:
>     static void getFaviconCallback(GObject* sourceObject, GAsyncResult* result, void* data)
>     {
>         FaviconDatabaseTest* test = static_cast<FaviconDatabaseTest*>(data);
>-        test->m_favicon = webkit_favicon_database_get_favicon_finish(test->m_database, result, &test->m_error.outPtr());
>+        test->m_favicon = webkit_favicon_database_get_favicon_finish(test->m_database.get(), result, &test->m_error.outPtr());
>         test->quitMainLoop();
>     }
> 
>@@ -123,7 +149,7 @@ public:
>             m_favicon = nullptr;
>         }
> 
>-        webkit_favicon_database_get_favicon(m_database, pageURI, 0, getFaviconCallback, this);
>+        webkit_favicon_database_get_favicon(m_database.get(), pageURI, 0, getFaviconCallback, this);
>         g_main_loop_run(m_mainLoop);
>     }
> 
>@@ -136,7 +162,7 @@ public:
>         m_waitingForFaviconURI = false;
>     }
> 
>-    WebKitFaviconDatabase* m_database { nullptr };
>+    GRefPtr<WebKitFaviconDatabase> m_database;
>     cairo_surface_t* m_favicon { nullptr };
>     CString m_faviconURI;
>     GUniqueOutPtr<GError> m_error;
>@@ -184,18 +210,35 @@ static void serverCallback(SoupServer*, SoupServerMessage* message, const char*
> 
> static void testFaviconDatabaseInitialization(FaviconDatabaseTest* test, gconstpointer)
> {
>+    // In 2022 API favicons are enabled by default.
>+#if !ENABLE(2022_GLIB_API)
>     test->getFaviconForPageURIAndWaitUntilReady(kServer->getURIForPath("/foo").data());
>     g_assert_null(test->m_favicon);
>     g_assert_error(test->m_error.get(), WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED);
> 
>     test->open("testFaviconDatabaseInitialization");
>+#endif
>+
>+#if ENABLE(2022_GLIB_API)
>+    GUniquePtr<char> databaseFile(g_build_filename(Test::dataDirectory(), "icondatabase", "WebpageIcons.db", nullptr));
>+#else
>     GUniquePtr<char> databaseFile(g_build_filename(webkit_web_context_get_favicon_database_directory(test->m_webContext.get()), "WebpageIcons.db", nullptr));
>+#endif
>     g_assert_true(g_file_test(databaseFile.get(), G_FILE_TEST_IS_REGULAR));
>+
>+#if ENABLE(2022_GLIB_API)
>+    test->close();
>+    test->getFaviconForPageURIAndWaitUntilReady(kServer->getURIForPath("/foo").data());
>+    g_assert_null(test->m_favicon);
>+    g_assert_error(test->m_error.get(), WEBKIT_FAVICON_DATABASE_ERROR, WEBKIT_FAVICON_DATABASE_ERROR_NOT_INITIALIZED);
>+#endif
> }
> 
> static void testFaviconDatabaseGetFavicon(FaviconDatabaseTest* test, gconstpointer)
> {
>+#if !ENABLE(2022_GLIB_API)
>     test->open("testFaviconDatabaseGetFavicon");
>+#endif
> 
>     test->loadURI(kServer->getURIForPath("/foo").data());
>     test->waitUntilLoadFinishedAndFaviconChanged();
>@@ -249,7 +292,8 @@ static void ephemeralViewFaviconChanged(WebKitWebView* webView, GParamSpec*, Web
> 
> static void testFaviconDatabaseEphemeral(FaviconDatabaseTest* test, gconstpointer)
> {
>-    // If the context is ephemeral, the database is not created if it doesn't exist.
>+#if !ENABLE(2022_GLIB_API)
>+    // If the context is ephemeral, the database is not created.
>     GRefPtr<WebKitWebContext> ephemeralContext = adoptGRef(webkit_web_context_new_ephemeral());
>     GUniquePtr<char> databaseDirectory(g_build_filename(Test::dataDirectory(), "testFaviconDatabaseEphemeral", nullptr));
>     webkit_web_context_set_favicon_database_directory(ephemeralContext.get(), databaseDirectory.get());
>@@ -260,20 +304,38 @@ static void testFaviconDatabaseEphemeral(FaviconDatabaseTest* test, gconstpointe
> 
>     test->open("testFaviconDatabaseEphemeral");
>     g_assert_true(g_file_test(databaseFile.get(), G_FILE_TEST_EXISTS));
>+#endif
> 
>     test->loadURI(kServer->getURIForPath("/foo").data());
>     test->waitUntilLoadFinishedAndFaviconChanged();
> 
>     // An ephemeral web view doesn't write to the database.
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitNetworkSession> ephemeralSession = adoptGRef(webkit_network_session_new_ephemeral());
>+#endif
>     auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>-        "web-context", test->m_webContext.get(), "is-ephemeral", TRUE, nullptr));
>+        "web-context", test->m_webContext.get(),
>+#if ENABLE(2022_GLIB_API)
>+        "network-session", ephemeralSession.get(),
>+#else
>+        "is-ephemeral", TRUE,
>+#endif
>+       nullptr));
>     g_signal_connect(webView.get(), "notify::favicon", G_CALLBACK(ephemeralViewFaviconChanged), test);
>     webkit_web_view_load_uri(webView.get(), kServer->getURIForPath("/bar").data());
>     g_main_loop_run(test->m_mainLoop);
> 
>+#if ENABLE(2022_GLIB_API)
>+    auto* database = webkit_website_data_manager_get_favicon_database(webkit_network_session_get_website_data_manager(ephemeralSession.get()));
>+    // Persistent session database is not modified by ephemeral web views.
>+    g_assert_null(webkit_favicon_database_get_favicon_uri(test->m_database.get(), kServer->getURIForPath("/bar").data()));
>+#else
>+    auto* database = test->m_database.get();
>+#endif
>     // We get a favicon, but it's only in database memory cache.
>-    g_assert_nonnull(webkit_favicon_database_get_favicon_uri(test->m_database, kServer->getURIForPath("/bar").data()));
>+    g_assert_nonnull(webkit_favicon_database_get_favicon_uri(database, kServer->getURIForPath("/bar").data()));
> 
>+#if !ENABLE(2022_GLIB_API)
>     // If the database exists, it's used in read only mode for epeheral contexts.
>     ephemeralContext = adoptGRef(webkit_web_context_new_ephemeral());
>     webkit_web_context_set_favicon_database_directory(ephemeralContext.get(), databaseDirectory.get());
>@@ -283,22 +345,25 @@ static void testFaviconDatabaseEphemeral(FaviconDatabaseTest* test, gconstpointe
>     // Page URL loaded in ephemeral web view is not in the database.
>     g_assert_null(webkit_favicon_database_get_favicon_uri(ephemeralDatabase, kServer->getURIForPath("/bar").data()));
>     ephemeralContext = nullptr;
>+#endif
> }
> 
> void testFaviconDatabaseClear(FaviconDatabaseTest* test, gconstpointer)
> {
>+#if !ENABLE(2022_GLIB_API)
>     test->open("testFaviconDatabaseClear");
>+#endif
>     test->loadURI(kServer->getURIForPath("/foo").data());
>     test->waitUntilLoadFinishedAndFaviconChanged();
>     test->getFaviconForPageURIAndWaitUntilReady(kServer->getURIForPath("/foo").data());
>     g_assert_nonnull(test->m_favicon);
>-    g_assert_nonnull(webkit_favicon_database_get_favicon_uri(test->m_database, kServer->getURIForPath("/foo").data()));
>+    g_assert_nonnull(webkit_favicon_database_get_favicon_uri(test->m_database.get(), kServer->getURIForPath("/foo").data()));
> 
>-    webkit_favicon_database_clear(test->m_database);
>+    webkit_favicon_database_clear(test->m_database.get());
> 
>     test->getFaviconForPageURIAndWaitUntilReady(kServer->getURIForPath("/foo").data());
>     g_assert_null(test->m_favicon);
>-    g_assert_null(webkit_favicon_database_get_favicon_uri(test->m_database, kServer->getURIForPath("/foo").data()));
>+    g_assert_null(webkit_favicon_database_get_favicon_uri(test->m_database.get(), kServer->getURIForPath("/foo").data()));
> }
> 
> void beforeAll()
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitNetworkSession.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitNetworkSession.cpp
>new file mode 100644
>index 000000000000..dff672ae33e1
>--- /dev/null
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitNetworkSession.cpp
>@@ -0,0 +1,278 @@
>+
>+
>+/*
>+ * Copyright (C) 2023 Igalia S.L.
>+ *
>+ * This library is free software; you can redistribute it and/or
>+ * modify it under the terms of the GNU Lesser General Public
>+ * License as published by the Free Software Foundation; either
>+ * version 2,1 of the License, or (at your option) any later version.
>+ *
>+ * This library is distributed in the hope that it will be useful,
>+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
>+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>+ * Library General Public License for more details.
>+ *
>+ * You should have received a copy of the GNU Library General Public License
>+ * along with this library; see the file COPYING.LIB.  If not, write to
>+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
>+ * Boston, MA 02110-1301, USA.
>+ */
>+
>+#include "config.h"
>+
>+#include "WebKitTestServer.h"
>+#include "WebViewTest.h"
>+#include <libsoup/soup.h>
>+#include <wtf/glib/GRefPtr.h>
>+#include <wtf/glib/GUniquePtr.h>
>+
>+static WebKitTestServer* kServer;
>+
>+static void testNetworkSessionDefault(Test* test, gconstpointer)
>+{
>+    // Check there's a single instance of the default network session.
>+    g_assert_true(webkit_network_session_get_default() == webkit_network_session_get_default());
>+    g_assert_true(webkit_network_session_get_default() != test->m_networkSession.get());
>+}
>+
>+static void testNetworkSessionEphemeral(Test* test, gconstpointer)
>+{
>+    // By default network sessions are not ephemeral.
>+    g_assert_false(webkit_network_session_is_ephemeral(webkit_network_session_get_default()));
>+    g_assert_false(webkit_network_session_is_ephemeral(test->m_networkSession.get()));
>+
>+    WebKitWebsiteDataManager* manager = webkit_network_session_get_website_data_manager(webkit_network_session_get_default());
>+    g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
>+    g_assert_false(webkit_website_data_manager_is_ephemeral(manager));
>+    manager = webkit_network_session_get_website_data_manager(test->m_networkSession.get());
>+    g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
>+    g_assert_false(webkit_website_data_manager_is_ephemeral(manager));
>+
>+    auto webView = Test::adoptView(Test::createWebView());
>+    g_assert_true(webkit_web_view_get_network_session(webView.get()) == webkit_network_session_get_default());
>+
>+    webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>+#if PLATFORM(WPE)
>+        "backend", Test::createWebViewBackend(),
>+#endif
>+        "web-context", test->m_webContext.get(),
>+        "network-session", test->m_networkSession.get(),
>+        nullptr));
>+    g_assert_true(webkit_web_view_get_network_session(webView.get()) == test->m_networkSession.get());
>+
>+    GRefPtr<WebKitNetworkSession> session = adoptGRef(webkit_network_session_new_ephemeral());
>+    g_assert_true(webkit_network_session_is_ephemeral(session.get()));
>+    manager = webkit_network_session_get_website_data_manager(session.get());
>+    g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
>+    g_assert_true(webkit_website_data_manager_is_ephemeral(manager));
>+    g_assert_true(webkit_web_view_get_network_session(webView.get()) != session.get());
>+
>+    webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>+#if PLATFORM(WPE)
>+        "backend", Test::createWebViewBackend(),
>+#endif
>+        "web-context", test->m_webContext.get(),
>+        "network-session", session.get(),
>+        nullptr));
>+    g_assert_true(webkit_web_view_get_network_session(webView.get()) == session.get());
>+}
>+
>+static void serverCallback(SoupServer* server, SoupServerMessage* message, const char* path, GHashTable*, gpointer)
>+{
>+    if (soup_server_message_get_method(message) != SOUP_METHOD_GET) {
>+        soup_server_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED, nullptr);
>+        return;
>+    }
>+
>+    auto* responseBody = soup_server_message_get_response_body(message);
>+
>+    if (g_str_equal(path, "/echoPort")) {
>+        char* port = g_strdup_printf("%u", g_inet_socket_address_get_port(G_INET_SOCKET_ADDRESS(soup_server_message_get_local_address(message))));
>+        soup_message_body_append(responseBody, SOUP_MEMORY_TAKE, port, strlen(port));
>+        soup_message_body_complete(responseBody);
>+        soup_server_message_set_status(message, SOUP_STATUS_OK, nullptr);
>+    } else
>+        soup_server_message_set_status(message, SOUP_STATUS_NOT_FOUND, nullptr);
>+}
>+
>+class ProxyTest : public WebViewTest {
>+public:
>+    MAKE_GLIB_TEST_FIXTURE(ProxyTest);
>+
>+    enum class WebSocketServerType {
>+        Unknown,
>+        NoProxy,
>+        Proxy
>+    };
>+
>+    static void webSocketProxyServerCallback(SoupServer*, SoupServerMessage*, const char* path, SoupWebsocketConnection*, gpointer userData)
>+    {
>+        static_cast<ProxyTest*>(userData)->webSocketConnected(ProxyTest::WebSocketServerType::Proxy);
>+    }
>+
>+    ProxyTest()
>+    {
>+        // This "proxy server" is actually just a different instance of the main
>+        // test server (kServer), listening on a different port. Requests
>+        // will not actually be proxied to kServer because proxyServer is not
>+        // actually a proxy server. We're testing whether the proxy settings
>+        // work, not whether we can write a soup proxy server.
>+        m_proxyServer.run(serverCallback);
>+        g_assert_false(m_proxyServer.baseURL().isNull());
>+
>+        m_proxyServer.addWebSocketHandler(webSocketProxyServerCallback, this);
>+        g_assert_false(m_proxyServer.baseWebSocketURL().isNull());
>+    }
>+
>+    CString loadURIAndGetMainResourceData(const char* uri)
>+    {
>+        loadURI(uri);
>+        waitUntilLoadFinished();
>+        size_t dataSize = 0;
>+        const char* data = mainResourceData(dataSize);
>+        return CString(data, dataSize);
>+    }
>+
>+    GUniquePtr<char> proxyServerPortAsString()
>+    {
>+        GUniquePtr<char> port(g_strdup_printf("%u", m_proxyServer.port()));
>+        return port;
>+    }
>+
>+    void webSocketConnected(WebSocketServerType serverType)
>+    {
>+        m_webSocketRequestReceived = serverType;
>+        quitMainLoop();
>+    }
>+
>+    WebSocketServerType createWebSocketAndWaitUntilConnected()
>+    {
>+        m_webSocketRequestReceived = WebSocketServerType::Unknown;
>+        GUniquePtr<char> createWebSocket(g_strdup_printf("var ws = new WebSocket('%s');", kServer->getWebSocketURIForPath("/foo").data()));
>+        runJavaScriptAndWaitUntilFinished(createWebSocket.get(), nullptr);
>+        if (m_webSocketRequestReceived == WebSocketServerType::Unknown)
>+            g_main_loop_run(m_mainLoop);
>+        return m_webSocketRequestReceived;
>+    }
>+
>+    WebKitTestServer m_proxyServer;
>+    WebSocketServerType m_webSocketRequestReceived { WebSocketServerType::Unknown };
>+};
>+
>+static void webSocketServerCallback(SoupServer*, SoupServerMessage*, const char*, SoupWebsocketConnection*, gpointer userData)
>+{
>+    static_cast<ProxyTest*>(userData)->webSocketConnected(ProxyTest::WebSocketServerType::NoProxy);
>+}
>+
>+static void ephemeralViewloadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent, ProxyTest* test)
>+{
>+    if (loadEvent != WEBKIT_LOAD_FINISHED)
>+        return;
>+    g_signal_handlers_disconnect_by_func(webView, reinterpret_cast<void*>(ephemeralViewloadChanged), test);
>+    test->quitMainLoop();
>+}
>+
>+static void testNetworkSessionProxySettings(ProxyTest* test, gconstpointer)
>+{
>+    // Proxy URI is unset by default. Requests to kServer should be received by kServer.
>+    GUniquePtr<char> serverPortAsString(g_strdup_printf("%u", kServer->port()));
>+    auto mainResourceData = test->loadURIAndGetMainResourceData(kServer->getURIForPath("/echoPort").data());
>+    ASSERT_CMP_CSTRING(mainResourceData, ==, serverPortAsString.get());
>+
>+    // WebSocket requests should also be received by kServer.
>+    kServer->addWebSocketHandler(webSocketServerCallback, test);
>+    auto serverType = test->createWebSocketAndWaitUntilConnected();
>+    g_assert_true(serverType == ProxyTest::WebSocketServerType::NoProxy);
>+
>+    // Set default proxy URI to point to proxyServer. Requests to kServer should be received by proxyServer instead.
>+    WebKitNetworkProxySettings* settings = webkit_network_proxy_settings_new(test->m_proxyServer.baseURL().string().utf8().data(), nullptr);
>+    webkit_network_session_set_proxy_settings(test->m_networkSession.get(), WEBKIT_NETWORK_PROXY_MODE_CUSTOM, settings);
>+    GUniquePtr<char> proxyServerPortAsString = test->proxyServerPortAsString();
>+    mainResourceData = test->loadURIAndGetMainResourceData(kServer->getURIForPath("/echoPort").data());
>+    ASSERT_CMP_CSTRING(mainResourceData, ==, proxyServerPortAsString.get());
>+
>+    // WebSocket requests should also be received by proxyServer.
>+    serverType = test->createWebSocketAndWaitUntilConnected();
>+    g_assert_true(serverType == ProxyTest::WebSocketServerType::Proxy);
>+
>+    // Proxy settings also affect ephemeral web views.
>+    GRefPtr<WebKitNetworkSession> ephemeralSession = adoptGRef(webkit_network_session_new_ephemeral());
>+    webkit_network_session_set_proxy_settings(ephemeralSession.get(), WEBKIT_NETWORK_PROXY_MODE_CUSTOM, settings);
>+    webkit_network_proxy_settings_free(settings);
>+    auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>+#if PLATFORM(WPE)
>+        "backend", Test::createWebViewBackend(),
>+#endif
>+        "web-context", test->m_webContext.get(),
>+        "network-session", ephemeralSession.get(),
>+        nullptr));
>+    g_assert_true(webkit_web_view_get_network_session(webView.get()) == ephemeralSession.get());
>+
>+    g_signal_connect(webView.get(), "load-changed", G_CALLBACK(ephemeralViewloadChanged), test);
>+    webkit_web_view_load_uri(webView.get(), kServer->getURIForPath("/echoPort").data());
>+    g_main_loop_run(test->m_mainLoop);
>+    WebKitWebResource* resource = webkit_web_view_get_main_resource(webView.get());
>+    g_assert_true(WEBKIT_IS_WEB_RESOURCE(resource));
>+    webkit_web_resource_get_data(resource, nullptr, [](GObject* object, GAsyncResult* result, gpointer userData) {
>+        size_t dataSize;
>+        GUniquePtr<char> data(reinterpret_cast<char*>(webkit_web_resource_get_data_finish(WEBKIT_WEB_RESOURCE(object), result, &dataSize, nullptr)));
>+        g_assert_nonnull(data);
>+        auto* test = static_cast<ProxyTest*>(userData);
>+        GUniquePtr<char> proxyServerPortAsString = test->proxyServerPortAsString();
>+        ASSERT_CMP_CSTRING(CString(data.get(), dataSize), ==, proxyServerPortAsString.get());
>+        test->quitMainLoop();
>+        }, test);
>+    g_main_loop_run(test->m_mainLoop);
>+
>+    // Remove the proxy. Requests to kServer should be received by kServer again.
>+    webkit_network_session_set_proxy_settings(test->m_networkSession.get(), WEBKIT_NETWORK_PROXY_MODE_NO_PROXY, nullptr);
>+    mainResourceData = test->loadURIAndGetMainResourceData(kServer->getURIForPath("/echoPort").data());
>+    ASSERT_CMP_CSTRING(mainResourceData, ==, serverPortAsString.get());
>+
>+    // Use a default proxy uri, but ignoring requests to localhost.
>+    static const char* ignoreHosts[] = { "localhost", nullptr };
>+    settings = webkit_network_proxy_settings_new(test->m_proxyServer.baseURL().string().utf8().data(), ignoreHosts);
>+    webkit_network_session_set_proxy_settings(test->m_networkSession.get(), WEBKIT_NETWORK_PROXY_MODE_CUSTOM, settings);
>+    mainResourceData = test->loadURIAndGetMainResourceData(kServer->getURIForPath("/echoPort").data());
>+    ASSERT_CMP_CSTRING(mainResourceData, ==, proxyServerPortAsString.get());
>+    GUniquePtr<char> localhostEchoPortURI(g_strdup_printf("http://localhost:%s/echoPort", serverPortAsString.get()));
>+    mainResourceData = test->loadURIAndGetMainResourceData(localhostEchoPortURI.get());
>+    ASSERT_CMP_CSTRING(mainResourceData, ==, serverPortAsString.get());
>+    webkit_network_proxy_settings_free(settings);
>+
>+    // Remove the proxy again to ensure next test is not using any previous values.
>+    webkit_network_session_set_proxy_settings(test->m_networkSession.get(), WEBKIT_NETWORK_PROXY_MODE_NO_PROXY, nullptr);
>+    mainResourceData = test->loadURIAndGetMainResourceData(kServer->getURIForPath("/echoPort").data());
>+    ASSERT_CMP_CSTRING(mainResourceData, ==, serverPortAsString.get());
>+
>+    // Use scheme specific proxy instead of the default.
>+    settings = webkit_network_proxy_settings_new(nullptr, nullptr);
>+    webkit_network_proxy_settings_add_proxy_for_scheme(settings, "http", test->m_proxyServer.baseURL().string().utf8().data());
>+    webkit_network_session_set_proxy_settings(test->m_networkSession.get(), WEBKIT_NETWORK_PROXY_MODE_CUSTOM, settings);
>+    mainResourceData = test->loadURIAndGetMainResourceData(kServer->getURIForPath("/echoPort").data());
>+    ASSERT_CMP_CSTRING(mainResourceData, ==, proxyServerPortAsString.get());
>+    webkit_network_proxy_settings_free(settings);
>+
>+    // Reset to use the default resolver.
>+    webkit_network_session_set_proxy_settings(test->m_networkSession.get(), WEBKIT_NETWORK_PROXY_MODE_DEFAULT, nullptr);
>+    mainResourceData = test->loadURIAndGetMainResourceData(kServer->getURIForPath("/echoPort").data());
>+    ASSERT_CMP_CSTRING(mainResourceData, ==, serverPortAsString.get());
>+
>+    kServer->removeWebSocketHandler();
>+}
>+
>+void beforeAll()
>+{
>+    kServer = new WebKitTestServer();
>+    kServer->run(serverCallback);
>+
>+    Test::add("WebKitNetworkSession", "default-session", testNetworkSessionDefault);
>+    Test::add("WebKitNetworkSession", "ephemeral", testNetworkSessionEphemeral);
>+    ProxyTest::add("WebKitNetworkSession", "proxy", testNetworkSessionProxySettings);
>+}
>+
>+void afterAll()
>+{
>+    delete kServer;
>+}
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp
>index 0bbd1a9365ef..28e7c5dc04e3 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebContext.cpp
>@@ -41,6 +41,7 @@ static void testWebContextDefault(Test* test, gconstpointer)
>     g_assert_true(webkit_web_context_get_default() != test->m_webContext.get());
> }
> 
>+#if !ENABLE(2022_GLIB_API)
> static void testWebContextEphemeral(Test* test, gconstpointer)
> {
>     // By default web contexts are not ephemeral.
>@@ -78,6 +79,7 @@ static void testWebContextEphemeral(Test* test, gconstpointer)
>     context = adoptGRef(webkit_web_context_new_with_website_data_manager(ephemeralManager.get()));
>     g_assert_true(webkit_web_context_is_ephemeral(context.get()));
> }
>+#endif
> 
> static const char* kBarHTML = "<html><body>Bar</body></html>";
> static const char* kEchoHTMLFormat = "<html><body>%s</body></html>";
>@@ -768,6 +770,7 @@ public:
> #endif
> };
> 
>+#if !ENABLE(2022_GLIB_API)
> #if SOUP_CHECK_VERSION(2, 61, 90)
> #if USE(SOUP2)
> static void webSocketServerCallback(SoupServer*, SoupWebsocketConnection*, const char*, SoupClientContext*, gpointer userData)
>@@ -881,6 +884,7 @@ static void testWebContextProxySettings(ProxyTest* test, gconstpointer)
>     kServer->removeWebSocketHandler();
> #endif
> }
>+#endif
> 
> class MemoryPressureTest : public WebViewTest {
> public:
>@@ -1066,7 +1070,9 @@ void beforeAll()
>     kServer->run(serverCallback);
> 
>     Test::add("WebKitWebContext", "default-context", testWebContextDefault);
>+#if !ENABLE(2022_GLIB_API)
>     Test::add("WebKitWebContext", "ephemeral", testWebContextEphemeral);
>+#endif
>     URISchemeTest::add("WebKitWebContext", "uri-scheme", testWebContextURIScheme);
>     // FIXME: implement spellchecker in WPE.
> #if PLATFORM(GTK)
>@@ -1075,7 +1081,9 @@ void beforeAll()
>     WebViewTest::add("WebKitWebContext", "languages", testWebContextLanguages);
>     SecurityPolicyTest::add("WebKitSecurityManager", "security-policy", testWebContextSecurityPolicy);
>     WebViewTest::add("WebKitSecurityManager", "file-xhr", testWebContextSecurityFileXHR);
>+#if !ENABLE(2022_GLIB_API)
>     ProxyTest::add("WebKitWebContext", "proxy", testWebContextProxySettings);
>+#endif
>     MemoryPressureTest::add("WebKitWebContext", "memory-pressure", testMemoryPressureSettings);
>     WebViewTest::add("WebKitWebContext", "timezone", testWebContextTimeZoneOverride);
>     WebViewTest::add("WebKitWebContext", "timezone-worker", testWebContextTimeZoneOverrideInWorker);
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebView.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebView.cpp
>index 4d96091e2c60..6bf8dc792733 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebView.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebKitWebView.cpp
>@@ -219,11 +219,19 @@ static void ephemeralViewloadChanged(WebKitWebView* webView, WebKitLoadEvent loa
> 
> static void testWebViewEphemeral(WebViewTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    auto* networkSession = webkit_web_view_get_network_session(test->m_webView);
>+    g_assert_false(webkit_network_session_is_ephemeral(networkSession));
>+    auto* manager = webkit_network_session_get_website_data_manager(networkSession);
>+    g_assert_false(webkit_website_data_manager_is_ephemeral(manager));
>+    GRefPtr<WebKitNetworkSession> ephemeralSession = adoptGRef(webkit_network_session_new_ephemeral());
>+#else
>     g_assert_false(webkit_web_view_is_ephemeral(test->m_webView));
>     g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(test->m_webView)));
>     auto* manager = webkit_web_context_get_website_data_manager(test->m_webContext.get());
>     g_assert_false(webkit_website_data_manager_is_ephemeral(manager));
>     g_assert_true(webkit_web_view_get_website_data_manager(test->m_webView) == manager);
>+#endif
>     webkit_website_data_manager_clear(manager, WEBKIT_WEBSITE_DATA_DISK_CACHE, 0, nullptr, [](GObject* manager, GAsyncResult* result, gpointer userData) {
>         webkit_website_data_manager_clear_finish(WEBKIT_WEBSITE_DATA_MANAGER(manager), result, nullptr);
>         static_cast<WebViewTest*>(userData)->quitMainLoop();
>@@ -236,11 +244,20 @@ static void testWebViewEphemeral(WebViewTest* test, gconstpointer)
>         "backend", Test::createWebViewBackend(),
> #endif
>         "web-context", webkit_web_view_get_context(test->m_webView),
>+#if ENABLE(2022_GLIB_API)
>+        "network-session", ephemeralSession.get(),
>+#else
>         "is-ephemeral", TRUE,
>+#endif
>         nullptr));
>+#if ENABLE(2022_GLIB_API)
>+    g_assert_true(webkit_network_session_is_ephemeral(webkit_web_view_get_network_session(webView.get())));
>+    g_assert_true(webkit_web_view_get_network_session(webView.get()) != networkSession);
>+#else
>     g_assert_true(webkit_web_view_is_ephemeral(webView.get()));
>     g_assert_false(webkit_web_context_is_ephemeral(webkit_web_view_get_context(webView.get())));
>     g_assert_true(webkit_web_view_get_website_data_manager(webView.get()) != manager);
>+#endif
> 
>     g_signal_connect(webView.get(), "load-changed", G_CALLBACK(ephemeralViewloadChanged), test);
>     webkit_web_view_load_uri(webView.get(), gServer->getURIForPath("/").data());
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebsiteData.cpp b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebsiteData.cpp
>index 9d4dbb0591ef..43fe46369b63 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebsiteData.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGLib/TestWebsiteData.cpp
>@@ -104,9 +104,12 @@ class WebsiteDataTest : public WebViewTest {
> public:
>     MAKE_GLIB_TEST_FIXTURE(WebsiteDataTest);
> 
>-
>     WebsiteDataTest()
>+#if ENABLE(2022_GLIB_API)
>+        : m_manager(webkit_network_session_get_website_data_manager(webkit_web_view_get_network_session(m_webView)))
>+#else
>         : m_manager(webkit_web_context_get_website_data_manager(webkit_web_view_get_context(m_webView)))
>+#endif
>     {
>         g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(m_manager));
>         assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_manager));
>@@ -160,10 +163,11 @@ public:
>     GList* m_dataList { nullptr };
> };
> 
>-#if !ENABLE(2022_GLIB_API)
> static void testWebsiteDataConfiguration(WebsiteDataTest* test, gconstpointer)
> {
>+#if !ENABLE(2022_GLIB_API)
>     ALLOW_DEPRECATED_DECLARATIONS_BEGIN
>+#endif
> 
>     g_assert_cmpstr(webkit_website_data_manager_get_base_data_directory(test->m_manager), ==, Test::dataDirectory());
>     g_assert_cmpstr(webkit_website_data_manager_get_base_cache_directory(test->m_manager), ==, Test::dataDirectory());
>@@ -172,7 +176,9 @@ static void testWebsiteDataConfiguration(WebsiteDataTest* test, gconstpointer)
>     test->waitUntilLoadFinished();
>     test->runJavaScriptAndWaitUntilFinished("window.localStorage.myproperty = 42;", nullptr);
>     GUniquePtr<char> localStorageDirectory(g_build_filename(Test::dataDirectory(), "localstorage", nullptr));
>+#if !ENABLE(2022_GLIB_API)
>     g_assert_cmpstr(localStorageDirectory.get(), ==, webkit_website_data_manager_get_local_storage_directory(test->m_manager));
>+#endif
>     test->assertFileIsCreated(localStorageDirectory.get());
>     g_assert_true(g_file_test(localStorageDirectory.get(), G_FILE_TEST_IS_DIR));
>     test->runJavaScriptAndWaitUntilFinished("window.localStorage.clear();", nullptr);
>@@ -181,37 +187,51 @@ static void testWebsiteDataConfiguration(WebsiteDataTest* test, gconstpointer)
>     test->waitUntilLoadFinished();
>     test->runJavaScriptAndWaitUntilFinished("window.indexedDB.open('TestDatabase');", nullptr);
>     GUniquePtr<char> indexedDBDirectory(g_build_filename(Test::dataDirectory(), "databases", "indexeddb", nullptr));
>+#if !ENABLE(2022_GLIB_API)
>     g_assert_cmpstr(indexedDBDirectory.get(), ==, webkit_website_data_manager_get_indexeddb_directory(test->m_manager));
>+#endif
>     test->assertFileIsCreated(indexedDBDirectory.get());
>     g_assert_true(g_file_test(indexedDBDirectory.get(), G_FILE_TEST_IS_DIR));
> 
>     test->loadURI(kServer->getURIForPath("/appcache").data());
>     test->waitUntilLoadFinished();
>     GUniquePtr<char> applicationCacheDirectory(g_build_filename(Test::dataDirectory(), "applications", nullptr));
>+#if !ENABLE(2022_GLIB_API)
>     g_assert_cmpstr(applicationCacheDirectory.get(), ==, webkit_website_data_manager_get_offline_application_cache_directory(test->m_manager));
>+#endif
>     GUniquePtr<char> applicationCacheDatabase(g_build_filename(applicationCacheDirectory.get(), "ApplicationCache.db", nullptr));
>     test->assertFileIsCreated(applicationCacheDatabase.get());
> 
>     GUniquePtr<char> diskCacheDirectory(g_build_filename(Test::dataDirectory(), nullptr));
>+#if !ENABLE(2022_GLIB_API)
>     g_assert_cmpstr(diskCacheDirectory.get(), ==, webkit_website_data_manager_get_disk_cache_directory(test->m_manager));
>+#endif
>     g_assert_true(g_file_test(diskCacheDirectory.get(), G_FILE_TEST_IS_DIR));
> 
>     GUniquePtr<char> hstsCacheDirectory(g_build_filename(Test::dataDirectory(), nullptr));
>+#if !ENABLE(2022_GLIB_API)
>     g_assert_cmpstr(hstsCacheDirectory.get(), ==, webkit_website_data_manager_get_hsts_cache_directory(test->m_manager));
>+#endif
>     g_assert_true(g_file_test(hstsCacheDirectory.get(), G_FILE_TEST_IS_DIR));
> 
>+#if !ENABLE(2022_GLIB_API)
>     GUniquePtr<char> itpDirectory(g_build_filename(Test::dataDirectory(), "itp", nullptr));
>     g_assert_cmpstr(itpDirectory.get(), ==, webkit_website_data_manager_get_itp_directory(test->m_manager));
>+#endif
> 
>     test->runJavaScriptAndWaitUntilFinished("navigator.serviceWorker.register('./some-dummy.js');", nullptr);
>     GUniquePtr<char> swRegistrationsDirectory(g_build_filename(Test::dataDirectory(), "serviceworkers", nullptr));
>+#if !ENABLE(2022_GLIB_API)
>     g_assert_cmpstr(swRegistrationsDirectory.get(), ==, webkit_website_data_manager_get_service_worker_registrations_directory(test->m_manager));
>+#endif
>     test->assertFileIsCreated(swRegistrationsDirectory.get());
>     g_assert_true(g_file_test(swRegistrationsDirectory.get(), G_FILE_TEST_IS_DIR));
> 
>     test->runJavaScriptAndWaitUntilFinished("let domCacheOpened = false; caches.open('my-cache').then(() => { domCacheOpened = true});", nullptr);
>     GUniquePtr<char> domCacheDirectory(g_build_filename(Test::dataDirectory(), "CacheStorage", nullptr));
>+#if !ENABLE(2022_GLIB_API)
>     g_assert_cmpstr(domCacheDirectory.get(), ==, webkit_website_data_manager_get_dom_cache_directory(test->m_manager));
>+#endif
>     test->assertFileIsCreated(domCacheDirectory.get());
>     g_assert_true(g_file_test(domCacheDirectory.get(), G_FILE_TEST_IS_DIR));
> 
>@@ -226,10 +246,17 @@ static void testWebsiteDataConfiguration(WebsiteDataTest* test, gconstpointer)
>     test->clear(persistentCaches, 0);
>     g_assert_null(test->fetch(persistentCaches));
> 
>-    // The default context should have a different manager with different configuration.
>-    WebKitWebsiteDataManager* defaultManager = webkit_web_context_get_website_data_manager(webkit_web_context_get_default());
>+    // The default context or session should have a different manager with different configuration.
>+#if ENABLE(2022_GLIB_API)
>+    auto* defaultManager = webkit_network_session_get_website_data_manager(webkit_network_session_get_default());
>+#else
>+    auto* defaultManager = webkit_web_context_get_website_data_manager(webkit_web_context_get_default());
>+#endif
>     g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(defaultManager));
>     g_assert_true(test->m_manager != defaultManager);
>+    g_assert_cmpstr(webkit_website_data_manager_get_base_data_directory(test->m_manager), !=, webkit_website_data_manager_get_base_data_directory(defaultManager));
>+    g_assert_cmpstr(webkit_website_data_manager_get_base_cache_directory(test->m_manager), !=, webkit_website_data_manager_get_base_cache_directory(defaultManager));
>+#if !ENABLE(2022_GLIB_API)
>     g_assert_cmpstr(webkit_website_data_manager_get_local_storage_directory(test->m_manager), !=, webkit_website_data_manager_get_local_storage_directory(defaultManager));
>     g_assert_cmpstr(webkit_website_data_manager_get_indexeddb_directory(test->m_manager), !=, webkit_website_data_manager_get_indexeddb_directory(defaultManager));
>     g_assert_cmpstr(webkit_website_data_manager_get_disk_cache_directory(test->m_manager), !=, webkit_website_data_manager_get_disk_cache_directory(defaultManager));
>@@ -238,7 +265,9 @@ static void testWebsiteDataConfiguration(WebsiteDataTest* test, gconstpointer)
>     g_assert_cmpstr(webkit_website_data_manager_get_itp_directory(test->m_manager), !=, webkit_website_data_manager_get_itp_directory(defaultManager));
>     g_assert_cmpstr(webkit_website_data_manager_get_service_worker_registrations_directory(test->m_manager), !=, webkit_website_data_manager_get_service_worker_registrations_directory(defaultManager));
>     g_assert_cmpstr(webkit_website_data_manager_get_dom_cache_directory(test->m_manager), !=, webkit_website_data_manager_get_dom_cache_directory(defaultManager));
>+#endif
> 
>+#if !ENABLE(2022_GLIB_API)
>     // Any specific configuration provided takes precedence over base dirs.
>     indexedDBDirectory.reset(g_build_filename(Test::dataDirectory(), "mycustomindexeddb", nullptr));
>     applicationCacheDirectory.reset(g_build_filename(Test::dataDirectory(), "mycustomappcache", nullptr));
>@@ -258,8 +287,8 @@ static void testWebsiteDataConfiguration(WebsiteDataTest* test, gconstpointer)
>     g_assert_cmpstr(webkit_website_data_manager_get_disk_cache_directory(baseDataManager.get()), ==, diskCacheDirectory.get());
> 
>     ALLOW_DEPRECATED_DECLARATIONS_END
>-}
> #endif
>+}
> 
> static void ephemeralViewloadChanged(WebKitWebView* webView, WebKitLoadEvent loadEvent, WebViewTest* test)
> {
>@@ -271,8 +300,13 @@ static void ephemeralViewloadChanged(WebKitWebView* webView, WebKitLoadEvent loa
> 
> static void testWebsiteDataEphemeral(WebViewTest* test, gconstpointer)
> {
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitNetworkSession> session = adoptGRef(webkit_network_session_new_ephemeral());
>+    GRefPtr<WebKitWebsiteDataManager> manager = webkit_network_session_get_website_data_manager(session.get());
>+#else
>     GRefPtr<WebKitWebsiteDataManager> manager = adoptGRef(webkit_website_data_manager_new_ephemeral());
>     g_assert_true(webkit_website_data_manager_is_ephemeral(manager.get()));
>+#endif
>     g_assert_null(webkit_website_data_manager_get_base_data_directory(manager.get()));
>     g_assert_null(webkit_website_data_manager_get_base_cache_directory(manager.get()));
> 
>@@ -286,22 +320,35 @@ static void testWebsiteDataEphemeral(WebViewTest* test, gconstpointer)
>     g_assert_null(webkit_website_data_manager_get_itp_directory(manager.get()));
>     g_assert_null(webkit_website_data_manager_get_service_worker_registrations_directory(manager.get()));
>     ALLOW_DEPRECATED_DECLARATIONS_END
>-#endif
> 
>     // Configuration is ignored when is-ephemeral is used.
>     manager = adoptGRef(WEBKIT_WEBSITE_DATA_MANAGER(g_object_new(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, "base-data-directory", Test::dataDirectory(), "is-ephemeral", TRUE, nullptr)));
>     g_assert_true(webkit_website_data_manager_is_ephemeral(manager.get()));
>     g_assert_null(webkit_website_data_manager_get_base_data_directory(manager.get()));
>+#endif
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_itp_enabled(session.get(), TRUE);
>+    g_assert_true(webkit_network_session_get_itp_enabled(session.get()));
>+#else
>     webkit_website_data_manager_set_itp_enabled(manager.get(), TRUE);
>-    g_assert(webkit_website_data_manager_get_itp_enabled(manager.get()));
>+    g_assert_true(webkit_website_data_manager_get_itp_enabled(manager.get()));
>+#endif
> 
>     // Non persistent data can be queried in an ephemeral manager.
>+#if ENABLE(2022_GLIB_API)
>+    auto webView = Test::adoptView(g_object_new(WEBKIT_TYPE_WEB_VIEW,
>+        "web-context", webkit_web_view_get_context(test->m_webView),
>+        "network-session", session.get(),
>+        nullptr));
>+    g_assert_true(webkit_web_view_get_network_session(webView.get()) == session.get());
>+#else
>     GRefPtr<WebKitWebContext> webContext = adoptGRef(webkit_web_context_new_with_website_data_manager(manager.get()));
>     g_assert_true(webkit_web_context_is_ephemeral(webContext.get()));
>     auto webView = Test::adoptView(Test::createWebView(webContext.get()));
>     g_assert_true(webkit_web_view_is_ephemeral(webView.get()));
>     g_assert_true(webkit_web_view_get_website_data_manager(webView.get()) == manager.get());
>+#endif
> 
>     g_signal_connect(webView.get(), "load-changed", G_CALLBACK(ephemeralViewloadChanged), test);
>     webkit_web_view_load_uri(webView.get(), kServer->getURIForPath("/empty").data());
>@@ -325,7 +372,11 @@ static void testWebsiteDataEphemeral(WebViewTest* test, gconstpointer)
>     }, test);
>     g_main_loop_run(test->m_mainLoop);
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_itp_enabled(session.get(), FALSE);
>+#else
>     webkit_website_data_manager_set_itp_enabled(manager.get(), FALSE);
>+#endif
> }
> 
> static void testWebsiteDataCache(WebsiteDataTest* test, gconstpointer)
>@@ -682,31 +733,37 @@ static void testWebsiteDataDeviceIdHashSalt(WebsiteDataTest* test, gconstpointer
>     webkit_settings_set_enable_mock_capture_devices(settings, enabled);
> }
> 
>-#if !ENABLE(2022_GLIB_API)
> static void testWebsiteDataITP(WebsiteDataTest* test, gconstpointer)
> {
>-    ALLOW_DEPRECATED_DECLARATIONS_BEGIN
>-    const char* itpDirectory = webkit_website_data_manager_get_itp_directory(test->m_manager);
>-    ALLOW_DEPRECATED_DECLARATIONS_END
>-    GUniquePtr<char> itpDatabaseFile(g_build_filename(itpDirectory, "observations.db", nullptr));
>+    GUniquePtr<char> itpDirectory(g_build_filename(Test::dataDirectory(), "itp", nullptr));
>+    GUniquePtr<char> itpDatabaseFile(g_build_filename(itpDirectory.get(), "observations.db", nullptr));
> 
>     // Delete any previous data.
>     g_unlink(itpDatabaseFile.get());
>-    g_rmdir(itpDirectory);
>+    g_rmdir(itpDirectory.get());
> 
>+#if ENABLE(2022_GLIB_API)
>+    g_assert_false(webkit_network_session_get_itp_enabled(test->m_networkSession.get()));
>+#else
>     g_assert_false(webkit_website_data_manager_get_itp_enabled(test->m_manager));
>+#endif
>     test->loadURI(kServer->getURIForPath("/empty").data());
>     test->waitUntilLoadFinished();
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_itp_enabled(test->m_networkSession.get(), TRUE);
>+    g_assert_true(webkit_network_session_get_itp_enabled(test->m_networkSession.get()));
>+#else
>     webkit_website_data_manager_set_itp_enabled(test->m_manager, TRUE);
>     g_assert_true(webkit_website_data_manager_get_itp_enabled(test->m_manager));
>-    g_assert_false(g_file_test(itpDirectory, G_FILE_TEST_IS_DIR));
>+#endif
>+    g_assert_false(g_file_test(itpDirectory.get(), G_FILE_TEST_IS_DIR));
>     g_assert_false(g_file_test(itpDatabaseFile.get(), G_FILE_TEST_IS_REGULAR));
> 
>     test->loadURI(kServer->getURIForPath("/empty").data());
>     test->waitUntilLoadFinished();
>     test->assertFileIsCreated(itpDatabaseFile.get());
>-    g_assert_true(g_file_test(itpDirectory, G_FILE_TEST_IS_DIR));
>+    g_assert_true(g_file_test(itpDirectory.get(), G_FILE_TEST_IS_DIR));
>     g_assert_true(g_file_test(itpDatabaseFile.get(), G_FILE_TEST_IS_REGULAR));
> 
>     // Give some time for the database to be updated.
>@@ -731,12 +788,16 @@ static void testWebsiteDataITP(WebsiteDataTest* test, gconstpointer)
>     static const WebKitWebsiteDataTypes cacheAndITP = static_cast<WebKitWebsiteDataTypes>(WEBKIT_WEBSITE_DATA_ITP | WEBKIT_WEBSITE_DATA_MEMORY_CACHE | WEBKIT_WEBSITE_DATA_DISK_CACHE);
>     test->clear(cacheAndITP, 0);
> 
>+#if ENABLE(2022_GLIB_API)
>+    webkit_network_session_set_itp_enabled(test->m_networkSession.get(), FALSE);
>+    g_assert_false(webkit_network_session_get_itp_enabled(test->m_networkSession.get()));
>+#else
>     webkit_website_data_manager_set_itp_enabled(test->m_manager, FALSE);
>     g_assert_false(webkit_website_data_manager_get_itp_enabled(test->m_manager));
>+#endif
> 
>-    g_rmdir(itpDirectory);
>+    g_rmdir(itpDirectory.get());
> }
>-#endif
> 
> static void testWebsiteDataServiceWorkerRegistrations(WebsiteDataTest* test, gconstpointer)
> {
>@@ -814,13 +875,21 @@ public:
>         webkit_memory_pressure_settings_set_kill_threshold(settings, 1);
>         webkit_memory_pressure_settings_set_strict_threshold(settings, 0.75);
>         webkit_memory_pressure_settings_set_conservative_threshold(settings, 0.5);
>+#if ENABLE(2022_GLIB_API)
>+        webkit_network_session_set_memory_pressure_settings(settings);
>+#else
>         webkit_website_data_manager_set_memory_pressure_settings(settings);
>+#endif
>         webkit_memory_pressure_settings_free(settings);
>     }
> 
>     static void teardown()
>     {
>+#if ENABLE(2022_GLIB_API)
>+        webkit_network_session_set_memory_pressure_settings(nullptr);
>+#else
>         webkit_website_data_manager_set_memory_pressure_settings(nullptr);
>+#endif
>     }
> 
>     static gboolean loadFailedCallback(WebKitWebView* webView, WebKitLoadEvent loadEvent, const char* failingURI, GError* error, MemoryPressureTest* test)
>@@ -859,9 +928,7 @@ void beforeAll()
>     prepopulateHstsData();
> #endif
> 
>-#if !ENABLE(2022_GLIB_API)
>     WebsiteDataTest::add("WebKitWebsiteData", "configuration", testWebsiteDataConfiguration);
>-#endif
>     WebViewTest::add("WebKitWebsiteData", "ephemeral", testWebsiteDataEphemeral);
>     WebsiteDataTest::add("WebKitWebsiteData", "cache", testWebsiteDataCache);
>     WebsiteDataTest::add("WebKitWebsiteData", "storage", testWebsiteDataStorage);
>@@ -872,10 +939,7 @@ void beforeAll()
>     WebsiteDataTest::add("WebKitWebsiteData", "hsts", testWebsiteDataHsts);
> #endif
>     WebsiteDataTest::add("WebKitWebsiteData", "deviceidhashsalt", testWebsiteDataDeviceIdHashSalt);
>-#if !ENABLE(2022_GLIB_API)
>-    // FIXME: find a way to test this without deprecated API.
>     WebsiteDataTest::add("WebKitWebsiteData", "itp", testWebsiteDataITP);
>-#endif
>     WebsiteDataTest::add("WebKitWebsiteData", "service-worker-registrations", testWebsiteDataServiceWorkerRegistrations);
>     WebsiteDataTest::add("WebKitWebsiteData", "dom-cache", testWebsiteDataDOMCache);
>     MemoryPressureTest::add("WebKitWebsiteData", "memory-pressure", testMemoryPressureSettings);
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitGtk/TestAutocleanups.cpp b/Tools/TestWebKitAPI/Tests/WebKitGtk/TestAutocleanups.cpp
>index 420505f4e24e..dcc4df9b4091 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitGtk/TestAutocleanups.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKitGtk/TestAutocleanups.cpp
>@@ -36,9 +36,15 @@ static void testUIProcessAutocleanups(WebViewTest* test, gconstpointer)
>     g_assert_true(WEBKIT_IS_WEB_CONTEXT(context));
>     test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(context));
> 
>+#if ENABLE(2022_GLIB_API)
>+    g_autoptr(WebKitNetworkSession) session = webkit_network_session_new(nullptr, nullptr);
>+    g_assert_true(WEBKIT_IS_NETWORK_SESSION(session));
>+    test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(session));
>+#else
>     g_autoptr(WebKitWebsiteDataManager) manager = webkit_website_data_manager_new(nullptr);
>     g_assert_true(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
>-    test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(context));
>+    test->assertObjectIsDeletedWhenTestFinishes(G_OBJECT(manager));
>+#endif
> 
>     g_autoptr(WebKitUserScript) userScript = webkit_user_script_new("",
>         WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES, WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
>diff --git a/Tools/TestWebKitAPI/glib/CMakeLists.txt b/Tools/TestWebKitAPI/glib/CMakeLists.txt
>index 0957dde79361..d37fda42e1e7 100644
>--- a/Tools/TestWebKitAPI/glib/CMakeLists.txt
>+++ b/Tools/TestWebKitAPI/glib/CMakeLists.txt
>@@ -144,6 +144,7 @@ ADD_WK2_TEST_WEB_EXTENSION(WebProcessTest ${WebKitGLibAPIWebProcessTests})
> ADD_WK2_TEST(TestAuthentication ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestAuthentication.cpp)
> ADD_WK2_TEST(TestAutomationSession ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestAutomationSession.cpp)
> ADD_WK2_TEST(TestBackForwardList ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestBackForwardList.cpp)
>+ADD_WK2_TEST(TestCookieManager ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp)
> ADD_WK2_TEST(TestDownloads ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestDownloads.cpp)
> ADD_WK2_TEST(TestWebKitFindController ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestWebKitFindController.cpp)
> ADD_WK2_TEST(TestEditor ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestEditor.cpp)
>@@ -168,9 +169,8 @@ ADD_WK2_TEST(TestDOMElement ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestDOME
> ADD_WK2_TEST(TestGeolocationManager ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestGeolocationManager.cpp)
> ADD_WK2_TEST(TestInputMethodContext ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestInputMethodContext.cpp)
> 
>-# FIXME: Enable for WPE and GTK4
>-if (PORT STREQUAL "GTK" AND NOT USE_GTK4)
>-    ADD_WK2_TEST(TestCookieManager ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestCookieManager.cpp)
>+if (ENABLE_2022_GLIB_API)
>+    ADD_WK2_TEST(TestWebKitNetworkSession ${TOOLS_DIR}/TestWebKitAPI/Tests/WebKitGLib/TestWebKitNetworkSession.cpp)
> endif ()
> 
> macro(ADD_WPE_QT_TEST test_name)
>diff --git a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.cpp b/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.cpp
>index 39741746a756..a0c0b53bd4d5 100644
>--- a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.cpp
>+++ b/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.cpp
>@@ -127,6 +127,8 @@ int main(int argc, char** argv)
>     g_set_prgname(FileSystem::currentExecutableName().data());
>     g_setenv("WEBKIT_EXEC_PATH", WEBKIT_EXEC_PATH, FALSE);
>     g_setenv("WEBKIT_INJECTED_BUNDLE_PATH", WEBKIT_INJECTED_BUNDLE_PATH, FALSE);
>+    // Sandbox requires using GApplication.
>+    g_setenv("WEBKIT_DISABLE_SANDBOX_THIS_IS_DANGEROUS", "1", TRUE);
>     g_setenv("LC_ALL", "C", TRUE);
>     g_setenv("GIO_USE_VFS", "local", TRUE);
>     g_setenv("GSETTINGS_BACKEND", "memory", TRUE);
>diff --git a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h b/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h
>index 0ceba0dc4d53..b0bf3b2a2ef0 100644
>--- a/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h
>+++ b/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h
>@@ -120,6 +120,12 @@ public:
> 
>     Test()
>     {
>+#if ENABLE(2022_GLIB_API)
>+        m_networkSession = adoptGRef(webkit_network_session_new(dataDirectory(), dataDirectory()));
>+        assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_networkSession.get()));
>+
>+        m_webContext = adoptGRef(WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT, "memory-pressure-settings", s_memoryPressureSettings, nullptr)));
>+#else
>         GRefPtr<WebKitWebsiteDataManager> websiteDataManager = adoptGRef(webkit_website_data_manager_new(
>             "base-data-directory", dataDirectory(),
>             "base-cache-directory", dataDirectory(),
>@@ -127,12 +133,13 @@ public:
> 
>         m_webContext = adoptGRef(WEBKIT_WEB_CONTEXT(g_object_new(WEBKIT_TYPE_WEB_CONTEXT,
>             "website-data-manager", websiteDataManager.get(),
>-#if PLATFORM(GTK) && !USE(GTK4)
>+#if PLATFORM(GTK)
>             "process-swap-on-cross-site-navigation-enabled", TRUE,
>             "use-system-appearance-for-scrollbars", FALSE,
> #endif
>             "memory-pressure-settings", s_memoryPressureSettings,
>             nullptr)));
>+#endif
>         assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_webContext.get()));
>         g_signal_connect(m_webContext.get(), "initialize-web-extensions", G_CALLBACK(initializeWebExtensionsCallback), this);
>     }
>@@ -141,6 +148,9 @@ public:
>     {
>         g_signal_handlers_disconnect_matched(m_webContext.get(), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, this);
>         m_webContext = nullptr;
>+#if ENABLE(2022_GLIB_API)
>+        m_networkSession = nullptr;
>+#endif
>         if (m_watchedObjects.isEmpty())
>             return;
> 
>@@ -279,6 +289,9 @@ public:
> 
>     HashSet<GObject*> m_watchedObjects;
>     GRefPtr<WebKitWebContext> m_webContext;
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitNetworkSession> m_networkSession;
>+#endif
>     static GRefPtr<GDBusServer> s_dbusServer;
>     static Vector<GRefPtr<GDBusConnection>> s_dbusConnections;
>     static HashMap<uint64_t, GDBusConnection*> s_dbusConnectionPageMap;
>diff --git a/Tools/TestWebKitAPI/glib/WebKitGLib/WebViewTest.cpp b/Tools/TestWebKitAPI/glib/WebKitGLib/WebViewTest.cpp
>index ef22379a1a6d..ab7dba54dfa7 100644
>--- a/Tools/TestWebKitAPI/glib/WebKitGLib/WebViewTest.cpp
>+++ b/Tools/TestWebKitAPI/glib/WebKitGLib/WebViewTest.cpp
>@@ -52,13 +52,21 @@ void WebViewTest::initializeWebView()
> {
>     g_assert_null(m_webView);
> 
>+#if ENABLE(2022_GLIB_API)
>+    GRefPtr<WebKitNetworkSession> networkSession = shouldCreateEphemeralWebView ? adoptGRef(webkit_network_session_new_ephemeral()) : m_networkSession;
>+#endif
>+
>     m_webView = WEBKIT_WEB_VIEW(g_object_new(WEBKIT_TYPE_WEB_VIEW,
> #if PLATFORM(WPE)
>         "backend", Test::createWebViewBackend(),
> #endif
>         "web-context", m_webContext.get(),
>         "user-content-manager", m_userContentManager.get(),
>+#if ENABLE(2022_GLIB_API)
>+        "network-session", networkSession.get(),
>+#else
>         "is-ephemeral", shouldCreateEphemeralWebView,
>+#endif
>         nullptr));
> 
>     platformInitializeWebView();

Actions: View | Formatted Diff | Diff

Attachments on bug 222366: 464556 | 464576 | 464577 | 464608 | 464630